testcode.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	ALL_OK   0
#define	CODE_UNIMPLEMENTED   -1
#define	ERROR_RESULT   -2

Functions
int	instructions_million (void)
int	instructions_fldcw (void)
int	instructions_rep (void)
int	branches_testcode (void)
int	random_branches_testcode (int number, int quiet)
int	flops_float_init_matrix (void)
float	flops_float_matrix_matrix_multiply (void)
float	flops_float_swapped_matrix_matrix_multiply (void)
int	flops_double_init_matrix (void)
double	flops_double_matrix_matrix_multiply (void)
double	flops_double_swapped_matrix_matrix_multiply (void)
double	do_flops3 (double x, int iters, int quiet)
double	do_flops (int n, int quiet)
int	cache_write_test (double *array, int size)
double	cache_read_test (double *array, int size)
int	cache_random_write_test (double *array, int size, int count)
double	cache_random_read_test (double *array, int size, int count)
double	do_cycles (int minimum_time)

Macro Definition Documentation

ALL_OK

#define ALL_OK   0

Definition at line 1 of file testcode.h.

CODE_UNIMPLEMENTED

#define CODE_UNIMPLEMENTED   -1

Definition at line 2 of file testcode.h.

ERROR_RESULT

#define ERROR_RESULT   -2

Definition at line 3 of file testcode.h.

Function Documentation

branches_testcode()

int branches_testcode

(

void

)

Definition at line 11 of file branches_testcode.c.

                            {

#if defined(__i386__) || (defined __x86_64__)
    asm(    "\txor %%ecx,%%ecx\n"
        "\tmov $500000,%%ecx\n"
        "test_loop:\n"
        "\tjmp test_jmp\n"
        "\tnop\n"
        "test_jmp:\n"
        "\txor %%eax,%%eax\n"
        "\tjnz test_jmp2\n"
        "\tinc %%eax\n"
        "test_jmp2:\n"
        "\tdec %%ecx\n"
        "\tjnz test_loop\n"
        : /* no output registers */
        : /* no inputs */
        : "cc", "%ecx", "%eax" /* clobbered */
    );
        return 0;

#elif defined(__arm__)
    /* Initial code contributed by sam wang linux.swang _at_ gmail.com */
    asm(    "\teor r3,r3,r3\n"
        "\tldr r3,=500000\n"
            "test_loop:\n"
        "\tB test_jmp\n"
        "\tnop\n"
        "test_jmp:\n"
        "\teor r2,r2,r2\n"
        "\tcmp r2,#1\n"
        "\tbge test_jmp2\n"
        "\tnop\n"
        "\tadd r2,r2,#1\n"
        "test_jmp2:\n"
        "\tsub r3,r3,#1\n"
        "\tcmp r3,#1\n"
        "\tbgt test_loop\n"
        : /* no output registers */
        : /* no inputs       */
        : "cc", "r2", "r3" /* clobbered */
    );

    return 0;
#elif defined(__aarch64__)
    asm(    "\teor x3,x3,x3\n"
        "\tldr x3,=500000\n"
        "test_loop:\n"
        "\tB test_jmp\n"
        "\tnop\n"
        "test_jmp:\n"
        "\teor x2,x2,x2\n"
        "\tcmp x2,#1\n"
        "\tbge test_jmp2\n"
        "\tnop\n"
        "\tadd x2,x2,#1\n"
        "test_jmp2:\n"
        "\tsub x3,x3,#1\n"
        "\tcmp x3,#1\n"
        "\tbgt test_loop\n"
        : /* no output registers */
        : /* no inputs       */
        : "cc", "x2", "x3" /* clobbered */
    );

    return 0;
#elif defined(__powerpc__)
    /* Not really optimized */

    asm(    "\txor  3,3,3\n"
        "\tlis  3,500000@ha\n"
        "\taddi 3,3,500000@l\n"
            "test_loop:\n"
        "\tb    test_jmp\n"
        "\tnop\n"
        "test_jmp:\n"
        "\txor  4,4,4\n"
        "\tcmpwi    cr0,4,1\n"
        "\tbge  test_jmp2\n"
        "\tnop\n"
        "\taddi 4,4,1\n"
        "test_jmp2:\n"
        "\taddi 3,3,-1\n"
        "\tcmpwi    cr0,3,1\n"
        "\tbgt  test_loop\n"
        : /* no output registers */
        : /* no inputs       */
        : "cr0", "r3", "r4" /* clobbered */
    );

    return 0;
#endif

    return -1;

}

