rt_client.cc

Go to the documentation of this file.

/*
 * rt_client.cc
 *
 * Copyright (c) 2003 The University of Utah and the Flux Group.
 * All rights reserved.
 *
 * This file is licensed under the terms of the GNU Public License.  
 * See the file "license.terms" for restrictions on redistribution 
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 */

/**
 * @file rt_client.cc
 *
 * CORBA Client used to drive the real-time synthetic server.
 *
 * @sa RTServer.idl
 * @sa rt_server.cc
 */

#include "config.h"

#include <errno.h>

#if TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# if HAVE_SYS_TIME_H
#  include <sys/time.h>
# else
#  include <time.h>
# endif
#endif

#include <time_util.h>

#include <iostream>

#include "RTServerC.h"

#if !defined(timespecclear)
/**
 * Clear a timespec structure.
 *
 * @param tvp Pointer to the timespec object to clear.
 */
#define timespecclear(tvp)      ((tvp)->tv_sec = (tvp)->tv_nsec = 0)

/**
 * Test if a timespec has non-zero values.
 *
 * @param tvp Pointer to the timespec object to check.
 */
#define timespecisset(tvp)      ((tvp)->tv_sec || (tvp)->tv_nsec)

/**
 * Compare two timespec structures.
 *
 * @param tvp Pointer to the 'left hand side' of the comparison.
 * @param uvp Pointer to the 'right hande side' of the comparison.
 * @param cmp The comparison operator.  (e.g. '<', '>', ...)
 */
#define timespeccmp(tvp, uvp, cmp)                                      \
        (((tvp)->tv_sec == (uvp)->tv_sec) ?                             \
            ((tvp)->tv_nsec cmp (uvp)->tv_nsec) :                       \
            ((tvp)->tv_sec cmp (uvp)->tv_sec))

/**
 * Add one timespec to another.
 *
 * @param vvp Pointer to the timespec that will be added to.
 * @param uvp Pointer to the timespec to add.
 */
#define timespecadd(vvp, uvp)                                           \
        do {                                                            \
                (vvp)->tv_sec += (uvp)->tv_sec;                         \
                (vvp)->tv_nsec += (uvp)->tv_nsec;                       \
                if ((vvp)->tv_nsec >= 1000000000) {                     \
                        (vvp)->tv_sec++;                                \
                        (vvp)->tv_nsec -= 1000000000;                   \
                }                                                       \
        } while (0)

/**
 * Subtract one timespec from another.
 *
 * @param vvp Pointer to the timespec that will be subtracted from.
 * @param uvp Pointer to the timespec to subtract.
 */
#define timespecsub(vvp, uvp)                                           \
        do {                                                            \
                (vvp)->tv_sec -= (uvp)->tv_sec;                         \
                (vvp)->tv_nsec -= (uvp)->tv_nsec;                       \
                if ((vvp)->tv_nsec < 0) {                               \
                        (vvp)->tv_sec--;                                \
                        (vvp)->tv_nsec += 1000000000;                   \
                }                                                       \
        } while (0)
#endif

/**
 * The CORBA ORB for this process.
 */
static CORBA::ORB_var orb;

/**
 * Handle SIGALRM signal by exiting.
 *
 * @param sig The actual signal received.
 */
static void sigalrm_handler(int sig)
{
    orb->shutdown();
    
    exit(0);
}

int main(int argc, char *argv[])
{
    int retval = EXIT_FAILURE;

    try
    {
        const char *server_ior = "file://rtserver.ior";
        CORBA::ULong period = 1000000;
        unsigned long run_time = 0;
        struct timespec interval;
        int ch, g2g = 1;

        /* Start up the ORB, */
        orb = CORBA::ORB_init(argc, argv);

        /* process the arguments, and */
        while( ((ch = getopt(argc, argv, "hVf:s:P:")) != -1) && g2g )
        {
            switch( ch )
            {
            case 'f':
                {
                    unsigned long long run_time_ull;
                    
                    if( string_to_microsec(&run_time_ull, optarg) )
                    {
                        run_time = run_time_ull;
                    }
                    else
                    {
                        cerr << "Run for value not a time: "
                             << period
                             << endl;
                        throw CORBA::BAD_PARAM();
                    }
                }
                break;
            case 's':
                if( strlen(optarg) == 0 )
                {
                    cerr << "Server IOR is empty" << endl;
                    throw CORBA::BAD_PARAM();
                }
                server_ior = optarg;
                break;
            case 'P':
                {
                    unsigned long long period_ull;
                    
                    if( string_to_microsec(&period_ull, optarg) )
                    {
                        period = period_ull;
                    }
                    else
                    {
                        cerr << "Period value is not a number: "
                             << optarg
                             << endl;
                        throw CORBA::BAD_PARAM();
                    }
                }
                break;
            case 'V':
                cout << PACKAGE_VERSION << endl;
                exit(0);
                break;
            case 'h':
            case '?':
            default:
                g2g = 0;
                break;
            }
        }

        /* ... continue if we are good to go. */
        if( g2g )
        {
            interval.tv_sec = period / 1000000;
            interval.tv_nsec = (period % 1000000) * 1000;
            
            if( run_time > 0 )
            {
                struct itimerval itv;
                
                signal(SIGALRM, sigalrm_handler);
                itv.it_interval.tv_sec = 0;
                itv.it_interval.tv_usec = 0;
                itv.it_value.tv_sec = run_time / 1000000;
                itv.it_value.tv_usec = run_time % 1000000;
                if( setitimer(ITIMER_REAL, &itv, NULL) < 0 )
                {
                    perror("setitimer");
                }
            }
            
            CORBA::Object_var obj = orb->string_to_object(server_ior);
            
            RTServer_var rts;
            
            rts = RTServer::_narrow(obj.in());
            if( CORBA::is_nil(rts.in()) )
            {
                cerr << "Invalid RTServer IOR: " << endl;
                throw CORBA::BAD_PARAM();
            }
            else
            {
                struct timespec start, end, next;
                int eventCount = 1;
                
                for( ;; )
                {
                    clock_gettime(CLOCK_REALTIME, &start);
                    next = start;
                    timespecadd(&next, &interval);
                    rts->Periodic();
                    clock_gettime(CLOCK_REALTIME, &end);
                    timespecsub(&next, &end);
                    
                    timespecsub(&end, &interval);
                    eventCount -= 1;
                    while( timespeccmp(&start, &end, <) )
                    {
                        timespecsub(&end, &interval);
                        eventCount += 1;
                    }
#if defined(DEBUG)
                    cout << "Queued Events = " << eventCount << endl;
#endif
                    if( eventCount == 0 )
                    {
                        int rc;
                        
                        while( (rc = nanosleep(&next, NULL)) == -1 )
                        {
                            perror("nanosleep");
                            
                            ensure(errno == EINTR);
                        }
                        eventCount += 1;
                    }
                }
                
                retval = EXIT_SUCCESS;
            }
        }
    }
    catch(const CORBA::SystemException &e)
    {
        cerr << "Caught Exception: " << e << endl;
    }
    catch(...)
    {
        cerr << "Caught an unhandled exception" << endl;
    }
    return( retval );
}

---