clock() Function in C

Description

The C library function clock_t clock(void) returns the number of clock ticks elapsed since the program was launched. To get the number of seconds used by the CPU, you will need to divide by CLOCKS_PER_SEC.

On a 32 bit system where CLOCKS_PER_SEC equals 1000000 this function will return the same value approximately every 72 minutes.

Syntax:

There is a proper syntax that represents the clock() function by returning some approximate processor time which further gets consumed by a program. Depending upon the clock time allocation of resources with each of the operating systems gets allocated. Syntax representation is as follows:

clock_k clock(void)

Where clock_k signifies the function with keyword clock and parameter to return void type.

How clock() works in C?

• The clock function is mostly used to determine processor time within an operating system.
• It helps in allocating the time resources to the processor by counting the number of ticks per second for any manipulation.
• Clock function uses the following versions where it makes use of C language as ANSI/ISO 9899-1990
• There are other C functions as well which are similar to clock function and is represented within the standard library as:

Time_0 func (time.h)

• Clock() function follows some algorithmic code represented by the minutes and time example for :

<image>

• The algorithmic flow goes in a way where it first checks for the repeat loop whether it exists or not and if it is greater than 0 or not if the condition checking gets satisfied then it will decrement the number of elapses or ticks per the second basis or else.
• If it does not satisfy the condition, then it will in turn land into another scenario where delay or repeat will take place for less than 0 value.
• Then further it will call for power check whether it sustains or not then it will move into the increment of no-of minutes after that it will be counted in the done state for a completed operation as per flow chart depiction.

Pseudocode

# include <time.h>

clock_h  strt, end;

double cpu_time_usd;

start=clock();

// Perform Work

end = clock();

cpu_time_usd = ( (double) (end-start)) // This gives clock value on per second basis…

• As per pseudocode initially, a start and end time exists with the clock() function then a variable for cpu_time_usd is taken where the clock function is then assigned to the start function.
• It will then perform all work for manipulation.
• Once the work comes to end the clock() function result will be assigned to the end() function further giving the manipulation of CPU timings on the per-second basis for start and end at the time of resource allocation.
• The clock function return is the amount of elapsed time for processing since the program gets started at the beginning of any program.
• If error the function, in turn, returns -1.

Examples

There are some examples mentioned below.

Example #1

This program demonstrates how the time is consumed by function for its processing as shown in the output below.

#include <stdio.h>

#include <time.h>

void func_1()

{

printf("func_1() starts the flow... \n");

printf("Press enter_button to stop func_1 when entered.. \n");

while(1)

{

if (getchar())

break;

}

printf("func_1() gets an end here.. \n");

}

int main()

{

clock_t t_0;

t_0 = clock();

func_1();

t_0 = clock() - t_0;

double time_consumed = ((double)t_0)/CLOCKS_PER_SEC;

printf("func_1() took %f seconds for execution of some value.. \n", time_consumed);

return 0;

}

Output:

Explanation:

Clock() function in C here is used for demonstrating the flow where func_1 consumes the flow of time with the execution of some value and its time as well. It takes some time for execution and allocates resources as per the operating system. If pressed enter then it will get halted with the required value as shown in the output.

Example #2

This function demonstrates the time taken by fib_time(20) for consumption of time within the processor for any manipulation as shown in the output.

#include<stdio.h>

int fib_time(int a_0)

{

if (a_0 <= 1)

return a_0;

return fib_time(a_0-1) + fib_time(a_0-2);

}

int main ()

{

printf("The number coming out of fib_time is: %d", fib_time(20));

return 0;

}

Output:

Explanation:

In this program, the number coming out of fib_time comes as the final compiled time of the fib_time() function that is used for the overview it is the final compilation time.

Example #3

This program demonstrates the current time as part of ctime standard library to determine the current time as part of clock() function for comparison.

#include <stdio.h>

#include <time.h>

int main () {

time_t currnt_time;

time(&currnt_time);

printf("Current_time comes_out to be: = %s", ctime(&currnt_time));

return(0);

}

Output:

Example #4

Difftime is another c reference function that is also similar to clock() function but with some of the major differences which are depicted in the output below.

#include <stdio.h>

#include <time.h>

int main ()

{

time_t tm_1,tm_2;

char get_inpt [258];

double diff_sc;

time (&tm_1);

printf ("Enter name of_fav food: ");

gets (get_inpt);

time (&tm_2);

diff_sc = difftime (tm_2,tm_1);

printf ("It took almost %.2lf seconds_for typing the time...\n", diff_sc );

return 0;

}

Output:

Explanation: This program demonstrates the function diff_sc with some of the time differences in comparison and it helps in understanding the instantaneous time for switching or any other functionality to work. Here one option is given with entering the name of fav food and to compare and fetch the instance of time with a difference concerning the operating system as shown in the output.

Clock() function in C plays an important role as it helps developers gain insight into the timing constraints concerning the current system or processor in use. It gives developers the ability to differentiate and troubleshoot even if some of the patches and releases are made with help of a check and run this clock() and ctime function as part of the same standard library for verification.