cache_random_read_test()

double cache_random_read_test	(	double *	array,
		int	size,
		int	count
	)

Definition at line 38 of file cache_testcode.c.

                                                                  {

    int i;
    double sum=0;

    for(i=0; i<count; i++) {
        sum+= array[random()%size];
    }

    return sum;
}

cache_random_write_test()

int cache_random_write_test	(	double *	array,
		int	size,
		int	count
	)

Definition at line 28 of file cache_testcode.c.

                                                                {
    int i;

    for(i=0; i<count; i++) {
        array[random()%size]=(double)i;
    }

    return 0;
}

cache_read_test()

double cache_read_test	(	double *	array,
		int	size
	)

Definition at line 16 of file cache_testcode.c.

                                                {

    int i;
    double sum=0;

    for(i=0; i<size; i++) {
        sum+= array[i];
    }

    return sum;
}

cache_write_test()

int cache_write_test	(	double *	array,
		int	size
	)

Definition at line 6 of file cache_testcode.c.

                                              {
    int i;

    for(i=0; i<size; i++) {
        array[i]=(double)i;
    }

    return 0;
}

do_cycles()

double do_cycles

(

int

minimum_time

)

Definition at line 8 of file busy_work.c.

{
    struct timeval start, now;
    double x, sum;

    gettimeofday( &start, NULL );

    for ( ;; ) {
        sum = 1.0;
        for ( x = 1.0; x < 250000.0; x += 1.0 ) {
            sum += x;
        }
        if ( sum < 0.0 ) {
            printf( "==>>  SUM IS NEGATIVE !!  <<==\n" );
        }

        gettimeofday( &now, NULL );
        if ( now.tv_sec >= start.tv_sec + minimum_time ) {
            break;
        }
    }
    return sum;
}

Here is the call graph for this function:

do_flops()

double do_flops	(	int	n,
		int	quiet
	)

Definition at line 184 of file flops_testcode.c.

{
        int i;
        double c = 0.11;

        for ( i = 0; i < n; i++ ) {
                c += a * b;
        }

    if (!quiet) printf("%lf\n",c);

    return c;
}

do_flops3()

double do_flops3	(	double	x,
		int	iters,
		int	quiet
	)

Definition at line 142 of file flops_testcode.c.

{
    int i;
    double w, y, z, a, b, c, d, e, f, g, h;
    double result;
    double one;
    one = 1.0;
    w = x;
    y = x;
    z = x;
    a = x;
    b = x;
    c = x;
    d = x;
    e = x;
    f = x;
    g = x;
    h = x;
    for ( i = 1; i <= iters; i++ ) {
        w = w * 1.000000000001 + one;
        y = y * 1.000000000002 + one;
        z = z * 1.000000000003 + one;
        a = a * 1.000000000004 + one;
        b = b * 1.000000000005 + one;
        c = c * 0.999999999999 + one;
        d = d * 0.999999999998 + one;
        e = e * 0.999999999997 + one;
        f = f * 0.999999999996 + one;
        g = h * 0.999999999995 + one;
        h = h * 1.000000000006 + one;
    }
    result = 2.0 * ( a + b + c + d + e + f + w + x + y + z + g + h );

    if (!quiet) printf("Result = %lf\n", result);

    return result;
}

Here is the call graph for this function:

flops_double_init_matrix()

int flops_double_init_matrix

(

void

)

Definition at line 81 of file flops_testcode.c.

                                   {

    int i,j;

    /* Initialize the Matrix arrays */
    /* Non-optimail row major.  Intentional? */
    for ( i = 0; i < ROWS; i++ ) {
        for ( j = 0; j < COLUMNS; j++) {
            double_mresult[j][i] = 0.0;
            double_matrixa[j][i] = ( double ) rand() * ( double ) 1.1;
            double_matrixb[j][i] = ( double ) rand() * ( double ) 1.1;
        }
    }

#if defined(__powerpc__)
        /* has fused multiply-add */
        return ROWS*ROWS*ROWS;
#else
    return ROWS*ROWS*ROWS*2;
#endif

}

Here is the call graph for this function:

flops_double_matrix_matrix_multiply()

double flops_double_matrix_matrix_multiply

(

void

)

Definition at line 104 of file flops_testcode.c.

                                                 {

    int i,j,k;

    /* Matrix-Matrix multiply */
    for ( i = 0; i < ROWS; i++ ) {
        for ( j = 0; j < COLUMNS; j++ ) {
            for ( k = 0; k < COLUMNS; k++ ) {
                double_mresult[i][j] += double_matrixa[i][k] * double_matrixb[k][j];
            }
        }
    }

    return double_mresult[10][10];
}

