Thread: Timing program

I just had a go at writing a program that times simple operations. It dosent seem to be working tho. I figured that this should take at least 1 millisecond to run:

Code:

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
int main()
{
    srand(time(NULL));
    int *table1, *table2;
    unsigned x, y, z;
    unsigned time;
    int mod, mul, add, sub, div;
    int test;
    
    table1=malloc(sizeof(int)*1000000);
    table2=malloc(sizeof(int)*1000000);
    
    while(*table1) 
    {
        *table1=rand()+1;
        table1++;
    }
    while(*table2) 
    {
        *table2=rand()+1;    
        table2++;
    }   
     
    time=clock();
    while(*table1)
    {
        for(x=0; x<4294967295; x++) 
            for(y=0; y<4294967295; y++) 
                for(z=0; z<4294967295; z++) 
                    test = *table1 % *table2;
        table1++; 
        table2++;
    }  
    mod=clock()-time;
    
    
    printf("Modulus: %i\n", mod);
    printf("X:%i Y:%i Z:%i", x, y, z);
    getchar();                 
}

It dident, so I printed out the x, y, z variables and it seems as if the loops have just decided to exit at random times. I must be doing something wrong here. Right?

Malloc usually returns a bunch of memory that contains zero, so I expect loops similar to this:

Code:

    while(*table1) 
    {
        *table1=rand()+1;
        table1++;
    }

to not do anything, because the first test of "*table" is zero, so it doesn't enter the first iteration of the loop.

You may want something like:
Add this early on in the code

Code:

#define ARRAY_SIZE 1000000

Then replace this:

Code:

    table1=malloc(sizeof(int)*1000000);
    table2=malloc(sizeof(int)*1000000);
    
   while(*table1) 
    {
        *table1=rand()+1;
        table1++;
    }
    while(*table2) 
    {
        *table2=rand()+1;    
        table2++;
    }   
     
    time=clock();
    while(*table1)
    {
        for(x=0; x<4294967295; x++) 
            for(y=0; y<4294967295; y++) 
                for(z=0; z<4294967295; z++) 
                    test = *table1 % *table2;
        table1++; 
        table2++;
    }

with

Code:

    int i;

    table1=malloc(sizeof(int)*ARRAY_SIZE);
    table2=malloc(sizeof(int)*ARRAY_SIZE);
    

   for(i = 0; i < ARRAY_SIZE; i++)) 
    {
        table1[i]=rand()+1;
        table2[i]=rand()+1;    
    }
     
    time=clock();
    for(i = 0; i < ARRAY_SIZE; i++)
    {
        for(x=0; x<4294967295; x++) 
            for(y=0; y<4294967295; y++) 
                for(z=0; z<4294967295; z++) 
                    test = *table1 % *table2;
        table1++; 
        table2++;
    }

I also expect that 2^32^3*1000000 will take a bit longer than 1ms. 1 loop of 2^32 using divide takes about 30 seconds or so. 30^3 will be 240 seconds, times 1 million is about 80 years or so (I could have got that entirely wrong, but I'm sure my calculation is several orders of magnitude closer than the 1ms you are talking of).

--
Mats

Originally Posted by matsp

Malloc usually returns a bunch of memory that contains zero, so I expect loops similar to this:

No, malloc() does not initialise the space it allocates, as already said by Salem.

Originally Posted by cwr

No, malloc() does not initialise the space it allocates, as already said by Salem.

The standard does not SAY what malloc returrns, that is correct. However, it is QUITE COMMON that it returns memory that is all zeros - there are of course several other bugs in the code, which makes it fall over in a big heap - and of course, the time it will take is many orders of magnitude greater than the original poster suggests.

--
Mats

Another point: The compiler may well eliminate the x, y and z loops, as the pointer table doesn't change within the loop, so the loop actually doesn't make any difference - and test is only actually set to the final value of the loop, so the compiler may just do:

Code:

table1 += 1000000-1;
table2 += 1000000-1;
i = 1000000;
test = *table1 % *table2;

This would run in much less than 1ms, of course.

It depends on how clever the compiler is, and whehter it has optimization enabled, what actually ends up in the code.

--
Mats

Haha, yeah I screwed up bad there. Just spent all night trying random things to fix the clipping on a raycaster I'm making in Blitz Basic. Guess my brain turned to mush and I forgot how C works. Thanks guys, I should be able to get it to work now