perf.c

Go to the documentation of this file.

#include "util.h"
#include "timing.h"


/**
  * \brief Testing the resolution of the rdtsc timing code
  */

int
Perf_CheckTimingCode (ClientData cd,
              Tcl_Interp * interp, int objc, Tcl_Obj * const objv[])
{
  util_timing_t t0, t1;

  util_timing_set (&t0);
  util_timing_pause_secs (0.0000005);
  util_timing_set (&t1);

  util_timing_t diffTime;

  diffTime = util_timing_diff (t1, t0);
  printf (" high - %u\tlow - %u\n", diffTime.high, diffTime.low);

  double T = util_timing_secs (diffTime);
  printf ("diff time in ns is %f\n", 1000000000.0 * T);
  return TCL_OK;

}



/**
  * \brief  Routine to determine machine dependent parameters
  */

int
Perf_CheckHardware (ClientData cd,
            Tcl_Interp * interp, int objc, Tcl_Obj * const objv[])
{
  printf ("This is 10 %d, and this is 010 %d\n", 10, 010);
  printf ("Size in bytes of onboard types:\n");
  printf ("char %d, short %d, int %d, long %d,",
      sizeof (char), sizeof (short), sizeof (int), sizeof (long));
  printf (" float %d, double %d, void* %d\n",
      sizeof (float), sizeof (double), sizeof (void *));

  // result on tyan is char 1, short 2, int 4, long 4, float 4, double 8, void* 4
  unsigned long Xlong;
  unsigned char *p;
  unsigned int i;

  // 11 22 33 44 big-endian
  // 44 33 22 11 little-endian

  Xlong = 0x11223344UL;

  p = (unsigned char *) &Xlong;

  for (i = 0; i < sizeof (long); i++)
    {
      printf ("%x ", *p++);
    }
  printf ("\n");

#if BYTE_ORDER == LITTLE_ENDIAN
  printf
    ("#if BYTE_ORDER == LITTLE_ENDIAN check shows it's a Little endian machine\n");
#endif

#if BYTE_ORDER == BIG_ENDIAN
  printf
    ("#if BYTE_ORDER == BIG_ENDIAN check shows it's a Big endian machine\n");
#endif

  // result on tyan is 44 33 22 11

  /* PoP fix for big-end/little-end problems is as follows: */

  // write:

  // unsigned short x;
  // putchar( x >> 8 ); // write high-order bytes
  // putchar( x & Oxff );  // write low-order bytes

  // read:

  // unsigned short x;
  // x = getchar() << 8; // read high-order bytes
  // x |= getchar & OxFF; // read low-order bytes

  unsigned int A = 1;
  char *pA = (char *) &A;
  printf
    ("A = %o ; A << 1 = %o ; A << 2 = %o ; A << 16 = %o ; A << 31 = %o\n", A,
     A << 1, A << 2, A << 16, A << 31);
  printf
    ("A = %ud ; A << 1 = %ud ; A << 2 = %ud ; A << 16 = %ud ; A << 31 = %ud\n",
     A, A << 1, A << 2, A << 16, A << 31);

  printf ("A = %x => *pA = %x ; *(pA+1)= %x ; *(pA+2) = %x ; *(pA+3)= %x\n",
      A, *pA, *(pA + 1), *(pA + 2), *(pA + 3));
  printf ("A = %x => *pA = %x ; *(pA-1)= %x ; *(pA-2) = %x ; *(pA-3)= %x\n",
      A, *pA, *(pA - 1), *(pA - 2), *(pA - 3));

  A = 1 << 3;
  printf ("A = %x => *pA = %x ; *(pA+1)= %x ; *(pA+2) = %x ; *(pA+3)= %x\n",
      A, *pA, *(pA + 1), *(pA + 2), *(pA + 3));
  printf ("A = %x => *pA = %x ; *(pA-1)= %x ; *(pA-2) = %x ; *(pA-3)= %x\n",
      A, *pA, *(pA - 1), *(pA - 2), *(pA - 3));

  return 0;
}