flops_double_swapped_matrix_matrix_multiply()

double flops_double_swapped_matrix_matrix_multiply

(

void

)

Definition at line 120 of file flops_testcode.c.

                                                         {

    int i, j, k;

    /* Matrix-Matrix multiply */
    /* With inner loops swapped */

    for (i = 0; i < ROWS; i++) {
        for (k = 0; k < COLUMNS; k++) {
            for (j = 0; j < COLUMNS; j++) {
                double_mresult[i][j] += double_matrixa[i][k] * double_matrixb[k][j];
            }
        }
    }
    return double_mresult[10][10];
}

flops_float_init_matrix()

int flops_float_init_matrix

(

void

)

Definition at line 23 of file flops_testcode.c.

                                  {

    int i,j;

    /* Initialize the Matrix arrays */
    /* Non-optimail row major.  Intentional? */
    for ( i = 0; i < ROWS; i++ ) {
        for ( j = 0; j < COLUMNS; j++) {
            float_mresult[j][i] = 0.0;
            float_matrixa[j][i] = ( float ) rand() * ( float ) 1.1;
            float_matrixb[j][i] = ( float ) rand() * ( float ) 1.1;
        }
    }

#if defined(__powerpc__)
    /* Has fused multiply-add */
    return ROWS*ROWS*ROWS;
#else
    return ROWS*ROWS*ROWS*2;
#endif

}

Here is the call graph for this function:

flops_float_matrix_matrix_multiply()

float flops_float_matrix_matrix_multiply

(

void

)

Definition at line 46 of file flops_testcode.c.

                                               {

    int i,j,k;

    /* Matrix-Matrix multiply */
    for ( i = 0; i < ROWS; i++ ) {
        for ( j = 0; j < COLUMNS; j++ ) {
            for ( k = 0; k < COLUMNS; k++ ) {
                float_mresult[i][j] += float_matrixa[i][k] * float_matrixb[k][j];
            }
        }
    }

    return float_mresult[10][10];
}

flops_float_swapped_matrix_matrix_multiply()

float flops_float_swapped_matrix_matrix_multiply

(

void

)

Definition at line 62 of file flops_testcode.c.

                                                       {

    int i, j, k;

    /* Matrix-Matrix multiply */
    /* With inner loops swapped */

    for (i = 0; i < ROWS; i++) {
        for (k = 0; k < COLUMNS; k++) {
            for (j = 0; j < COLUMNS; j++) {
                float_mresult[i][j] += float_matrixa[i][k] * float_matrixb[k][j];
            }
        }
    }
    return float_mresult[10][10];
}

instructions_fldcw()

int instructions_fldcw

(

void

)

Definition at line 92 of file instructions_testcode.c.

                             {

#if defined(__i386__) || (defined __x86_64__)

    int saved_cw,result,cw;
    double three=3.0;

    asm(    "   mov $100000,%%ecx\n"
        "big_loop:\n"
        "   fldl    %1      # load value onto fp stack\n"
        "   fnstcw  %0      # store control word to mem\n"
        "   movzwl  %0, %%eax   # load cw from mem, zero extending\n"
        "   movb    $12, %%ah   # set cw for \"round to zero\"\n"
        "   movw    %%ax, %3    # store back to memory\n"
        "   fldcw   %3      # save new rounding mode\n"
        "   fistpl  %2      # save stack value as integer to mem\n"
        "   fldcw   %0      # restore old cw\n"
        "   loop    big_loop    # loop to make the count more obvious\n"
        : /* no output registers */
        : "m"(saved_cw), "m"(three), "m"(result), "m"(cw) /* inputs */
        : "cc", "%ecx","%eax" /* clobbered */
    );
    return 0;
#endif

    return CODE_UNIMPLEMENTED;
}

instructions_million()

int instructions_million

(

void

)

