RTServerImpl.cc

Go to the documentation of this file.

/*
 * RTServerImpl.cc
 *
 * Copyright (c) 2003, 2004 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 RTServerImpl.cc
 *
 * Implementation of the RTServerImpl class.
 */

#include "config.h"

#include <stdlib.h>
#include <assert_pp.h>

#include <iostream>

#include <sys/time.h>
#include <sys/resource.h>
#include <unistd.h>

#include "RTServerImpl.hh"

using namespace std;

/* Note: Most of this was harvested from hourglass. */

/**
 * Type used for cycle counter values.
 */
typedef signed long long int cycle_time;

/**
 * Type used for time value in microseconds.
 */
typedef double us_time;

/**
 * The CPU frequency for this machine, in megahertz.
 */
static double MHZ;

#ifdef WIN32
/**
 * The acceptable difference in successive guesses of the machines Mhz.
 * Unfortunately, win2k needs a higher value than usual.
 *
 * @sa FindMHZ
 */
#define MHZ_SLOP 5
#else
/**
 * The acceptable difference in successive guesses of the machines Mhz.
 *
 * @sa FindMHZ
 */
#define MHZ_SLOP 2
#endif

/**
 * @return The current value of the x86 timestamp counter.
 */
static inline cycle_time rdtsc (void)
{
  cycle_time d;
  __asm__ __volatile__ ("rdtsc" : "=A" (d) );
  return d;
}

/**
 * Convert a cycle count value generated by rdtsc to a microsecond value.
 *
 * @param c The cycle value to convert.
 * @return The 'c' value converted to microseconds.
 */
static inline us_time cycle_to_us (cycle_time c)
{
  return c / (us_time)MHZ;
}

/**
 * Convert a microsecond value to cycle count value.
 *
 * @param us The microsecond value to convert.
 * @return The 'us' value converted to a cycle count.
 */
static inline cycle_time us_to_cycle (us_time us)
{
  return (cycle_time)us * (cycle_time)MHZ;
}

/**
 * @return The current time of day in microseconds.
 */
static us_time get_timeval_us(void)
{
  struct timeval tv;
  us_time t;
  
  gettimeofday (&tv, NULL);
  t = tv.tv_usec + (1000000 * tv.tv_sec);
  return t;
}

/**
 * @param d A double value.
 * @return The absolute value of d.
 */
static double my_fabs (double d)
{
  if (d < 0) {
    return -d;
  } else {
    return d;
  }
}

/**
 * @return The detected Mhz for the machine where this is running.
 */
static double FindMHZ(void)
{
    double last_freq, freq = 0;
    int i;
    int good = 0;
    us_time us_start, us_stop, us_diff;
    cycle_time cycle_start, cycle_stop, cycle_diff;

    setpriority(PRIO_PROCESS, 0, 20);
    
    for( i = 0; i < 100; i++ )
    {
        // estimate MHz
        
        us_start = get_timeval_us ();
        cycle_start = rdtsc ();
        
        /*
         * ugh -- sleeping permits some laptops to power down their
         * processors, which screws up the measurements -- so busy-wait
         * instead
         */
#if 0
        usleep (1000);
#else
        {
            volatile int x;
            
            for (x=0; x < 5*1000*1000; x++);
        }
#endif
        
        us_stop = get_timeval_us ();
        cycle_stop = rdtsc ();
        
        us_diff = us_stop - us_start;
        cycle_diff = cycle_stop - cycle_start;
        
        last_freq = freq;
        freq = cycle_diff / us_diff;
        
        // wait for three successive values within range
        
        if (my_fabs (last_freq - freq) < MHZ_SLOP) {
            good++;
            if (good == 3) {
                setpriority(PRIO_PROCESS, 0, 0);
                return freq;
            }
        } else {
            good = 0;
        }
    }
    
    cerr << "couldn't determine MHz of this processor: try reducing\n";
    cerr << "machine load.\n";
    
    exit (EXIT_FAILURE);
}

RTServerImpl::RTServerImpl(CORBA::ULong deadline_us,
                           const CORBA::ULong *compute_us,
                           unsigned int compute_us_length)
{
    require(compute_us != NULL);
    
    this->rts_Deadline = deadline_us;
    this->rts_Compute.data = compute_us;
    this->rts_Compute.length = compute_us_length;
    this->rts_Compute.index = 0;
    if( MHZ == 0.0 )
    {
        MHZ = FindMHZ();
        cerr << "CPU frequency: " << MHZ << "Mhz" << endl;
    }
}

void RTServerImpl::Periodic(void)
    throw (CORBA::SystemException)
{
    cycle_time last, curr, diff, total;

    total = us_to_cycle(this->rts_Compute.data[this->rts_Compute.index]);
    this->rts_Compute.index = ((this->rts_Compute.index + 1) %
                               this->rts_Compute.length);
    last = rdtsc();
    do {
        curr = rdtsc();
        diff = curr - last;
        if( diff > us_to_cycle(1.0) )
        {
            curr = rdtsc();
            /* gap... */
        }
        else
        {
            total -= diff;
        }
        last = curr;
    } while( total > 0 );
}

---