clock.c

/* 
 * clock.c - Routines for using the cycle counters on x86, 
 *           Alpha, and Sparc boxes.
 * 
 * Copyright (c) 2002, R. Bryant and D. O'Hallaron, All rights reserved.
 * May not be used, modified, or copied without permission.
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/times.h>
#include "clock.h"


/******************************************************* 
 * Machine dependent functions 
 *
 * Note: the constants __i386__ and  __alpha
 * are set by GCC when it calls the C preprocessor
 * You can verify this for yourself using gcc -v.
 *******************************************************/

#if defined(__i386__)  
/*******************************************************
 * Pentium versions of start_counter() and get_counter()
 *******************************************************/


/* $begin x86cyclecounter */
/* Initialize the cycle counter */
static unsigned cyc_hi = 0;
static unsigned cyc_lo = 0;


/* Set *hi and *lo to the high and low order bits  of the cycle counter.  
	Implementation requires assembly code to use the rdtsc instruction. */
void access_counter(unsigned *hi, unsigned *lo)
{
	asm("rdtsc; movl %%edx,%0; movl %%eax,%1"   /* Read cycle counter */
			: "=r" (*hi), "=r" (*lo)                /* and move results to */
			: /* No input */                        /* the two outputs */
			: "%edx", "%eax");
}

/* Record the current value of the cycle counter. */
void start_counter()
{
	access_counter(&cyc_hi, &cyc_lo);
}

/* Return the number of cycles since the last call to start_counter. */
double get_counter()
{
	unsigned ncyc_hi, ncyc_lo;
	unsigned hi, lo, borrow;
	double result;

	/* Get cycle counter */
	access_counter(&ncyc_hi, &ncyc_lo);

	/* Do double precision subtraction */
	lo = ncyc_lo - cyc_lo;
	borrow = lo > ncyc_lo;
	hi = ncyc_hi - cyc_hi - borrow;
	result = (double) hi * (1 << 30) * 4 + lo;
	if (result < 0) {
		fprintf(stderr, "Error: counter returns neg value: %.0f\n", result);
	}
	return result;
}
/* $end x86cyclecounter */

#elif defined(__alpha)

/****************************************************
 * Alpha versions of start_counter() and get_counter()
 ***************************************************/

/* Initialize the cycle counter */
static unsigned cyc_hi = 0;
static unsigned cyc_lo = 0;


/* Use Alpha cycle timer to compute cycles.  Then use
	measured clock speed to compute seconds 
 */

/*
 * counterRoutine is an array of Alpha instructions to access 
 * the Alpha's processor cycle counter. It uses the rpcc 
 * instruction to access the counter. This 64 bit register is 
 * divided into two parts. The lower 32 bits are the cycles 
 * used by the current process. The upper 32 bits are wall 
 * clock cycles. These instructions read the counter, and 
 * convert the lower 32 bits into an unsigned int - this is the 
 * user space counter value.
 * NOTE: The counter has a very limited time span. With a 
 * 450MhZ clock the counter can time things for about 9 
 * seconds. */
static unsigned int counterRoutine[] =
{
	0x601fc000u,
	0x401f0000u,
	0x6bfa8001u
};

/* Cast the above instructions into a function. */
static unsigned int (*counter)(void)= (void *)counterRoutine;


void start_counter()
{
	/* Get cycle counter */
	cyc_hi = 0;
	cyc_lo = counter();
}

double get_counter()
{
	unsigned ncyc_hi, ncyc_lo;
	unsigned hi, lo, borrow;
	double result;
	ncyc_lo = counter();
	ncyc_hi = 0;
	lo = ncyc_lo - cyc_lo;
	borrow = lo > ncyc_lo;
	hi = ncyc_hi - cyc_hi - borrow;
	result = (double) hi * (1 << 30) * 4 + lo;
	if (result < 0) {
		fprintf(stderr, "Error: Cycle counter returning negative value: %.0f\n", result);
	}
	return result;
}

#else

/****************************************************************
 * All the other platforms for which we haven't implemented cycle
 * counter routines. Newer models of sparcs (v8plus) have cycle
 * counters that can be accessed from user programs, but since there
 * are still many sparc boxes out there that don't support this, we
 * haven't provided a Sparc version here.
 ***************************************************************/

void start_counter()
{
	printf("ERROR: You are trying to use a start_counter routine in clock.c\n");
	printf("that has not been implemented yet on this platform.\n");
	printf("Please choose another timing package in config.h.\n");
	exit(1);
}

double get_counter() 
{
	printf("ERROR: You are trying to use a get_counter routine in clock.c\n");
	printf("that has not been implemented yet on this platform.\n");
	printf("Please choose another timing package in config.h.\n");
	exit(1);
}
#endif




/*******************************
 * Machine-independent functions
 ******************************/
double ovhd()
{
	/* Do it twice to eliminate cache effects */
	int i;
	double result;

	for (i = 0; i < 2; i++) {
		start_counter();
		result = get_counter();
	}
	return result;
}

/* $begin mhz */
/* Estimate the clock rate by measuring the cycles that elapse */ 
/* while sleeping for sleeptime seconds */
double mhz_full(int verbose, int sleeptime)
{
	double rate;

	start_counter();
	sleep(sleeptime);
	rate = get_counter() / (1e6*sleeptime);
	if (verbose) 
		printf("Processor clock rate ~= %.1f MHz\n", rate);
	return rate;
}
/* $end mhz */

/* Version using a default sleeptime */
double mhz(int verbose)
{
	return mhz_full(verbose, 2);
}

/** Special counters that compensate for timer interrupt overhead */

static double cyc_per_tick = 0.0;

#define NEVENT 100
#define THRESHOLD 1000
#define RECORDTHRESH 3000

/* Attempt to see how much time is used by timer interrupt */
static void callibrate(int verbose)
{
	double oldt;
	struct tms t;
	clock_t oldc;
	int e = 0;

	times(&t);
	oldc = t.tms_utime;
	start_counter();
	oldt = get_counter();
	while (e <NEVENT) {
		double newt = get_counter();

		if (newt-oldt >= THRESHOLD) {
			clock_t newc;
			times(&t);
			newc = t.tms_utime;
			if (newc > oldc) {
				double cpt = (newt-oldt)/(newc-oldc);
				if ((cyc_per_tick == 0.0 || cyc_per_tick > cpt) && cpt > RECORDTHRESH)
					cyc_per_tick = cpt;
				/*
					if (verbose)
					printf("Saw event lasting %.0f cycles and %d ticks.  Ratio = %f\n",
					newt-oldt, (int) (newc-oldc), cpt);
				 */
				e++;
				oldc = newc;
			}
			oldt = newt;
		}
	}
	if (verbose)
		printf("Setting cyc_per_tick to %f\n", cyc_per_tick);
}

static clock_t start_tick = 0;

void start_comp_counter() 
{
	struct tms t;

	if (cyc_per_tick == 0.0)
		callibrate(0);
	times(&t);
	start_tick = t.tms_utime;
	start_counter();
}

double get_comp_counter() 
{
	double time = get_counter();
	double ctime;
	struct tms t;
	clock_t ticks;

	times(&t);
	ticks = t.tms_utime - start_tick;
	ctime = time - ticks*cyc_per_tick;
	/*
		printf("Measured %.0f cycles.  Ticks = %d.  Corrected %.0f cycles\n",
		time, (int) ticks, ctime);
	 */
	return ctime;
}