/* 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);
}
void context_switch_experiment() {
printf("# context sw experiment\n");
fflush(stdout);
int ShmID;
ui *ShmPTR;
pid_t pid;
int status = 0;
int cw_sample_count = 500;
// Request OS to allocate some shared memory.
ShmID = shmget(IPC_PRIVATE, 3*sizeof(ui), IPC_CREAT | 0666);
if (ShmID < 0) { printf("ERROR: shmget failed to allocate memory\n"); exit(1);}
// Get pinter to shared memry.
ShmPTR = (ui *) shmat(ShmID, NULL, 0);
if ((ui) ShmPTR == (ui)-1) { printf("ERROR: shmat error\n"); exit(1);}
for (int i = 0; i < cw_sample_count; i++) {
// Notion here is as following:
// Child writes absolute cycle count into the first two ShmPTR locations.
// Parent reads ShmPtr[0 and 1], if they are equal, this means that the child
// was not interrupted while writing to shared memory.
// Parent then takes it's own CPU cycle count and compares it to child's value.
ShmPTR[0] = 1; //for parent to read child.
ShmPTR[1] = 2; //2nd confirmation copy, used as sort of mutex.
ShmPTR[2] = 0; //for child to read parent
pid = fork();
if (pid < 0) {printf("ERROR on fork\n"); exit(1);}
if (pid == 0) { //child
while (1) {
ShmPTR[0] = ShmPTR[1] = get_counter();
if (ShmPTR[2] != 0) { //parent wrote something into shared memory.
break;
}
}
exit(0);
} else { //parent
while (1) {
if (ShmPTR[0] == ShmPTR[1]) {
ui parent_cycles = get_counter();
ui child_cycles = ShmPTR[0];
ShmPTR[2] = 1; // Instruct child to exit.
printf("%lu\n", parent_cycles - child_cycles);
fflush(stdout);
wait(&status); // wait till child exits
break;
}
}
}
}
//
shmctl(ShmID, IPC_RMID, NULL); //Shared memory should be released before exiting.
exit(1);
}
word gamedata::get_spendable_rupies()
{
if(get_bit(quest_rules, qr_SHOPCHEAT) || get_dcounter(1)>=0)
return get_counter(1);
else
return get_counter(1)+get_dcounter(1);
}
/* 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);
}
}
/* $begin time_p_warm */
double time_P_warm()
{
P(); /* Warm up the cache */
start_counter();
P();
return get_counter();
}
/* but not too often */
void request_and_resend (int sock, char * contact, keyset kset)
{
if (get_counter (contact) <= 0) {
printf ("unable to request and resend for %s, peer not found\n", contact);
return;
}
/* printf ("request_and_resend (socket %d, peer %s)\n", sock, peer); */
static char * old_contact = NULL;
/* if it is the same peer as on the last call, we do nothing */
if ((old_contact != NULL) && (strcmp (contact, old_contact) == 0)) {
/* printf ("request_and_resend (%s), same as old peer\n", peer); */
return;
}
if (old_contact != NULL)
free (old_contact);
old_contact = strcpy_malloc (contact, "request_and_resend contact");
/* request retransmission of any missing messages */
int hops = 10;
send_retransmit_request (contact, kset, sock, hops,
ALLNET_PRIORITY_LOCAL_LOW);
/* resend any unacked messages, but no more than once every hour */
static time_t last_resend = 0;
time_t now = time (NULL);
if (now - last_resend > 3600) {
last_resend = now;
resend_unacked (contact, kset, sock, hops, ALLNET_PRIORITY_LOCAL_LOW, 10);
}
}
/*
* stress_rdrand()
* stress Intel rdrand instruction
*/
static int stress_rdrand(const args_t *args)
{
if (rdrand_supported) {
double time_start, duration, billion_bits;
bool lock = false;
time_start = time_now();
do {
#if defined(__x86_64__) || defined(__x86_64)
RDRAND64x32();
#else
RDRAND32x64();
#endif
inc_counter(args);
} while (keep_stressing());
duration = time_now() - time_start;
billion_bits = ((double)get_counter(args) * 64.0 * 32.0) / 1000000000.0;
pr_lock(&lock);
pr_dbg_lock(&lock, "%s: %.3f billion random bits read "
"(instance %" PRIu32")\n",
args->name, billion_bits, args->instance);
if (duration > 0.0) {
pr_dbg_lock(&lock, "%s: %.3f billion random bits per "
"second (instance %" PRIu32")\n",
args->name,
(double)billion_bits / duration,
args->instance);
}
pr_unlock(&lock);
}
return EXIT_SUCCESS;
}
u_int64_t inactive_periods(int num, u_int64_t threshold, Sample *samples) {
ui initial_value = get_counter();
ui last_value = initial_value;
for (int i = 0; i < num;) {
ui new_value = get_counter();
ui diff = new_value - last_value; // difference
if (diff > threshold) {
samples[i].start = last_value;
samples[i].end = new_value;
i++;
}
last_value = new_value;
}
return initial_value;
}
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);
}
/* $begin time_p_cold */
double time_P_cold()
{
P(); /* Warm up instruction cache */
clear_cache(); /* Clear data cache */
start_counter();
P();
return get_counter();
}
// 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
}
int hashtable_dec_counter(char* key) {
LM_DBG("decrementing counter for <%s>\n", key);
int *d = get_counter(key);
if (*d > 0)
*d = *d - 1;
if (*d == 0)
remove_counter(key);
return *d;
}
int main (int argc, char **argv)
{
/*
* Setup the Scheme library by calling "___setup" with appropriate
* parameters. The call to "___setup_params_reset" sets all parameters
* to their default setting.
*/
___setup_params_struct setup_params;
___setup_params_reset (&setup_params);
setup_params.version = ___VERSION;
setup_params.linker = SCHEME_LIBRARY_LINKER;
___setup (&setup_params);
/* Main part of program: start N threads that increment a counter */
counter = new_counter (); /* create a new counter */
pthread_mutex_init (&mut, NULL); /* initialize mutex */
{
int i;
pthread_t tid[N];
void* results[N];
for (i = 0; i<N; i++)
pthread_create (&tid[i], NULL, thread_main, NULL);
for (i = 0; i<N; i++)
pthread_join (tid[i], &results[i]);
}
{
int got_throw = 0;
int count = 0;
___ON_THROW(count = get_counter (counter), got_throw=1);
if (got_throw)
printf ("Scheme threw an exception\n");
else
printf ("final count = %d\n", count);
}
/* we don't need the counter anymore */
___ON_THROW(release_counter (counter),);
/* Cleanup the Scheme library */
___cleanup ();
return 0;
}
/*
* Timer function called every second to gather statistics
* from the 77105. This is done because the h/w registers
* will overflow if not read at least once per second. The
* kernel's stats are much higher precision. Also, having
* a separate copy of the stats allows implementation of
* an ioctl which gathers the stats *without* zero'ing them.
*/
static void idt77105_stats_timer_func(unsigned long dummy)
{
struct idt77105_priv *walk;
struct atm_dev *dev;
struct idt77105_stats *stats;
DPRINTK("IDT77105 gathering statistics\n");
for (walk = idt77105_all; walk; walk = walk->next) {
dev = walk->dev;
stats = &walk->stats;
stats->symbol_errors += get_counter(dev, IDT77105_CTRSEL_SEC);
stats->tx_cells += get_counter(dev, IDT77105_CTRSEL_TCC);
stats->rx_cells += get_counter(dev, IDT77105_CTRSEL_RCC);
stats->rx_hec_errors += get_counter(dev, IDT77105_CTRSEL_RHEC);
}
if (!start_timer) mod_timer(&stats_timer,jiffies+IDT77105_STATS_TIMER_PERIOD);
}
/**
* Get time + cycle count at a moment in time.
* Do some busy waiting.
* Get time + cycles count at the end again.
* Compute mhz based on difference in time and cycle count.
*
* Repeat experiment 20 times and pick the median value to avoid unexpected hops.
*/
ui get_cpu_mhz() {
int cpu_samples_count = 20;
ui * cpu_samples = (ui *) malloc(sizeof(ui)*cpu_samples_count);
for (int ci = 0; ci < cpu_samples_count; ci++) {
timespec time_start, time_end;
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time_start);
ui start_cycles = get_counter();
// 375000000 ~= 1 second or so.
for (long i = 0; i < 500000; i++) { // busy waiting.
int unused_number = 1 << 1;
(void) unused_number; //supress warning from compiler.
}
ui end_cycles = get_counter();
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time_end);
timespec diff_total;
diff_total.tv_sec = 0; diff_total.tv_nsec = 0;
diff_total = diff(time_start, time_end);
ui elapsed_cycles = end_cycles - start_cycles;
double total_time = ((double) diff_total.tv_nsec / 1000000000.0L) + diff_total.tv_sec; // nanoseconds to seconds + seconds.
double multiplier = 1.0L / total_time;
ui herz = (ui) floor((double) elapsed_cycles * multiplier);
//printf("%lu\n", herz);
cpu_samples[ci] = herz;
}
// sort all aquired CPU values.
qsort(cpu_samples, cpu_samples_count, sizeof(ui), ui_cmpfunc);
// for (int i = 0; i < cpu_samples_count ; i++) {
// printf("val: %lu\n", cpu_samples[i]);
// }
// pick the median, which will likley be reasonably accurate.
ui cpu_mhz = cpu_samples[cpu_samples_count / 2];
//printf("Cpu value: %lu\n", cpu_mhz);
free(cpu_samples);
return cpu_mhz;
}
/* 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;
}
int main(int argc, char **argv) {
srand(time(NULL));
sef_startup();
Whack* whack = startWhack();
vg_init(0x114);
int done = 0; //whack->done;
//Bitmap* board = loadBitmap("/home/lcom/lcom1415-t3g15/projeto/res/board.bmp");
//Bitmap* bt = loadBitmap("/home/lcom/lcom1415-t3g15/projeto/res/exit-button.bmp");
//drawBitmapWithoutBg(board, 0, 0, ALIGN_LEFT);
//drawBitmapWithoutBg(bt, 200, 120, ALIGN_LEFT);
//MainMenu* teste = createMainMenu();
//drawMainMenu(teste);
//deleteMainMenu(teste);
/*Game* teste = createGame();
//OptionsMenu* teste = createOptionsMenu(0, 0);
drawGame(teste);
flipMouse();
drawMouse();
flipDisplay();
sleep(10);
deleteGame(teste);*/
while (!whack->done) {
updateWhack(whack);
if (get_counter(whack->timer) % 4 == 0){
if (!whack->done && whack->draw) {
drawWhack(whack);
}
if (getMouse()->draw) {
flipMouse();
drawMouse();
flipDisplay();
}
}
}
stopWhack(whack);
vg_exit();
printf("\nTerminated\n");
return 0;
}
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;
}
double get_comp_counter() {
double time = get_counter();
double ctime;
struct tms t;
clock_t ticks;
times(&t);
ticks = t.tms_utime - start_tick;
ctime = time - ticks*cyc_per_tick;
/*
printf("Measured %.0f cycles. Ticks = %d. Corrected %.0f cycles\n",
time, (int) ticks, ctime);
*/
return ctime;
}
/* Gather a single sample that estimates the CPU freqency. Check the TSC register, sleep for the
* given amount of time, and then read back the TSC register. The difference in clock cycles over
* the known time is used to estimate the CPU freqency.
*/
int get_sample(long milliseconds, u_int64_t *sample)
{
struct timespec req;
u_int64_t start, end;
int err;
// Set amount of time to sleep per sample
req.tv_sec = 0;
req.tv_nsec = milliseconds * 1000000L;
// Measure clock-speed
start = get_counter();
err = nanosleep(&req, NULL);
end = get_counter();
if (err == -1) {
return 0;
}
*sample = (end - start);
return 1;
}
/**
* This function was initially used to determine the average interval between sampling cpu cycles, to find out context switch time.
*/
void print_intervals() {
int count = 2000;
//start_counter();
ui * sample_values = malloc(sizeof(ui)*count);
ui initial_value = get_counter();
for (int i = 0, last_value = initial_value; i < count; i++) {
ui new_value = get_counter();
sample_values[i] = new_value - last_value; //difference
last_value = new_value;
}
ui sum = 0;
for (int i = 0; i < count; i++) {
printf("%lu ", sample_values[i]);
sum += sample_values[i];
if (i % 20 == 0) {
printf("\n");
}
}
printf("Sum: %lu\n", sum);
free(sample_values);
}
/* 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;
}
/**
* digging hole アルゴリズムにより問題を作成する
* 点対称な問題を作成する。
* 人間的解法で解ける盤面を生成する。
* @param array ナンプレ盤面（入出力）
* @param symmetric 対称形に生成するフラグ
* @return 1: 作成できた
* @return それ以外: 作成できなかった
*/
static int digging_hole(numpl_array * array, int symmetric)
{
for (int i = 0; i < ARRAY_SIZE; i++) {
array->ar[i].fixed = 1;
}
numpl_array save = *array;
int loop_size = ARRAY_SIZE;
if (symmetric) {
loop_size = ARRAY_SIZE / 2;
}
for (int i = 0; i < loop_size; i++) {
int idx1 = get_random(ARRAY_SIZE);
int idx2 = get_counter(idx1);
if (array->ar[idx1].fixed == 0) {
continue;
}
array->ar[idx1].fixed = 0;
array->ar[idx1].symbol = FULL_SYMBOL;
if (symmetric) {
array->ar[idx2].fixed = 0;
array->ar[idx2].symbol = FULL_SYMBOL;
}
solve_info info;
fixed_only(array, FULL_SYMBOL);
int r = solve(array, &info);
if (r == 0) {
*array = save;
#if defined(DEBUG) && 0
printf("load and return r = %d\n", r);
//output(array);
#endif
return 1;
} else if (r == 1) {
save = *array;
#if defined(DEBUG) && 0
printf("save r = %d i = %d\n", r, i);
//output_detail(array);
#endif
} else {
*array = save;
#if defined(DEBUG) && 0
printf("load r = %d i = %d\n", r, i);
//output_detail(array);
#endif
}
}
return -1;
}
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;
}
static BOOL io_format_interp(io_struct *ps, size_t *item_size, int *nitems,
BOOL *is_string)
{
char fmt;
*is_string = False;
*item_size = 0;
*nitems = 1;
if (ps->format_string == NULL)
return False;
fmt = ps->format_string[ps->format_offset];
if (fmt == 0)
return False;
switch (fmt)
{
case 'W':
{
*item_size = 2;
break;
}
case 'z':
{
*is_string = True;
/* fall through... */
}
case 'B':
{
*item_size = 1;
break;
}
case 'D':
{
*item_size = 4;
break;
}
default:
{
return False;
}
}
ps->format_offset++;
*nitems = get_counter(ps->format_string, &ps->format_offset);
return True;
}
/**
* digging hole アルゴリズムを再帰的に使い問題を作成する
* symmetric が真なら点対称な問題を作成する。
* 人間的解法で解ける盤面を生成する。
* @param array ナンプレ盤面（入出力）
* @param pos 盤面配列内の開始位置
* @param info 解情報
* @param symmetric 真なら点対称の問題を作成する
* @return 1: 作成できた
* @return それ以外: 作成できなかった
*/
static int digging_hole_recursion(numpl_array * array, int pos,
solve_info * info, int symmetric)
{
fixed_only(array, FULL_SYMBOL);
int r = solve(array, info);
if (r != 1) {
return r;
}
numpl_array best = *array;
numpl_array save = *array;
int min_fixed = ARRAY_SIZE + 1;
int loop_size = ARRAY_SIZE;
if (symmetric) {
loop_size = ARRAY_SIZE / 2;
}
for (int i = pos; i < loop_size; i++) {
int idx1 = i;
int idx2 = get_counter(idx1);
if (array->ar[idx1].fixed == 0) {
continue;
}
array->ar[idx1].fixed = 0;
array->ar[idx1].symbol = FULL_SYMBOL;
if (symmetric) {
array->ar[idx2].fixed = 0;
array->ar[idx2].symbol = FULL_SYMBOL;
}
r = digging_hole_recursion(array, i + 1, info, symmetric);
if (r <= 0) {
*array = save;
continue;
} else if (r == 1) {
if (info->fx_count < min_fixed) {
min_fixed = info->fx_count;
best = *array;
}
*array = save;
}
}
*array = best;
if (min_fixed == ARRAY_SIZE + 1) {
return -1;
} else {
return 1;
}
}
