// by Ged, 4-1-2004
int inactive_duration(int thresh)
{
double value;
start_counter();
while(value = get_counter())
if(value > thresh) return (int) value;
else start_counter(); //resets counter, so we check between reads
}
/* while sleeping for sleeptime seconds */
double mhz(int verbose, int sleeptime)
{
double rate;
start_counter();
sleep(sleeptime);
rate = get_counter() / (1e6*sleeptime);
if (verbose)
printf("Processor clock rate ?= %.1f MHz\n", rate);
start_counter();
printf("delay is %.1f. ", get_counter());
return rate;
}
void run(int len, int trials, unsigned seed) {
double t1, t2;
int t;
for (t = 0; t < trials; t++) {
init(seed);
start_counter();
minmax1(a1, b1, len);
t1 = get_counter();
start_counter();
minmax2(a2, b2, len);
t2 = get_counter();
printf("%d\t%.2f\t%.2f\n", len, t1/len, t2/len);
}
}
int main()
{
setter();
saver();
clearer();
start_counter();
loader();
stop_counter();
dumper();
clearer();
start_counter();
loader_mem();
stop_counter();
dumper();
}
void operator() (const char * event,
T func,
long int bytes_read = 0,
long int ops = 0,
long int bytes_written = 0) {
#ifdef CYCLE_PROFILING
if (currentevent==maxevents) {
func();
} else {
const auto countfd = thread_counter_fds.get_counter_fd();
start_counter(countfd);
func();
long long cycs = stop_counter(countfd);
// Store the profiling data
std::lock_guard<std::mutex> lock_events(event_lock);
events[currentevent++] = {
get_event_id(event), bytes_read, ops, bytes_written, cycs
};
}
#else
(void) event;
(void) bytes_read;
(void) ops;
(void) bytes_written;
func();
#endif // CYCLE_PROFILING
}
/* Attempt to see how much time is used by timer interrupt */
static void callibrate(int verbose)
{
double oldt;
struct tms t;
clock_t oldc;
int e = 0;
times(&t);
oldc = t.tms_utime;
start_counter();
oldt = get_counter();
while (e <NEVENT) {
double newt = get_counter();
if (newt-oldt >= THRESHOLD) {
clock_t newc;
times(&t);
newc = t.tms_utime;
if (newc > oldc) {
double cpt = (newt-oldt)/(newc-oldc);
if ((cyc_per_tick == 0.0 || cyc_per_tick > cpt) && cpt > RECORDTHRESH)
cyc_per_tick = cpt;
/*
if (verbose)
printf("Saw event lasting %.0f cycles and %d ticks. Ratio = %f\n",
newt-oldt, (int) (newc-oldc), cpt);
*/
e++;
oldc = newc;
}
oldt = newt;
}
}
if (verbose)
printf("Setting cyc_per_tick to %f\n", cyc_per_tick);
}
/* $begin time_p_warm */
double time_P_warm()
{
P(); /* Warm up the cache */
start_counter();
P();
return get_counter();
}
/* $begin time_p_cold */
double time_P_cold()
{
P(); /* Warm up instruction cache */
clear_cache(); /* Clear data cache */
start_counter();
P();
return get_counter();
}
int main()
{
int i,j;
unsigned time1, time2, time3;
start_counter();
for (i = 0; i < SQSIZE; i++)
{
for (j = 0; j < SQSIZE; j++)
{
square[i][j].c = 0;
square[i][j].m = 0;
square[i][j].y = 1;
square[i][j].k = 0;
}
}
time1 = get_counter();
start_counter();
for (i = 0; i < SQSIZE; i++)
{
for (j = 0; j < SQSIZE; j++)
{
square[i][j].c = 0;
square[i][j].m = 0;
square[i][j].y = 1;
square[i][j].k = 0;
}
}
time2 = get_counter();
start_counter();
for (i = 0; i < SQSIZE; i++)
{
for (j = 0; j < SQSIZE; j++)
{
square[j][i].c = 0;
square[j][i].m = 0;
square[j][i].y = 1;
square[j][i].k = 0;
}
}
time3 = get_counter();
printf("T1 (Cold cache time): %12u (%.1fx)\n", time1,(double)time1/time2);
printf("T2 (Warm cache time): %12u (1.0x)\n", time2);
printf("T3 (Poor locality time): %12u (%.1fx)\n", time3,(double)time3/time2);
}
void start_comp_counter() {
struct tms t;
if (cyc_per_tick == 0.0)
callibrate(1);
times(&t);
start_tick = t.tms_utime;
start_counter();
}
/* return MHz rating of CPU */
double mhz(void)
{
int sleeptime = 1;
double rate;
start_counter();
sleep(sleeptime);
rate = dget_counter() / (1e6 * sleeptime);
return (rate);
}
/* Determine clock rate by measuring cycles
elapsed while sleeping for sleeptime seconds */
double mhz_full(int verbose, int sleeptime)
{
double rate;
start_counter();
sleep(sleeptime);
rate = get_counter()/(1e6*sleeptime);
if (verbose)
printf("Processor Clock Rate ~= %.1f MHz\n", rate);
return rate;
}
double fcyc(test_funct f, long int *params)
{
double result;
init_sampler();
if (compensate) {
do {
double cyc;
if (clear_cache)
clear();
start_counter();
f(params);
cyc = get_counter();
if (cyc > 0.0)
add_sample(cyc);
} while (!has_converged() && samplecount < maxsamples);
} else {
do {
double cyc;
if (clear_cache)
clear();
start_counter();
f(params);
cyc = get_counter();
if (cyc > 0.0)
add_sample(cyc);
} while (!has_converged() && samplecount < maxsamples);
}
#ifdef DEBUG
{
long int i;
printf(" %ld smallest values: [", kbest);
for (i = 0; i < kbest; i++)
printf("%.0f%s", values[i], i==kbest-1 ? "]\n" : ", ");
}
#endif
result = values[0];
#if !KEEP_VALS
free(values);
values = NULL;
#endif
return result;
}
double ovhd()
{
/* Do it twice to eliminate cache effects */
int i;
double result;
for (i = 0; i < 2; i++) {
start_counter();
result = get_counter();
}
return result;
}
double mhz(int verbose, int sleeptime)
{
double rate;
start_counter();
sleep(sleeptime);
rate = get_counter();
if(verbose)
printf("processor clock rate ~= %.1f MHz\n",rate);
return rate;
}
double ovhd() {
/* Find lowest among multiple samples */
int i;
double result = 1E10;
for (i = 0; i < 100; i++) {
double sample;
start_counter();
sample = get_counter();
if (sample < result)
result = sample;
}
return result;
}
/* repeatedly calls the function to measure -- argument is iteration
* count */
unsigned measure(int iter)
{
int i;
unsigned cmeas,cycles;
volatile int res = 0; /* don't let compiler optimize away fn
* calls */
res += absdiff(0,1); /* warm up cache */
start_counter();
for (i = 0; i < iter; i++)
res += absdiff(valA[i],valB[i]);
cmeas = get_counter();
cycles = cmeas / iter;
return cycles;
}
int main (int argc, char *argv[])
{
int iters = 1000000;
double MHz = mhz(1);
int i;
int sum = 0;
double cycs;
start_counter();
for (i = 0; i < iters; i++) {
sum += i;
cycs = get_counter();
}
printf("%d calls in %.0f clock cycles = %.3f usec/call\n",
iters, cycs, cycs / (MHz * iters));
return 0;
}
int main(int argc, char * argv[])
{
int i,j,n,gen,repeat,t;
double cycles;
printf("Enter count: ");
scanf("%d",&n);
printf("Enter (0=constant, 1 = random:");
scanf("%d",&gen);
printf("Enter repeat count:");
scanf("%d",&repeat);
switch (gen) {
case 0 :
for (i=0;i<n;i++)
{
a[i] = 1;
}
break;
case 1 :
for (i=0;i<n;i+=repeat)
{
t = (-1) * (lrand48() % 2) ;
for (j=0;j<repeat;j++)
a[i+j] = t;
}
for (;i<n;i++)
a[i] = t;
break;
default : printf("illegal case\n"); exit(1);
}
start_counter();
for (i=0;i<n;i++)
{
a[i] = absval(a[i]);
}
cycles = get_counter();
printf("cycles for absval = %.0f\n",cycles);
}
/* repeatedly calls the function to measure until the total execution
* time (in cycles) is above specified threshold, returns iteraction count */
int measurecnt(void)
{
unsigned cmeas, cycles;
int cnt = 1;
volatile int res = 0; /* don't let compiler optimize away fn
calls */
do
{
int c = cnt;
res += absdiff(0,1); /* first call to warm up cache */
start_counter();
while (c-- > 0)
res += absdiff(0,1);
cmeas = get_counter();
cycles = cmeas / cnt;
cnt += cnt;
} while (cmeas < CMIN); /* make sure long enough */
return cnt;
}
double fcyc2_full(test_funct f, int param1, int param2, int clear_cache,
int k, double epsilon, int maxsamples, int compensate)
{
double result;
init_sampler(k, maxsamples);
if (compensate) {
do {
double cyc;
if (clear_cache)
clear();
f(param1, param2); /* warm cache */
start_comp_counter();
f(param1, param2);
cyc = get_comp_counter();
add_sample(cyc, k);
} while (!has_converged(k, epsilon, maxsamples) && samplecount < maxsamples);
} else {
do {
double cyc;
if (clear_cache)
clear();
f(param1, param2); /* warm cache */
start_counter();
f(param1, param2);
cyc = get_counter();
add_sample(cyc, k);
} while (!has_converged(k, epsilon, maxsamples) && samplecount < maxsamples);
}
#ifdef DEBUG
{
int i;
printf(" %d smallest values: [", k);
for (i = 0; i < k; i++)
printf("%.0f%s", values[i], i==k-1 ? "]\n" : ", ");
}
#endif
result = values[0];
#if !KEEP_VALS
free(values);
values = NULL;
#endif
return result;
}
/* repeatedly calls the function to measure until the total execution
* time (in cycles) is above specified threshold */
unsigned measure(void)
{
unsigned cmeas, cycles;
int cnt = 1;
do
{
int c = cnt;
dotproduct7(V1,V2,&result); /* first call to warm up cache */
start_counter();
while (c-- > 0)
dotproduct7(V1,V2,&result);
cmeas = get_counter();
cycles = cmeas / cnt;
cnt += cnt;
} while (cmeas < CMIN); /* make sure long enough */
return cycles;
/* printf("Measured function required %u clock cycles (per call)\n", cycles);
printf(" cnt = %d, cmeas = %u\n", cnt, cmeas); */
}
/* Returns the estimated value of the CPU frequncy in cycles per second (Hz)
*/
long get_cpu_frequency()
{
u_int64_t samples[MAX_SAMPLES];
u_int64_t sample;
int sample_count = 0;
// Init sample array
init_sample_array(samples, MAX_SAMPLES);
// Initialize the counter
start_counter();
do {
if (!get_sample(SLEEP_TIME, &sample)) {
continue;
}
add_sample(samples, MAX_SAMPLES, sample);
sample_count++;
} while (!k_lowest_tolerance(samples, sample_count, K, TOLERANCE) && sample_count <= MAX_SAMPLES);
return (long)(samples[0] / ((double)SLEEP_TIME / 1000));
}
int main (int argc, char *argv[])
{
start_counter();
(void) argv; //supress warning.
//0) Compute CPU speed experimentally.
mhz = get_cpu_mhz(); // on a 3.5 ghz proc this is usually ~3 4xx xyz xyz, indicating cycles/second.
printf("# Cpu_mhz: %lu\n", mhz);
fflush(stdout);
if (single_affinity) {
set_single_cpu_affinity();
}
// Just passing an arg will branch to context switch experiment.
if (argc == 2) {
context_switch_experiment();
return 0;
} else {
inactive_time_experiment();
}
printf("\n\n"); //clear screen.
return 0;
}
int main() {
int64_t value = -1;
// Lock to cpu0
cpu_set_t mask;
CPU_ZERO(&mask);
CPU_SET(0, &mask);
assert(!sched_setaffinity(0, sizeof(mask), &mask));
while (1) {
int fd = start_counter();
timing_computation();
ssize_t nread = read(fd, &value, sizeof(value));
assert(nread == sizeof(value));
close(fd);
printf("%lld\n", value);
}
return 0;
}
int main()
{
double ctime,ptime,mhzest;
pid_t pid;
/* get estimate of mhz rating of cpu */
mhzest = mhz();
start_counter();
if ((pid = fork()) == 0)
{
ctime = dget_counter();
printf("Child: %.8d ticks (%.2f ms)\n", (int) ctime,
ctime/(mhzest * 1e3));
exit(0);
}
else
{
ptime = dget_counter();
printf("Parent: %.8d ticks (%.2f ms)\n", (int) ptime,
ptime/(mhzest * 1e3));
waitpid(pid,NULL,0);
}
}
void handle_press_select(ClickRecognizerRef recognizer, void *context) {
start_counter(settings.select);
}
void handle_press_up(ClickRecognizerRef recognizer, void *context) {
start_counter(settings.up);
}
void start_comp_counter()
{
start_counter();
}
double time_funct(test_funct f, double *a)
{
start_counter();
f(a);
return get_counter();
}