Definition at line 8 of file instructions_testcode.c.

                               {

#if defined(__i386__) || (defined __x86_64__)
    asm(    "   xor %%ecx,%%ecx\n"
        "   mov $499999,%%ecx\n"
        "test_loop:\n"
        "   dec %%ecx\n"
        "   jnz test_loop\n"
        : /* no output registers */
        : /* no inputs */
        : "cc", "%ecx" /* clobbered */
    );
    return 0;
#elif defined(__PPC__)
    asm(    "   nop         # to give us an even million\n"
        "   lis 15,499997@ha    # load high 16-bits of counter\n"
        "   addi    15,15,499997@l  # load low 16-bits of counter\n"
        "55:\n"
        "   addic.  15,15,-1              # decrement counter\n"
        "   bne     0,55b                  # loop until zero\n"
        : /* no output registers */
        : /* no inputs */
        : "cc", "15" /* clobbered */
    );
    return 0;
#elif defined(__ia64__)

    asm(    "   mov loc6=166666 // below is 6 instr.\n"
        "   ;;          // because of that we count 4 too few\n"
        "55:\n"
        "   add loc6=-1,loc6    // decrement count\n"
        "   ;;\n"
        "   cmp.ne  p2,p3=0,loc6\n"
        "(p2)   br.cond.dptk    55b // if not zero, loop\n"
        : /* no output registers */
        : /* no inputs */
        : "p2", "loc6" /* clobbered */
    );
    return 0;
#elif defined(__sparc__)
    asm(    "   sethi   %%hi(333333), %%l0\n"
        "   or  %%l0,%%lo(333333),%%l0\n"
        "test_loop:\n"
        "   deccc   %%l0        ! decrement count\n"
        "   bnz test_loop   ! repeat until zero\n"
        "   nop         ! branch delay slot\n"
        : /* no output registers */
        : /* no inputs */
        : "cc", "l0" /* clobbered */
    );
    return 0;
#elif defined(__arm__)
    asm(    "   ldr r2,count    @ set count\n"
        "   b       test_loop\n"
        "count: .word 333332\n"
        "test_loop:\n"
        "   add r2,r2,#-1\n"
        "   cmp r2,#0\n"
        "   bne test_loop   @ repeat till zero\n"
        : /* no output registers */
        : /* no inputs */
        : "cc", "r2" /* clobbered */
    );
    return 0;
#elif defined(__aarch64__)
    asm(    "   ldr x2,=333332  // set count\n"
        "test_loop:\n"
        "   add x2,x2,#-1\n"
        "   cmp x2,#0\n"
        "   bne test_loop   // repeat till zero\n"
        : /* no output registers */
        : /* no inputs */
        : "cc", "r2" /* clobbered */
    );
    return 0;
#endif

    return CODE_UNIMPLEMENTED;

}

instructions_rep()

int instructions_rep

(

void

)

Definition at line 124 of file instructions_testcode.c.

                           {

#if defined(__i386__) || defined(__ILP32__)

    char buffer_out[16384];

    asm(    "   mov $1000,%%edx\n"
        "   cld\n"
        "loadstore:         # test 8-bit store\n"
        "   mov $0xd, %%al  # set eax to d\n"
        "   mov $16384, %%ecx\n"
        "   mov %0, %%edi   # set destination\n"
        "   rep stosb       # store d 16384 times, auto-increment\n"
        "   dec %%edx\n"
        "   jnz loadstore\n"
        : /* outputs */
        : "rm" (buffer_out) /* inputs */
        : "cc", "%esi","%edi","%edx","%ecx","%eax","memory" /* clobbered */
    );
    return 0;
#elif defined (__x86_64__)

    char buffer_out[16384];

    asm(    "   mov $1000,%%edx\n"
        "   cld\n"
        "loadstore:         # test 8-bit store\n"
        "   mov $0xd, %%al  # set eax to d\n"
        "   mov $16384, %%ecx\n"
        "   mov %0, %%rdi   # set destination\n"
        "   rep stosb       # store d 16384 times, auto-increment\n"
        "   dec %%edx\n"
        "   jnz loadstore\n"
        : /* outputs */
        : "rm" (buffer_out) /* inputs */
        : "cc", "%esi","%edi","%edx","%ecx","%eax","memory" /* clobbered */
    );
    return 0;
#endif

    return CODE_UNIMPLEMENTED;

}

random_branches_testcode()

int random_branches_testcode	(	int	number,
		int	quiet
	)

Definition at line 109 of file branches_testcode.c.

                                                    {

  int j,junk=0;
  double junk2=5.0;

   for(j=0;j<number;j++) {

    if (( ((random()>>2)^(random()>>4)) %1000)>500) goto label_false;

    junk++;   /* can't just add, the optimizer is way too clever */

    junk2*=junk;

    //printf("T");
      label_false:
    //printf("F");
    ;
      }
   if (!quiet) printf("%lf\n",junk2);

   return junk;
}