clock() keeps returning 0

I have spent entire days trying to figure out why my clock() function is seeming to only return 0,15, or 31(it returns 15 or 31 when i make int i a double. and i have no idea why this would change the time). it seems to not matter how many nested loops i have in my program either, it just returns the same values. I've tried adding to my i, and it does nothing(but after 10 chars my program seems to be stuck in an infinate loop). thanks for your time!

Code:

---

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

double getMilliseconds() {
        return 1000.0 * clock() / CLOCKS_PER_SEC;
}

int main() {
        int i;
        double j;
        double elapsed;

        elapsed = -getMilliseconds();
        j = 0;
        for(i = 0; i < 100000000; ++i)
                j = j + i / 3.0; /* nonsense computation that just takes time */

        elapsed += getMilliseconds();

        printf("Elapsed Milliseconds = %lf\n", elapsed);

        return 0;
}

---

It is possible that the compiler is able to optimize the loop quite a bit so that the elapsed time is unperceivable to functions like clock(). I suggest trying some more CPU-intensive programs; for instance try filling a big array and then using qsort to see if the elapsed time is different from zero.

that's actually my intended purpose but i cant get this simple version to work. i get 0.00000milliseconds also on my code that sorts an array like as follows:
(and yes i know how to do true random numbers, i'm just using these to debugg it with)

Code:

---

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "dyArray.h"


#define ARRAY_SIZE 10

double getMilliseconds() {
        return 1000.0 * clock() / CLOCKS_PER_SEC;
}

main(){
        struct dyArray stk;
        double b,elapsed;
        int i,j;

        elapsed = -getMilliseconds();
       
        dyArrayInit(&stk, ARRAY_SIZE);

        for (i = 0; i < ARRAY_SIZE; i++){
                b = randDouble(ARRAY_SIZE);
                dyArrayPush(&stk, b);
                }

        stackSort(ARRAY_SIZE, &stk);

        for (i = 0; i < ARRAY_SIZE; i++){
                printf("%g \n", stk.data[i]);
                }
       
        elapsed += getMilliseconds();
        printf("Elapsed Milliseconds = %lf\n", elapsed);
}

---

i'm using microsoft visual C++ if that matters.

What does clock() by itself return rather than "1000.0 * clock() / CLOCKS_PER_SEC;"?
Maybe the number it returns is too small after you divide it by CLOCKS_PER_SEC.
If that's the case, try doing more stuff in the loop that would take longer.

Check if the return value from clock() can be represented, because if it can't clock() returns (clock_t)-1

if i call clock() instead of "1000.0 * clock() / CLOCKS_PER_SEC;"
i get: "Elapsed Milliseconds 15.000000" or "Elapsed Milliseconds 31.000000"
which is the exact same if i call getMilliseconds(); i'm really confused now. (it returns 0 if "int i" instead of "double i" too.

in for() loop.
if i< 1000000 "Elapsed Milliseconds 15.000000"
if i< 10000000 "Elapsed Milliseconds 31.000000"
if i< 100000000 "Elapsed Milliseconds 281.000000"

if i change "double getMilliseconds();"
to "clock_t getMilliseconds();"
i get the same answers.

if i change "double ellapsed"
to "clock_t ellapsed"
i get 0's again.
(is this what you meant itCbitC?)

thanks a ton for such swift answers!

Quote:

---

Originally Posted by Zooker

if i call clock() instead of "1000.0 * clock() / CLOCKS_PER_SEC;"
i get: "Elapsed Milliseconds 15.000000" or "Elapsed Milliseconds 31.000000"
which is the exact same if i call getMilliseconds(); i'm really confused now

---

Probably because CLOCKS_PER_SEC equals 1000.

Try this code; it seems to return a nonzero return when I run it with no optimizations:

Code:

---

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

int compare(const void *left, const void *right) {
        return(*(int*)left - *(int*)right);
}

#define SIZE  200000

int main() {
        int i;
        int arr[SIZE];
        clock_t begin, end;
        for(i = 0; i < SIZE; ++i)
            arr[i] = SIZE + SIZE - i;
        begin = clock();
        qsort(arr, SIZE, sizeof(int), compare);
        end = clock();
        printf("%lf\n", ((double)end - (double)begin) / CLOCKS_PER_SEC);
}

---

i get 0.015 or 0.016 with your code ronix. thanks a ton. i guess its bad programming on my part. now to play with it! and i didn't realize stdlib.h had it's own qsort. i'm laughing at myself for writing that out all the time now

Try this snippet of code in getMilliseconds().

Code:

---

clock_t rc;
if ((rc = clock()) != -1)
    return 1000.0 * rc / CLOCKS_PER_SEC;

---

What's the value of CLOCKS_PER_SEC on your system ... is it 1 million ... and what platform are you on?

Quote:

---

Originally Posted by Zooker

...
(is this what you meant itCbitC?)

---

see my reply in post #9

i saw CLOCKS_PER_SEC in different threads and thought it was 100 by default.
laptop. Geforce 7400go (i dont think this matters for arithmitic equations?)
My system is XP (32 bit i think)
T2400 @ 1.83GHz
2gig ram

i was doing this on my laptop because i assumed this was slow considering its over 2 or 3 years old. i played around with the code a bit and realized my call to "getMilliseconds();" doesn't work. If i use "clock()" in my code like ronix did in his, it works perfect. I tried your snippet too itCBitC and it didn't change anything. i can work with clock(); now at least. thanks a ton guys!!!

I am pretty darn sure that the originally posted code for getMilliSeconds is correct - it is simply that the time is so short that it doesn't register. It may also be that the compiler optimizes the loop itself to nothing, since j is not needed after the loop, and thus can be removed from the calculation, leaving an empty loop, which may well be removed too!

Sorting an array of ten elements is unlikely to take more than 100 iterations [unless the algorithm is completely broken]. 100 iterations, where each iteration is something like 10-100 instructions is likely to take around 1000-50000 clock-cycles [on a modern CPU] - sure, if you had a 8086 from 1984 then you may find that it actually takes enough time to register on clock(). But on a machine that runs at 1.8 GHz, it amounts to less than 1 microsecond. Up the number of elements you are sorting, and I'm sure you will get a measurable amount of time. I did a quick-sort of 60 million elements, and it took a few minutes...

--
Mats

Also remember that there's a difference between precision and accuracy.
It's precision is 1uS, but it's accuracy could be 20mS.

That is, in two back-to-back calls to clock(), you could get 0 from the first, and 20000 from the second.

Very small loops equate to timing a bullet with a stopwatch - results are vague and mis-leading.

Quote:

---

Originally Posted by Zooker

Code:

---

        j = 0;
        for(i = 0; i < 100000000; ++i)
                j = j + i / 3.0; /* nonsense computation that just takes time */

---

---

Since the value of j is never used, chances are the compiler has optimized this loop completely out of existence.

After the loop, make a call to a dummy function in another source module, passing it the value of j. That will force the compiler to generate the loop.

Quote:

---

Originally Posted by Zooker

i saw CLOCKS_PER_SEC in different threads and thought it was 100 by default.
laptop. Geforce 7400go (i dont think this matters for arithmitic equations?)
My system is XP (32 bit i think)
T2400 @ 1.83GHz
2gig ram

---

just wanted to know whether the platform type was UNIX or Windows since typedef of clock_t determines after how long the return value from clock() wraps around. If clock_t is a signed int then the return value from clock() wraps around in some seconds depending on its size on that platform.