Hugging Face's logo

Datasets:
Variable-role
/
sajaniemi_variable_dataset_large

Languages:
code
Tags:
code
variable-roles
sajaniemi
Dataset card Files
xet
 Community
sajaniemi_variable_dataset_large / code /validation /C /0006174_eval_clocks.c
Pendigard's picture
Pendigard
Upload folder using huggingface_hub (part 6)
8be366a verified
Raw History Blame Contribute Delete
4.84 kB
// Evaluate cost of calling different clocks under Linux. On one machine at a
// point in time, we got these values:
//
// time : 3 cycles
// ftime : 54 cycles
// gettimeofday : 42 cycles
//
// CLOCK_MONOTONIC_COARSE : 9 cycles
// CLOCK_REALTIME_COARSE : 9 cycles
// CLOCK_MONOTONIC : 42 cycles
// CLOCK_REALTIME : 42 cycles
// CLOCK_MONOTONIC_RAW : 173 cycles
// CLOCK_BOOTTIME : 179 cycles
// CLOCK_THREAD_CPUTIME_ID : 349 cycles
// CLOCK_PROCESS_CPUTIME_ID : 370 cycles
//
// Numbers above generated on Intel Core i7-4771 CPU @ 3.50GHz on Linux 4.0.
//
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <sys/timeb.h>
#include <time.h>
#include "tsc.h"
#define N 100000
/* measure the cost to call `time`. */
void time_overhead()
{
int i;
uint64_t t0, t1, tsc_overhead;
uint64_t min, max, avg;
uint64_t times[N];
tsc_overhead = measure_tsc_overhead();
// we run N times and take the min
for (i = 0; i < N; i++) {
t0 = bench_start();
time(NULL);
t1 = bench_end();
times[i] = t1 - t0 - tsc_overhead;
}
min = ~0, max = 0, avg = 0;
for (i = 0; i < N; i++) {
avg += times[i];
if (times[i] < min) { min = times[i]; }
if (times[i] > max) { max = times[i]; }
}
avg /= N;
printf("\n- TIME -\n");
printf("time_getres: 1s\n");
printf("Cost (min): %" PRIu64 " cycles\n", min);
printf("Cost (avg): %" PRIu64 " cycles\n", avg);
printf("Cost (max): %" PRIu64 " cycles\n", max);
}
/* measure the cost to call `ftime`. */
void ftime_overhead()
{
int i;
struct timeb t;
uint64_t t0, t1, tsc_overhead;
uint64_t min, max, avg;
uint64_t times[N];
tsc_overhead = measure_tsc_overhead();
// we run N times and take the min
for (i = 0; i < N; i++) {
t0 = bench_start();
ftime(&t);
t1 = bench_end();
times[i] = t1 - t0 - tsc_overhead;
}
min = ~0, max = 0, avg = 0;
for (i = 0; i < N; i++) {
avg += times[i];
if (times[i] < min) { min = times[i]; }
if (times[i] > max) { max = times[i]; }
}
avg /= N;
printf("\n- FTIME -\n");
printf("ftime_getres: 1ms\n");
printf("Cost (min): %" PRIu64 " cycles\n", min);
printf("Cost (avg): %" PRIu64 " cycles\n", avg);
printf("Cost (max): %" PRIu64 " cycles\n", max);
}
/* measure the cost to call `gettimeofday`. */
void gettimeofday_overhead()
{
int i;
struct timeval t;
uint64_t t0, t1, tsc_overhead;
uint64_t min, max, avg;
uint64_t times[N];
tsc_overhead = measure_tsc_overhead();
// we run N times and take the min
for (i = 0; i < N; i++) {
t0 = bench_start();
gettimeofday(&t, NULL);
t1 = bench_end();
times[i] = t1 - t0 - tsc_overhead;
}
min = ~0, max = 0, avg = 0;
for (i = 0; i < N; i++) {
avg += times[i];
if (times[i] < min) { min = times[i]; }
if (times[i] > max) { max = times[i]; }
}
avg /= N;
printf("\n- GETTIMEOFDAY -\n");
printf("gettimeofday_getres: 1us (?)\n");
printf("Cost (min): %" PRIu64 " cycles\n", min);
printf("Cost (avg): %" PRIu64 " cycles\n", avg);
printf("Cost (max): %" PRIu64 " cycles\n", max);
}
/* measure the cost to call `clock_gettime` for the specified clock. */
void clock_overhead(clockid_t clock)
{
int i;
struct timespec t;
uint64_t t0, t1, tsc_overhead;
uint64_t min, max, avg;
uint64_t times[N];
tsc_overhead = measure_tsc_overhead();
// we run N times and take the min
for (i = 0; i < N; i++) {
t0 = bench_start();
clock_gettime(clock, &t);
t1 = bench_end();
times[i] = t1 - t0 - tsc_overhead;
}
min = ~0, max = 0, avg = 0;
for (i = 0; i < N; i++) {
avg += times[i];
if (times[i] < min) { min = times[i]; }
if (times[i] > max) { max = times[i]; }
}
avg /= N;
printf("Cost (min): %" PRIu64 " cycles\n", min);
printf("Cost (avg): %" PRIu64 " cycles\n", avg);
printf("Cost (max): %" PRIu64 " cycles\n", max);
}
/* measure + print the cost to call `clock_gettime` for the specified clock. */
void measure_clock(const char * ctype, clockid_t clock)
{
struct timespec t;
printf("\n- %s -\n", ctype);
clock_getres(clock, &t);
printf("clock_getres: %ld seconds | %ld nanoseconds\n", t.tv_sec, t.tv_nsec);
clock_overhead(clock);
}
#define eval_clock(clk) \
measure_clock(#clk, clk)
/* benchmark various clock sources */
int main(void)
{
printf("=> Testing Clock...\n");
time_overhead();
ftime_overhead();
gettimeofday_overhead();
eval_clock(CLOCK_REALTIME);
eval_clock(CLOCK_REALTIME_COARSE);
eval_clock(CLOCK_MONOTONIC);
eval_clock(CLOCK_MONOTONIC_COARSE);
eval_clock(CLOCK_MONOTONIC_RAW);
eval_clock(CLOCK_BOOTTIME);
eval_clock(CLOCK_PROCESS_CPUTIME_ID);
eval_clock(CLOCK_THREAD_CPUTIME_ID);
return 0;
}