{"id":5720,"date":"2023-01-28T00:01:04","date_gmt":"2023-01-28T08:01:04","guid":{"rendered":"https:\/\/c-for-dummies.com\/blog\/?p=5720"},"modified":"2023-01-21T10:24:28","modified_gmt":"2023-01-21T18:24:28","slug":"checking-the-cpu-clock","status":"publish","type":"post","link":"https:\/\/c-for-dummies.com\/blog\/?p=5720","title":{"rendered":"Checking the CPU Clock"},"content":{"rendered":"

The clock()<\/em> function has nothing to do with human time. Nope. It returns a value from the computer’s CPU, the processor time. You can use this value to determine the amount of time it takes your programs to run.
\n
\nOf course, the time<\/em> utility at the command prompt does the same thing without your need to code anything. Just type:<\/p>\n

time program<\/em><\/code><\/p>\n

where program<\/em><\/code> is the name of the program you want to time. The results look like this:<\/p>\n

$ time .\/a.out
\n[program output appears here]<\/em><\/p>\n

real\t0m0.004s
\nuser\t0m0.001s
\nsys\t0m0.002s<\/code><\/p>\n

The three values are: 4 milliseconds for the entire process; 1 millisecond of user time; and 2 milliseconds of system time.<\/p>\n

Within your code, you can use the clock()<\/em> function to fetch these CPU time values. The value returned is a clock_t<\/em> (long unsigned<\/em>) integer representing the CPU time, but this value must be interpreted properly.<\/p>\n

2023_01_28-Lesson-a.c<\/a><\/h3>\n
\r\n#include <stdio.h>\r\n#include <time.h>\r\n\r\nint main()\r\n{\r\n    clock_t start;\r\n\r\n    start = clock();\r\n    printf(\"Processor start time: %lu\\n\",start);\r\n\r\n    return(0);\r\n}<\/pre>\n
The time.h<\/code> header is required to define and use the clock()<\/em> function.<\/p>\n
The clock_t<\/em> variable start<\/code> holds the value returned from clock()<\/em>, which is output by using the %lu<\/code> placeholder.<\/p>\n
Here’s a sample run:<\/p>\n
Processor start time: 2191<\/code><\/p>\n
The value 2191 (or whatever you see on your system) is meaningless without context. In this case, the value is related to the number of clock ticks per second the processor generates. This per-second value is different for each processor, though the defined constant CLOCKS_PER_SEC<\/code> is used to calculate the number of processor ticks per second. The CLOCKS_PER_SEC<\/code> value is set by default to one million, which doesn’t make it any more useful given that (again) processors have different clock rates.<\/p>\n
To make clock()<\/em> function’s return value more realistic, divide it by the CLOCKS_PER_SEC<\/code> constant. To get the best results, cast the clock_t<\/em> value as a double<\/em>. You must also update the code to replace the %lu<\/code> conversion character with %f<\/code>:<\/p>\n
printf(\"Processor start time: %f\\n\",(double)start\/CLOCKS_PER_SEC);<\/code><\/p>\n
Click here<\/a> to view the full code on GitHub. Here is the updated output:<\/p>\n
Processor start time: 0.002196<\/code><\/p>\n
The point of this exercise is to time how long code, or a portion of code, executes. To do so, two calls must be made to clock()<\/em>, one before all the action and another after. The following update to the code adds a for<\/em> loop to ensure that time is consumed before the second reading is made:<\/p>\n
2023_01_28-Lesson-c.c<\/a><\/h3>\n
\r\n#include <stdio.h>\r\n#include <stdlib.h>\r\n#include <time.h>\r\n\r\nint main()\r\n{\r\n    int r;\r\n    clock_t start,finish;\r\n\r\n    \/* obtain start time *\/<\/span>\r\n    start = clock();\r\n    printf(\"Processor start time: %f\\n\",(float)start\/CLOCKS_PER_SEC);\r\n\r\n    \/* seed the randomizer *\/<\/span>\r\n    srand( (unsigned)time(NULL) );\r\n    \r\n    \/* loop for a while *\/<\/span>\r\n    for(;;)\r\n    {\r\n        r = rand() % 1000;\r\n        if( r==1 )\r\n            break;\r\n    }\r\n\r\n    \/* obtain finish time *\/<\/span>\r\n    finish = clock();\r\n    printf(\"Processor end time: %f\\n\",(float)finish\/CLOCKS_PER_SEC);\r\n\r\n    return(0);\r\n}<\/pre>\n
The for<\/em> loop keeps repeating until the a random value in the range of zero to 1,000 is equal to one. This loop can take a few milliseconds to complete, which makes the output values different each run:<\/p>\n
Processor start time: 0.002194
\nProcessor end time: 0.002220<\/code><\/p>\n
To discover how much CPU time the program has consumed, the code must obtain the difference between the two values. The following printf()<\/em> statement is added just before the return<\/em> statement:<\/p>\n
printf(\"Total program runtime: %f\\n\",
\n        ((float)finish-start)\/CLOCKS_PER_SEC
\n      );<\/code><\/p>\n
The full code is available on GitHub<\/a>. The output now shows the difference:<\/p>\n
Processor start time: 0.002229
\nProcessor end time: 0.002258
\nTotal program runtime: 0.000029<\/code><\/p>\n
I’ve seen examples on the Interwebs where this result is multiplied by 1,000. I assume that’s to translate the result into milliseconds, though I don’t see any data to back that up.<\/p>\n
If I run the program through the time<\/em> utility, I see this output:<\/p>\n
$ time .\/a.out
\nProcessor start time: 0.002200
\nProcessor end time: 0.002236
\nTotal program runtime: 0.000036<\/p>\n
real    0m0.004s
\nuser    0m0.001s
\nsys     0m0.002s<\/code><\/p>\n
The time<\/em> utility reports a total runtime of four milliseconds, which is close to the program result of .000036. The difference might explain why I’ve seen code that multiplies the clock_t<\/em> value by 1,000. Again, that’s just my assumption.<\/p>\n","protected":false},"excerpt":{"rendered":"
An extremely low-level function is clock()<\/em>, which has nothing to do with human time. Continue reading →<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2],"tags":[],"class_list":["post-5720","post","type-post","status-publish","format-standard","hentry","category-main"],"_links":{"self":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/5720","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=5720"}],"version-history":[{"count":5,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/5720\/revisions"}],"predecessor-version":[{"id":5731,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/5720\/revisions\/5731"}],"wp:attachment":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=5720"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=5720"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=5720"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}