/**
  * \brief  Code from Jon Bentley's Programming Pearls book for measuring
  * times used by various C constructs.  http://www.cs.bell-labs.com/cm/cs/pearls/code.html
  *
  */

// #include <stdio.h>
// #include <time.h>
// #include <stdlib.h>
// #include <math.h>

// const int MAXN=100000;
#define MAXN 100000
static int x[MAXN];
static int startn = 5000;
static int n;

/* FUNCTIONS TO BE TIMED */

static int
intcmp (int *i, int *j)
{
  return *i - *j;
}

#define swapmac(i, j) { t = x[i]; x[i] = x[j]; x[j] = t; }

static void
swapfunc (int i, int j)
{
  int t = x[i];
  x[i] = x[j];
  x[j] = t;
}

#define maxmac(a, b) ((a) > (b) ? (a) : (b))

static int
maxfunc (int a, int b)
{
  return a > b ? a : b;
}


/* WORKHORSE */

#define T(s) printf("%s (n=%d)\n", s, n);
#define TRIALS 5
#define M(op)                           \
    printf(" %-22s", #op);              \
    k = 0;                              \
    timesum = 0;                        \
    for (ex = 0; ex < TRIALS; ex++) {   \
        start = clock();                \
        for (i = 1; i <= n; i++) {      \
            fi = (float) i;             \
            for (j = 1; j <= n; j++) {  \
                op;                     \
            }                           \
        }                               \
        t = clock()-start;              \
        printf("%6d", t);               \
        timesum += t;                   \
    }                                   \
    nans = 1e9 * timesum / ((double)    \
        n*n * TRIALS * CLOCKS_PER_SEC); \
    printf("%8.0f\n", nans);


int
Perf_TimePerf (ClientData cd,
           Tcl_Interp * interp, int objc, Tcl_Obj * const objv[])
{
  int i, j, k;
  float fi, fj, fk;
  int t, ex, timesum, start, globalstart;
  double nans;
  globalstart = clock ();
  for (i = 0; i < n; i++)
    x[i] = rand ();
  n = startn;
  printf ("C Time Cost Model, n=%d\n", n);
  printf ("CLOCKS_PER_SEC = %d\n", CLOCKS_PER_SEC);
  T ("Integer Arithmetic");
  M (
      {
      }
  );
  M (k++);
  M (k = i + j);
  M (k = i - j);
  M (k = i * j);
  M (k = i / j);
  M (k = i % j);
  M (k = i & j);
  M (k = i | j);
  T ("Floating Point Arithmetic");
  M (fj = j;
    );
  M (fj = j;
     fk = fi + fj;
    );
  M (fj = j;
     fk = fi - fj;
    );
  M (fj = j;
     fk = fi * fj;
    );
  M (fj = j;
     fk = fi / fj;
    );
  T ("Array Operations");
  M (k = i + j);
  M (k = x[i] + j);
  M (k = i + x[j]);
  M (k = x[i] + x[j]);
  T ("Comparisons");
  M (if (i < j) k++);
  M (if (x[i] < x[j]) k++);
  T ("Array Comparisons and Swaps");
  M (k = (x[i] < x[k]) ? -1 : 1);
  M (k = intcmp (x + i, x + j));
  M (swapmac (i, j));
  M (swapfunc (i, j));
  T ("Max Function, Macro and Inline");
  M (k = (i > j) ? i : j);
  M (k = maxmac (i, j));
  M (k = maxfunc (i, j));
  n = startn / 5;
  T ("Math Functions");
  M (fk = j + fi;
    );
  M (k = rand ();
    );
  M (fk = sqrt (j + fi));
  M (fk = sin (j + fi));
  M (fk = sinh (j + fi));
  M (fk = asin (j + fi));
  M (fk = cos (j + fi));
  M (fk = tan (j + fi));
  n = startn / 10;
  T ("Memory Allocation");
  M (free (malloc (16));
    );
  M (free (malloc (100));
    );
  M (free (malloc (2000));
    );

  /* Possible additions: input, output, malloc */
  printf ("  Secs: %4.2f\n",
      ((double) clock () - globalstart) / CLOCKS_PER_SEC);
  return TCL_OK;
}


/**
  * \brief Code for testing space usage of various C constructs.  From
  * Bentley (see above).
  */

#define MEASURE(T, text) {                  \
    printf("%s\t", text );      \
    printf("sizeof(%s) = %d\t", #T, sizeof(T) );                \
    int lastp = 0;                          \
    int i;  \
    for (i = 0; i < 11; i++) {          \
        T *p = (T *) malloc( sizeof( T ) );                     \
        int thisp = (int) p;                \
        if (lastp != 0)                     \
            printf(" %d ", thisp - lastp ); \
        lastp = thisp;                      \
    }                                       \
    printf("\n"); \
}

// Must use macros; templates give funny answers

/*
template <class T>
void measure(char *text)
{   cout << " measure: " << text << "\t";
    cout << sizeof(T) << "\n";
}

*/
typedef struct structc
{
  char c;
} structc;
typedef struct structic
{
  int i;
  char c;
} structic;
// struct structip { int i; structip *p; };
typedef struct structip
{
  int i;
  void *p;
} structip;
typedef struct structdc
{
  double d;
  char c;
} structdc;
typedef struct structcd
{
  char c;
  double d;
} structcd;
typedef struct structcdc
{
  char c1;
  double d;
  char c2;
} structcdc;
typedef struct structiii
{
  int i1;
  int i2;
  int i3;
} structiii;
typedef struct structiic
{
  int i1;
  int i2;
  char c;
} structiic;
typedef struct structc12
{
  char c[12];
} structc12;
typedef struct structc13
{
  char c[13];
} structc13;
typedef struct structc28
{
  char c[28];
} structc28;
typedef struct structc29
{
  char c[29];
} structc29;
typedef struct structc44
{
  char c[44];
} structc44;
typedef struct structc45
{
  char c[45];
} structc45;
typedef struct structc60
{
  char c[60];
} structc60;
typedef struct structc61
{
  char c[61];
} structc61;

int
Perf_SpacePerf (ClientData cd,
        Tcl_Interp * interp, int objc, Tcl_Obj * const objv[])
{

//      cout << "Raw sizeof";
//      cout << "\nsizeof(char)="     << sizeof(char);  
//      cout << "  sizeof(short)="    << sizeof(short);
//      cout << "  sizeof(int)="      << sizeof(int);
//      cout << "\nsizeof(float)="    << sizeof(float);
//      cout << "  sizeof(struct *)=" << sizeof(structc *);
//      cout << "  sizeof(long)="     << sizeof(long);
//      cout << "\nsizeof(double)="   << sizeof(double);
  printf ("Raw sizeof\n");
  printf ("sizeof(char)=%d\n", sizeof (char));
  printf ("sizeof(short)=%d\n", sizeof (short));
  printf ("sizeof(int)=%d\n", sizeof (int));
  printf ("sizeof(float)=%d\n", sizeof (float));
  printf ("sizeof(void *)=%d\n", sizeof (void *));
  printf ("sizeof(long)=%d\n", sizeof (long));
  printf ("sizeof(double)=%d\n", sizeof (double));

  // cout << "\n\nMEASURE macro\n";
  printf ("\n\nMEASURE macro\n");
  MEASURE (int, "int\t");
  MEASURE (structc, "structc\t");
  MEASURE (structic, "structic");
  MEASURE (structip, "structip");
  MEASURE (structdc, "structdc");
  MEASURE (structcd, "structcd");
  MEASURE (structcdc, "structcdc");
  MEASURE (structiii, "structiii");
  MEASURE (structiic, "structiic");
  MEASURE (structc12, "structc12");
  MEASURE (structc13, "structc13");
  MEASURE (structc28, "structc28");
  MEASURE (structc29, "structc29");
  MEASURE (structc44, "structc44");
  MEASURE (structc45, "structc45");
  MEASURE (structc60, "structc60");
  MEASURE (structc61, "structc61");

/*  
    cout << "\nmeasure template (strange results)\n";
    // Uncomment below lines to see answers change
    measure<int>("int");
    measure<structc>("structc");
    measure<structic>("structic");
    */
  return TCL_OK;
}


/**
  * \brief Another version of a timing program
  * from www/cs/vu.nl/pub/leendert/cputimes.c
  */

/* cputimes.c -- produce a 1-page summary of cpu times of various C constructs
 * To port to a new machine, change the following:
 *      BASEN:  Start around 10000, increase by *10 until no question marks
 *      Macro processor: define ANSIIMAC 1 for Ansii C, undef for old C
 *      WARNRANGE: print ? after CPU time if max clicks - min clicks >
 *                 WARNRANGE * mean clicks
 *      Times: typical values of CLOCKS_PER_SEC: Vax=60  Cray=105296000
 *      For large values, change %5d in macro loop1, 99999 in minclicks;
 *  10 Oct 1990  Bentley, Kernighan, Van Wyk
 *  13 Jan 1991  ANSI C edit by Grosse;  avoid common ungetc bug in scanf;
 *      clean up junk file;
 *  14 May 1993  Leendert van Doorn, cleaned it up even further.
 */

#include <stdio.h>
#include <math.h>
#include <time.h>

// AA #define BASEN 1000000
#define BASEN 100000000
#define WARNRANGE 0.4

#ifndef CLOCKS_PER_SEC
#define CLOCKS_PER_SEC  60
#endif

#ifdef __STDC__
#define quoted(TEXT) #TEXT
#else
#define quoted(TEXT) "TEXT"
#endif

struct stacknode
{
  int val;
  struct stacknode *next;
};
typedef struct stacknode *Stackp;
Stackp stackroot;

void
push (int i)
{
  Stackp p;

  p = (Stackp) malloc (sizeof (struct stacknode));
  p->val = i;
  p->next = stackroot;
  stackroot = p;
}

int
pop ()
{
  int i;

  i = stackroot->val;
  stackroot = stackroot->next;
  return i;
}

/* Main macros for experiments */


#define loop1(CODE) loop1ctr++; \
        for (i = 0; i < n; i++) { CODE; } \
        loop1next = clock(); \
        thisclicks = loop1next - loop1start; \
        sumclicks += thisclicks; \
        if (thisclicks < minclicks) minclicks = thisclicks; \
        if (thisclicks > maxclicks) maxclicks = thisclicks; \
        printf("%5d", (loop1next - loop1start)/1000); \
        loop1start = loop1next;

#define loop(CODE) printf("  %-30s", quoted(CODE)); \
        minclicks = 99999999; maxclicks = -1; sumclicks = 0; \
        loop1ctr = 0; \
        loop1start = clock(); \
        loop1(CODE) \
        loop1(CODE) \
        i0 = i1 + i2 + i3; \
        loop1(CODE) \
        i0 = i1 + i2 + i3 - i1 - i2 - i3; \
        loop1(CODE) \
        i0 = i1 + i2 + i3 + i1*i2 + i2*i3 + i1*i3; \
        loop1(CODE) \
        queststr = ""; \
        if (loop1ctr * (float)(maxclicks - minclicks) > WARNRANGE *  sumclicks) \
                queststr = "?"; \
        lastmics = sumclicks * 1000000.0 / ((float)(CLOCKS_PER_SEC) * n * loop1ctr); \
        printf("%10.6f%s\n", lastmics - basemics, queststr);

#define title(TEXT) printf("%s (n=%d)\n", TEXT, n);

/* The experiment */

int
sum1 (int a)
{
  return a;
}

int
sum2 (int a, int b)
{
  return a + b;
}

int
sum3 ( int a,  int b,  int c)
{
  return a + b + c;
}

int
Perf_TimePerf2 (ClientData cd,
        Tcl_Interp * interp, int objc, Tcl_Obj * const objv[])
{
  int loop1start, loop1next, loop1ctr;
  float lastmics, basemics;
  int minclicks, maxclicks, sumclicks, thisclicks;
  int i, n, basen;
  int i0, i1, i2, i3, i4;
  float f0, f1, f2, f3;
  int *v;
  char *queststr;
  char s[100];
  char fname[20];
  FILE *fp;
  /* The following strings are variables because some macro processors
     don't handle quoted strings in quoted arguments.
     They are not just pointers to string literals because some
     scanf's write on their input. */
  char s0123456789[20];
  char sa123456789[20];
  char s12345[20];
  char s123_45[20];
  char sd[20];
  char sdn[20];
  char sf[20];
  char sf62[20];
  strcpy (s0123456789, "0123456789");
  strcpy (sa123456789, "a123456789");
  strcpy (s12345, "12345");
  strcpy (s123_45, "123.45");
  strcpy (sd, "%d");
  strcpy (sdn, "%d\n");
  strcpy (sf, "%f");
  strcpy (sf62, "%f6.2");

  setbuf (stdout, (char *) 0);  /* No buffering to watch output */
  printf ("  Operation                         Clicks for each trial ");
  printf ("   Mics/N\n");

  basen = BASEN;
  n = basen;
  title ("Null Loop") i0 = i1 = i2 = i3 = 5;
  f0 = f1 = f2 = f3 = 5.0;
  basemics = 0.0;
  loop (
     {
     });
  basemics = lastmics;

  title ("Int Operations");
  i1 = i2 = i3 = 5;
  loop (i1++)
    loop (i1 = i2)
    loop (i1 = i2 + i3)
    loop (i1 = i2 - i3)
    loop (i1 = i2 * i3)
    loop (i1 = i2 / i3) loop (i1 = i2 % i3) title ("Float Operations");
  f1 = f2 = f3 = 5.0;
  loop (f1 = f2)
    loop (f1 = f2 + f3)
    loop (f1 = f2 - f3)
    loop (f1 = f2 * f3) loop (f1 = f2 / f3) title ("Numeric Conversions");
  f1 = 123456.789;
  i1 = 123456;
  loop (i1 = f1) loop (f1 = i1) title ("Integer Vector Operations");
  v = (int *) malloc (n * sizeof (int));
  if (v == NULL)
    {
      printf ("Malloc of %d bytes failed\n", n * sizeof (int));
      exit (1);
    }
  for (i = 0; i < n; i++)
    v[i] = 0;
  loop (v[i] = i) loop (v[v[i]] = i) loop (v[v[v[i]]] = i) free (v);

  title ("Control Structures");
  i1 = i2 = i3 = 5;
  loop (if (i == 5) i1++)
    loop (if (i != 5) i1++)
      loop (while (i < 0) i1++)
    loop (i1 = sum1 (i2))
      loop (i1 = sum2 (i2, i3))
      loop (i1 = sum3 (i2, i3, i4)) n = basen / 100;
  strcpy (fname, "junk");
  title ("Input/Output");
  strcpy (s, "1234\n");
  fp = fopen (fname, "w");
  loop ( fputs (s, fp) ) close ( (int) fp);
  fp = fopen (fname, "r");
  loop (fgets (s, 9, fp)) close ( (int) fp);
  fp = fopen (fname, "w");
  loop (fprintf (fp, sdn, i)) close ( (int) fp);
  fp = fopen (fname, "r");
  loop (fscanf (fp, sd, &i1)) close ( (int) fp);
  unlink (fname);

  n = basen / 100;
  title ("Malloc");
  loop (free (malloc (8))) loop (push (i)) loop (i1 = pop ())n = basen / 10;
  title ("String Functions");
  loop (strcpy (s, s0123456789))
    loop (i1 = strcmp (s, s))
    loop (i1 = strcmp (s, sa123456789)) n = basen / 100;
  title ("String/Number Conversions");
  loop (i1 = atoi (s12345))
    loop (sscanf (s12345, sd, &i1))
    loop (sprintf (s, sd, i))
    loop (f1 = atof (s123_45))
    loop (sscanf (s123_45, sf, &f1))
    loop (sprintf (s, sf62, 123.45)) n = basen / 100;
  title ("Math Functions");
  loop (i1 = rand ())f2 = 5.0;
  loop (f1 = log (f2))
    loop (f1 = exp (f2))
    loop (f1 = sin (f2)) loop (f1 = sqrt (f2)) return TCL_OK;
}