int _hl_rate_calls(float *real_time, float *proc_time, long long * ins, float *rate, int EVENT, HighLevelInfo * state) { long long values[2] = { 0, 0 }; int retval = 0; int level = 0; if (EVENT == PAPI_FP_INS) level = HL_FLIPS; else if (EVENT == PAPI_TOT_INS) level = HL_IPC; else if (EVENT == PAPI_FP_OPS) level = HL_FLOPS; if (state->running != 0 && state->running != level) return (PAPI_EINVAL); if (state->running == 0) { if (PAPI_query_event(EVENT) != PAPI_OK) return (PAPI_ENOEVNT); if ((retval = PAPI_add_event(state->EventSet, EVENT)) != PAPI_OK) { _internal_cleanup_hl_info(state); PAPI_cleanup_eventset(state->EventSet); return (retval); } if (PAPI_query_event(PAPI_TOT_CYC) != PAPI_OK) return (PAPI_ENOEVNT); if ((retval = PAPI_add_event(state->EventSet, PAPI_TOT_CYC)) != PAPI_OK) { _internal_cleanup_hl_info(state); PAPI_cleanup_eventset(state->EventSet); return (retval); } state->initial_time = PAPI_get_real_usec(); if ((retval = PAPI_start(state->EventSet)) != PAPI_OK) return (retval); state->running = level; } else { if ((retval = PAPI_stop(state->EventSet, values)) != PAPI_OK) return (retval); /* Use Multiplication because it is much faster */ *real_time = (float) ((long long)(PAPI_get_real_usec() - state->initial_time) * .000001); *proc_time = (float) (values[1]*.000001/((_papi_hwi_system_info.hw_info.mhz==0)?1:_papi_hwi_system_info.hw_info.mhz)); if (*proc_time > 0) *rate = (float) ((float) values[0]*(EVENT==PAPI_TOT_INS?1:_papi_hwi_system_info.hw_info.mhz)/(values[1]==0?1:values[1])); state->total_proc_time += *proc_time; state->total_ins += values[0]; *proc_time = state->total_proc_time; *ins = (long long)state->total_ins; if ((retval = PAPI_start(state->EventSet)) != PAPI_OK) { state->running = 0; return (retval); } } return PAPI_OK; }
int main(int argc, char* argv[]) { int rtn,i; unsigned int test_size = atoi(argv[1]); long_long s; long_long e; //Incremental Data for testing for(i = 0; i < DATA_POINTS/4; i++){ senddata[i] = i; } printf("# Host to PCIE\n"); printf("# Transfer Size(Bytes), Transfer Time (s),Throughput: (MB/s)\n"); s = PAPI_get_real_usec(); rtn = fpga_transfer_data(HOST,USERPCIE1,(unsigned char *) senddata,test_size,0, 1); //fpga_wait_interrupt(); e = PAPI_get_real_usec(); printf("%d, %f, %f\n", test_size,(e-s)*1e-6,(double)(test_size*1000000.0)/(1024.0*1024.0*(double)(e-s))); /*for(i=0;i<1024;i=i+4){ rtn = fpga_ddr_pio_rd(i); printf("%d\n",rtn); }*/ return 0; }
main(){ long_long start_cycles, end_cycles, start_usec, end_usec; int EventSet = PAPI_NULL; int tabla[100]; if (PAPI_library_init(PAPI_VER_CURRENT) != PAPI_VER_CURRENT) exit(1); /* Gets the starting time in clock cycles */ start_cycles = PAPI_get_real_cyc(); /* Gets the starting time in microseconds */ start_usec = PAPI_get_real_usec(); /*Create an EventSet */ //if (PAPI_create_eventset(&EventSet) != PAPI_OK) // exit(1); tabla[0]=1; tabla[100]=1; /* Gets the ending time in clock cycles */ end_cycles = PAPI_get_real_cyc(); /* Gets the ending time in microseconds */ end_usec = PAPI_get_real_usec(); printf("Wall clock cycles: %lld\n", end_cycles - start_cycles); printf("Wall clock time in microseconds: %lld\n", end_usec - start_usec); }
/** Log performance counters into "pstats.dat" */ static void log_counters( FILE *out, const char *phase, long long *pTic, long long values[] ) { long long toc = PAPI_get_real_usec(); #ifdef CACHE_PROFILE if( PAPI_read_counters( values, 4 ) != PAPI_OK ) { handle_error( 1 ); } fprintf( out, "%s PAPI_L2_TCM %lld\n", phase, values[0] ); fprintf( out, "%s PAPI_L2_TCA %lld\n", phase, values[2] ); fprintf( out, "%s L2MissRate %.4lf%\n", phase, ( double )values[0] / ( double )values[2] ); fprintf( out, "%s PAPI_L3_TCM %lld\n", phase, values[1] ); fprintf( out, "%s PAPI_L3_TCA %lld\n", phase, values[3] ); fprintf( out, "%s L3MissRate %.4lf%\n", phase, ( double )values[1] / ( double )values[3] ); #else if( PAPI_read_counters( values, 1 ) != PAPI_OK ) { handle_error( 1 ); } fprintf( out, "%s PAPI_FP_OPS %lld\n", phase, values[0] ); #endif fprintf( out, "%s RealTime %.4lfs\n", phase, ( toc - *pTic ) * 1e-6 ); *pTic = PAPI_get_real_usec(); }
void *Thread(void *arg) { int retval, num_tests = 1; int EventSet1=PAPI_NULL; int mask1, papi_event; int num_events1; long long **values; long long elapsed_us, elapsed_cyc; char event_name[PAPI_MAX_STR_LEN]; /* add PAPI_TOT_CYC and one of the events in PAPI_FP_INS, PAPI_FP_OPS or PAPI_TOT_INS, depends on the availability of the event on the platform */ EventSet1 = add_two_nonderived_events(&num_events1, &papi_event, hw_info, &mask1); expected[EventSet1] = *(int *)arg / mythreshold; myid[EventSet1] = PAPI_thread_id(); values = allocate_test_space(num_tests, num_events1); elapsed_us = PAPI_get_real_usec(); elapsed_cyc = PAPI_get_real_cyc(); if ((retval = PAPI_overflow(EventSet1, papi_event, mythreshold, 0, handler)) != PAPI_OK) test_fail(__FILE__, __LINE__, "PAPI_overflow", retval); /* start_timer(1); */ if ((retval = PAPI_start(EventSet1)) != PAPI_OK) test_fail(__FILE__, __LINE__, "PAPI_start", retval); do_stuff(); if ((retval = PAPI_stop(EventSet1, values[0])) != PAPI_OK) test_fail(__FILE__, __LINE__, "PAPI_stop", retval); elapsed_us = PAPI_get_real_usec() - elapsed_us; elapsed_cyc = PAPI_get_real_cyc() - elapsed_cyc; if ((retval = PAPI_overflow(EventSet1, papi_event, 0, 0, NULL)) != PAPI_OK) test_fail(__FILE__, __LINE__, "PAPI_overflow", retval); remove_test_events(&EventSet1, mask1); if ((retval = PAPI_event_code_to_name(papi_event, event_name)) != PAPI_OK) test_fail(__FILE__, __LINE__, "PAPI_event_code_to_name", retval); if (!TESTS_QUIET) { printf("Thread 0x%x %s : \t%lld\n", (int) pthread_self(), event_name, (values[0])[0]); printf("Thread 0x%x PAPI_TOT_CYC: \t%lld\n", (int) pthread_self(), (values[0])[1]); printf("Thread 0x%x Real usec : \t%lld\n", (int) pthread_self(), elapsed_us); printf("Thread 0x%x Real cycles : \t%lld\n", (int) pthread_self(), elapsed_cyc); } free_test_space(values, num_tests); pthread_exit(NULL); return (NULL); }
int main(int argc, char **argv) { int retval; long long elapsed_us, elapsed_cyc; const PAPI_hw_info_t *hw_info; tests_quiet(argc, argv); /* Set TESTS_QUIET variable */ retval = PAPI_library_init(PAPI_VER_CURRENT); if (retval != PAPI_VER_CURRENT) test_fail(__FILE__, __LINE__, "PAPI_library_init", retval); hw_info = PAPI_get_hardware_info(); if (hw_info == NULL) test_fail(__FILE__, __LINE__, "PAPI_get_hardware_info", 2); elapsed_us = PAPI_get_real_usec(); elapsed_cyc = PAPI_get_real_cyc(); printf("Testing real time clock. (CLOCK %d MHz, CPU %f MHz)\n",hw_info->clock_mhz,hw_info->mhz); printf("Sleeping for 10 seconds.\n"); sleep(10); elapsed_us = PAPI_get_real_usec() - elapsed_us; elapsed_cyc = PAPI_get_real_cyc() - elapsed_cyc; printf("%lld us. %lld cyc.\n",elapsed_us,elapsed_cyc); printf("%f Computed MHz.\n",(float)elapsed_cyc/(float)elapsed_us); /* Elapsed microseconds and elapsed cycles are not as unambiguous as they appear. On Pentium III and 4, for example, cycles is a measured value, while useconds is computed from cycles and mhz. MHz is read from /proc/cpuinfo (on linux). Thus, any error in MHz is propagated to useconds. Conversely, on ultrasparc useconds are extracted from a system call (gethrtime()) and cycles are computed from useconds. Also, MHz comes from a scan of system info, Thus any error in gethrtime() propagates to both cycles and useconds, and cycles can be further impacted by errors in reported MHz. Without knowing the error bars on these system values, we can't really specify error ranges for our reported values, but we *DO* know that errors for at least one instance of Pentium 4 (torc17@utk) are on the order of one part per thousand. Newer multicore Intel processors seem to have broken the relationship between the clock rate reported in /proc/cpuinfo and the actual computed clock. To accomodate this artifact, the test no longer fails, but merely reports results out of range. */ if (elapsed_us < 9000000) printf("NOTE: Elapsed real time less than 9 seconds!\n"); if (elapsed_us > 11000000) printf("NOTE: Elapsed real time greater than 11 seconds!\n"); if ((float)elapsed_cyc < 9.0 * hw_info->mhz * 1000000.0) printf("NOTE: Elapsed real cycles less than 9*MHz*1000000.0!\n"); if ((float)elapsed_cyc > 11.0 * hw_info->mhz * 1000000.0) printf("NOTE: Elapsed real cycles greater than 11*MHz*1000000.0!\n"); test_pass(__FILE__, NULL, 0); exit(1); }
int main(int argc, char **argv) { int i, retval; long long elapsed_us, elapsed_cyc; tests_quiet(argc, argv); /* Set TESTS_QUIET variable */ retval = PAPI_library_init(PAPI_VER_CURRENT); if (retval != PAPI_VER_CURRENT) test_fail(__FILE__, __LINE__, "PAPI_library_init", retval); hw_info = PAPI_get_hardware_info(); if (hw_info == NULL) test_fail(__FILE__, __LINE__, "PAPI_get_hardware_info", 2); elapsed_us = PAPI_get_real_usec(); elapsed_cyc = PAPI_get_real_cyc(); #if defined(_AIX) retval = PAPI_thread_init((unsigned long (*)(void)) (pthread_self)); if (retval != PAPI_OK) { if (retval == PAPI_ESBSTR) test_skip(__FILE__, __LINE__, "PAPI_thread_init", retval); else test_fail(__FILE__, __LINE__, "PAPI_thread_init", retval); } #pragma ibm parallel_loop #elif defined(sgi) && defined(mips) retval = PAPI_thread_init((unsigned long (*)(void)) (mp_my_threadnum)); if (retval != PAPI_OK) { test_fail(__FILE__, __LINE__, "PAPI_thread_init", retval); } #pragma parallel #pragma local(i) #pragma pfor #elif defined(sun) && defined(sparc) retval = PAPI_thread_init((unsigned long (*)(void)) (thr_self)); if (retval != PAPI_OK) { test_fail(__FILE__, __LINE__, "PAPI_thread_init", retval); } #pragma MP taskloop private(i) #else #error "Architecture not included in this test file yet." #endif for (i = 1; i < 3; i++) Thread(i, 10000000 * i); elapsed_cyc = PAPI_get_real_cyc() - elapsed_cyc; elapsed_us = PAPI_get_real_usec() - elapsed_us; if (!TESTS_QUIET) { printf("Master real usec : \t%lld\n", elapsed_us); printf("Master real cycles : \t%lld\n", elapsed_cyc); } test_pass(__FILE__, NULL, 0); exit(1); }
/** * \brief A bit-twiddling load which will run within the given bytes of memory. * \param [in] plan The struct that holds the plan's data values. * \return int Error flag value * \sa parseCBAPlan * \sa makeCBAPlan * \sa initCBAPlan * \sa perfCBAPlan * \sa killCBAPlan */ int execCBAPlan(void *plan){ #ifdef HAVE_PAPI int k; long long start, end; #endif //HAVE_PAPI int i, j; int niters; ORB_t t1, t2; Plan *p; CBA_data *ci; p = (Plan *)plan; ci = (CBA_data *)p->vptr; /* update execution count */ p->exec_count++; for(i = 0; i < ci->niter; i += NITERS){ niters = ci->niter - i; if(niters > NITERS){ niters = NITERS; } for(j = 0; j < niters; j++){ /* pick NITERS random rows in the range 1..(nrow-1) */ ci->out[j] = 1 + (brand(&(ci->br)) % (ci->nrows - 1)); ci->out[j] <<= 48; /* store index in high 16 bits */ } if(DO_PERF){ #ifdef HAVE_PAPI /* Start PAPI counters and time */ TEST_PAPI(PAPI_reset(p->PAPI_EventSet), PAPI_OK, MyRank, 9999, PRINT_SOME); start = PAPI_get_real_usec(); #endif //HAVE_PAPI ORB_read(t1); } //DO_PERF cnt_bit_arr (ci->work, ci->nrows, ci->ncols, ci->out, niters); if(DO_PERF){ ORB_read(t2); #ifdef HAVE_PAPI end = PAPI_get_real_usec(); //PAPI time /* Collect PAPI counters and store time elapsed */ TEST_PAPI(PAPI_accum(p->PAPI_EventSet, p->PAPI_Results), PAPI_OK, MyRank, 9999, PRINT_SOME); for(k = 0; k < p->PAPI_Num_Events && k < TOTAL_PAPI_EVENTS; k++){ p->PAPI_Times[k] += (end - start); } #endif //HAVE_PAPI perftimer_accumulate(&p->timers, TIMER0, ORB_cycles_a(t2, t1)); } //DO_PERF } return ERR_CLEAN; } /* execCBAPlan */
/** * \brief <DESCRIPTION of your plan goes here..> * \param plan The Plan struct that holds the plan's data values. * \return int Error flag value */ int execDOPENACCGEMMPlan(void *plan){ // <- Replace YOUR_NAME with the name of your module. #ifdef HAVE_PAPI int k; long long start, end; #endif //HAVE_PAPI ORB_t t1, t2; // Storage for timestamps, used to accurately find the runtime of the plan execution. Plan *p; p = (Plan *)plan; p->exec_count++; // Update the execution counter stored in the plan. DOPENACCGEMM_DATA *local_data = (DOPENACCGEMM_DATA *)p->vptr; int error; #ifdef HAVE_PAPI /* Start PAPI counters and time */ TEST_PAPI(PAPI_reset(p->PAPI_EventSet), PAPI_OK, MyRank, 9999, PRINT_SOME); start = PAPI_get_real_usec(); #endif //HAVE_PAPI ORB_read(t1); // Store the timestamp for the beginning of the execution. int jdx; for(jdx=0;jdx < local_data->loop_count; jdx++) { systemburn_openaccblas_dgemm(local_data); } // -------------------------------------------- // Plan is executed here... // -------------------------------------------- ORB_read(t2); // Store timestamp for the end of execution. #ifdef HAVE_PAPI end = PAPI_get_real_usec(); //PAPI time /* Collect PAPI counters and store time elapsed */ TEST_PAPI(PAPI_accum(p->PAPI_EventSet, p->PAPI_Results), PAPI_OK, MyRank, 9999, PRINT_SOME); for(k = 0; k < p->PAPI_Num_Events && k < TOTAL_PAPI_EVENTS; k++){ p->PAPI_Times[k] += (end - start); } #endif //HAVE_PAPI perftimer_accumulate(&p->timers, TIMER0, ORB_cycles_a(t2, t1)); // Store the difference between the timestamps in the plan's timers. if(CHECK_CALC){ // Evaluates to true if the '-t' option is passed on the commandline. ORB_read(t1); // ---------------------------------------------------------------- // Optional: Check calculations performed in execution above. // ---------------------------------------------------------------- ORB_read(t2); perftimer_accumulate(&p->timers, TIMER1, ORB_cycles_a(t2, t1)); } return ERR_CLEAN; // <- This inicates a clean run with no errors. Does not need to be changed. } /* execDOPENACCGEMMPlan */
void Thread( int t, int n ) { int retval, num_tests = 1; int EventSet1 = PAPI_NULL; int PAPI_event, mask1; int num_events1; long long **values; long long elapsed_us, elapsed_cyc; char event_name[PAPI_MAX_STR_LEN]; /* add PAPI_TOT_CYC and one of the events in PAPI_FP_INS, PAPI_FP_OPS or PAPI_TOT_INS, depending on the availability of the event on the platform */ EventSet1 = add_two_events( &num_events1, &PAPI_event, &mask1 ); retval = PAPI_event_code_to_name( PAPI_event, event_name ); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_event_code_to_name", retval ); values = allocate_test_space( num_tests, num_events1 ); retval = PAPI_start( EventSet1 ); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_start", retval ); elapsed_us = PAPI_get_real_usec( ); elapsed_cyc = PAPI_get_real_cyc( ); do_flops( n ); elapsed_us = PAPI_get_real_usec( ) - elapsed_us; elapsed_cyc = PAPI_get_real_cyc( ) - elapsed_cyc; retval = PAPI_stop( EventSet1, values[0] ); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_stop", retval ); remove_test_events( &EventSet1, mask1 ); if ( !TESTS_QUIET ) { printf( "Thread %#x %-12s : \t%lld\n", t, event_name, values[0][1] ); printf( "Thread %#x PAPI_TOT_CYC : \t%lld\n", t, values[0][0] ); } free_test_space( values, num_tests ); if ( !TESTS_QUIET ) { printf( "Thread %#x Real usec : \t%lld\n", t, elapsed_us ); printf( "Thread %#x Real cycles : \t%lld\n", t, elapsed_cyc ); } PAPI_unregister_thread( ); }
void Thread( int n ){ int retval, num_tests = 1; int EventSet1 = PAPI_NULL; int PAPI_event, mask1; int num_events1; long long **values; long long elapsed_us, elapsed_cyc, L1_DCM; char event_name[PAPI_MAX_STR_LEN]; printf( "Thread %#x started\n", omp_get_thread_num( ) ); num_events1 = 2; EventSet1 = add_two_events( &num_events1, &PAPI_event, &mask1 ); retval = PAPI_event_code_to_name( PAPI_event, event_name ); if ( retval != PAPI_OK ) test_fail( __FILE__, __LINE__, "PAPI_event_code_to_name", retval ); values = allocate_test_space( num_tests, num_events1 ); elapsed_us = PAPI_get_real_usec( ); elapsed_cyc = PAPI_get_real_cyc( ); retval = PAPI_start( EventSet1 ); do_flops( n ); retval = PAPI_stop( EventSet1, values[0] ); elapsed_us = PAPI_get_real_usec( ) - elapsed_us; elapsed_cyc = PAPI_get_real_cyc( ) - elapsed_cyc; remove_test_events( &EventSet1, mask1 ); if ( !TESTS_QUIET ) { printf( "Thread %#x %-12s : \t%lld\n", omp_get_thread_num( ), event_name, values[0][1] ); printf( "Thread %#x PAPI_TOT_CYC: \t%lld\n", omp_get_thread_num( ), values[0][0] ); printf( "Thread %#x Real usec : \t%lld\n", omp_get_thread_num( ), elapsed_us ); printf( "Thread %#x Real cycles : \t%lld\n", omp_get_thread_num( ), elapsed_cyc ); } free_test_space( values, num_tests ); PAPI_unregister_thread( ); printf( "Thread %#x finished\n", omp_get_thread_num( ) ); }
int main(int argc, char** argv) { int c; char* s; char* t; unsigned int distance = 0; unsigned int len_s; unsigned int len_t; /*for measuring time*/ long_long start_usec, end_usec; while ((c = getopt (argc, argv, "s:t:")) != -1) { switch(c) { case 's': s = optarg; break; case 't': t = optarg; break; case '?': if ((optopt == 's') || (optopt == 't')) fprintf(stderr, "Option -%c requires an argument.\n", optopt); else fprintf(stderr, "Unknown option `-%c'.\n", optopt); return 1; } } len_s = strlen(s); len_t = strlen(t); /*get initial time*/ start_usec = PAPI_get_real_usec(); /*computing levenshtein*/ distance = levenshtein(s, len_s, t, len_t); /*computing final time*/ end_usec = PAPI_get_real_usec(); printf("The levesthein distance: %d\n", distance); printf("\nTotal time spent: %.8f (s)\n", (end_usec - start_usec) / 1000000.0); return 0; }
int _infiniband_stop( hwd_context_t *ctx, hwd_control_state_t *ctl ) { infiniband_context_t* context = (infiniband_context_t*) ctx; infiniband_control_state_t* control = (infiniband_control_state_t*) ctl; long long now = PAPI_get_real_usec(); int i; long long temp; for (i=0 ; i<INFINIBAND_MAX_COUNTERS ; ++i) { if (control->being_measured[i]) { temp = read_ib_counter_value(i); if (context->start_value[i] && control->need_difference[i]) { /* Must subtract values, but check for wraparound. * We cannot even detect all wraparound cases. Using the short, * auto-resetting IB counters is error prone. */ if (temp < context->start_value[i]) { SUBDBG("Wraparound!\nstart:\t%#016x\ttemp:\t%#016x", (unsigned)context->start_value[i], (unsigned)temp); /* The counters auto-reset. I cannot even adjust them to * account for a simple wraparound. * Just use the current reading of the counter, which is useless. */ } else temp -= context->start_value[i]; } control->counts[i] = temp; } } control->lastupdate = now; return PAPI_OK; }
int _net_read( hwd_context_t *ctx, hwd_control_state_t *ctl, long long ** events, int flags ) { (void) flags; (void) ctx; NET_control_state_t *net_ctl = (NET_control_state_t *) ctl; long long now = PAPI_get_real_usec(); int i; /* Caching * Only read new values from /proc if enough time has passed * since the last read. */ if ( now - net_ctl->lastupdate > NET_REFRESH_LATENCY ) { read_net_counters(_net_register_current); for ( i=0; i<NET_MAX_COUNTERS; i++ ) { net_ctl->values[i] = _net_register_current[i] - _net_register_start[i]; } net_ctl->lastupdate = now; } *events = net_ctl->values; return PAPI_OK; }
void Thread( int n ) { int retval, num_tests = 1, tmp; int EventSet1 = PAPI_NULL; int mask1 = 0x5; int num_events1; long long **values; long long elapsed_us, elapsed_cyc; EventSet1 = add_test_events( &num_events1, &mask1 ); /* num_events1 is greater than num_events2 so don't worry. */ values = allocate_test_space( num_tests, num_events1 ); elapsed_us = PAPI_get_real_usec( ); elapsed_cyc = PAPI_get_real_cyc( ); retval = PAPI_start( EventSet1 ); if ( retval >= PAPI_OK ) exit( 1 ); do_flops( n ); retval = PAPI_stop( EventSet1, values[0] ); if ( retval >= PAPI_OK ) exit( 1 ); elapsed_us = PAPI_get_real_usec( ) - elapsed_us; elapsed_cyc = PAPI_get_real_cyc( ) - elapsed_cyc; remove_test_events( &EventSet1, mask1 ); printf( "Thread %#x PAPI_FP_INS : \t%lld\n", pthread_self( ), ( values[0] )[0] ); printf( "Thread %#x PAPI_TOT_CYC: \t%lld\n", pthread_self( ), ( values[0] )[1] ); printf( "Thread %#x Real usec : \t%lld\n", pthread_self( ), elapsed_us ); printf( "Thread %#x Real cycles : \t%lld\n", pthread_self( ), elapsed_cyc ); free_test_space( values, num_tests ); }
perf_counter_t perf_read(perf_t *perf) { perf_counter_t counter; counter.tick = PAPI_get_real_usec(); int retval = PAPI_read(perf->EventSet, (counter_t*)&counter.value); assert(retval == PAPI_OK); return counter; }
void ref_measurements(int iters, int *eventset, int *events, int nevents, long long *refvalues) { PAPI_event_info_t info; int i, retval; double x = 1.1, y; long long t1, t2; printf("PAPI reference measurements:\n"); if ((retval = PAPI_create_eventset(eventset))) test_fail(__FILE__, __LINE__, "PAPI_create_eventset", retval); for (i = 0; i < nevents; i++) { if ((retval = PAPI_add_event(*eventset, events[i]))) test_fail(__FILE__, __LINE__, "PAPI_add_event", retval); x = 1.0; t1 = PAPI_get_real_usec(); if ((retval = PAPI_start(*eventset))) test_fail(__FILE__, __LINE__, "PAPI_start", retval); y = dummy3(x, iters); if ((retval = PAPI_stop(*eventset, &refvalues[i]))) test_fail(__FILE__, __LINE__, "PAPI_stop", retval); t2 = PAPI_get_real_usec(); #if 0 printf("\tOperations= %.1f Mflop", y * 1e-6); printf("\t(%g Mflop/s)\n\n", ((float) y / (t2 - t1))); #endif PAPI_get_event_info(events[i], &info); printf("%20s = ", info.short_descr); printf(LLDFMT, refvalues[i]); printf("\n"); if ((retval = PAPI_cleanup_eventset(*eventset))) test_fail(__FILE__, __LINE__, "PAPI_cleanup_eventset", retval); } if ((retval = PAPI_destroy_eventset(eventset))) test_fail(__FILE__, __LINE__, "PAPI_destroy_eventset", retval); *eventset = PAPI_NULL; }
/* PAPI wallclock time */ void metric_read_papiwallclock(int tid, int idx, double values[]) { static long long oldvalue = 0L; static long long offset = 0; long long newvalue = 0L; #ifdef TAU_PAPI newvalue = PAPI_get_real_usec(); if (newvalue < oldvalue) { offset += UINT_MAX; DEBUGPROFMSG("WARNING: papi counter overflow. Fixed in TAU! new = " << newvalue << " old = " << oldvalue << " offset = " << offset << endl; );
void *Slave(void *arg) { long long duration; sleep(1); duration = PAPI_get_real_usec(); lockloop(10000,&tmpcount); duration = PAPI_get_real_usec() - duration; /* First one here set's the number */ PAPI_lock(PAPI_USR2_LOCK); if (num_iters == 0) { printf("10000 iterations took %lld us.\n",duration); num_iters = 10*(TIME_LIMIT_IN_US/duration); printf("Running %d iterations\n",num_iters); } PAPI_unlock(PAPI_USR2_LOCK); lockloop(num_iters,&count); pthread_exit(NULL); }
/** Setup the counter control structure */ int example_init_control_state( hwd_control_state_t * ctrl ) { SUBDBG( "example_init_control_state..." ); /* set the hardware to initial conditions */ example_hardware_reset( ); /* set the counters last-accessed time */ ( ( example_control_state_t * ) ctrl )->lastupdate = PAPI_get_real_usec( ); return PAPI_OK; }
int main( ) { int i, rc; long long elapsed_us, elapsed_cyc; elapsed_us = PAPI_get_real_usec( ); elapsed_cyc = PAPI_get_real_cyc( ); start_pes( 2 ); Thread( 1000000 * ( _my_pe( ) + 1 ) ); elapsed_cyc = PAPI_get_real_cyc( ) - elapsed_cyc; elapsed_us = PAPI_get_real_usec( ) - elapsed_us; printf( "Master real usec : \t%lld\n", elapsed_us ); printf( "Master real cycles : \t%lld\n", elapsed_cyc ); exit( 0 ); }
double getTime(){ #if PAPI return PAPI_get_real_usec(); #else struct timespec ts; clock_gettime( CLOCK_REALTIME, &ts ); return ( ts.tv_nsec + ts.tv_sec * 1000000000 ); /* struct timeval tv; gettimeofday( &tv, NULL ); return ( tv.tv_sec * 1000000 + tv.tv_usec );*/ #endif }
/** Triggered by PAPI_reset */ int example_reset( hwd_context_t * ctx, hwd_control_state_t * ctrl ) { (void) ctx; SUBDBG( "example_reset ctx=%p ctrl=%p...", ctx, ctrl ); /* Reset the hardware */ example_hardware_reset( ); /* Set the counters last-accessed time */ ( ( example_control_state_t * ) ctrl )->lastupdate = PAPI_get_real_usec( ); return PAPI_OK; }
/* * TIMERS: TIME STOP */ void OSCR_timer_stop(int ind) { OSCR_timer_check("timerStop", ind); if ( ! oscrTimers[ind].active ) OSCR_error("internal - timerStop, timer already stoped ->",ind); oscrTimers[ind].active = 0; #ifdef __USE_PAPI oscrTimers[ind].elapsed += ((PAPI_get_real_usec() / SCALEPAPI) - oscrTimers[ind].start); #else oscrTimers[ind].elapsed += (OSCR_wtime() - oscrTimers[ind].start); #endif }
/* * TIMERS: TIME START */ void OSCR_timer_start(int ind) { OSCR_timer_check("timerStart", ind); if ( oscrTimers[ind].active ) OSCR_error("internal - timerStart, timer already started ->",ind); oscrTimers[ind].active = 1; #ifdef __USE_PAPI oscrTimers[ind].start = PAPI_get_real_usec() / SCALEPAPI; #else oscrTimers[ind].start = OSCR_wtime(); #endif }
/** * @brief Return the time in nanoseconds from first call to trios_get_time_*. */ uint64_t trios_get_time_ns() { uint64_t result = 0; #ifdef USING_PAPI long_long cur_usec, diff_usec; init_timer(); cur_usec = PAPI_get_real_usec(); diff_usec = cur_usec - init_usec; /* to convert to ns, multiply by 1000 */ result = diff_usec * 1000; #endif #ifdef USING_CLOCK_GETTIME struct timespec tp; init_timer(); clock_gettime(clockid, &tp); result = ts_diff_nsec(ts_init, tp); #endif #ifdef USING_MACH_ABSOLUTE_TIME static mach_timebase_info_data_t info = {0,0}; init_timer(); if (info.denom == 0) mach_timebase_info(&info); result = mach_absolute_time() * (info.numer / info.denom); #endif #ifdef USING_GETTIMEOFDAY struct timeval tp; init_timer(); gettimeofday( &tp, NULL ); result = tv_diff_us(tv_init, tp); result = result*(uint64_t)1000; #endif return result; }
int _infiniband_start( hwd_context_t *ctx, hwd_control_state_t *ctl ) { infiniband_context_t* context = (infiniband_context_t*) ctx; infiniband_control_state_t* control = (infiniband_control_state_t*) ctl; long long now = PAPI_get_real_usec(); int i; for (i=0 ; i<INFINIBAND_MAX_COUNTERS ; ++i) { if (control->being_measured[i] && control->need_difference[i]) { context->start_value[i] = read_ib_counter_value(i); } } control->lastupdate = now; return PAPI_OK; }
int _net_stop( hwd_context_t *ctx, hwd_control_state_t *ctl ) { (void) ctx; NET_control_state_t *net_ctl = (NET_control_state_t *) ctl; long long now = PAPI_get_real_usec(); int i; read_net_counters(_net_register_current); for ( i=0; i<NET_MAX_COUNTERS; i++ ) { net_ctl->values[i] = _net_register_current[i] - _net_register_start[i]; } net_ctl->lastupdate = now; return PAPI_OK; }
int _net_start( hwd_context_t *ctx, hwd_control_state_t *ctl ) { ( void ) ctx; NET_control_state_t *net_ctl = (NET_control_state_t *) ctl; long long now = PAPI_get_real_usec(); read_net_counters(_net_register_start); memcpy(_net_register_current, _net_register_start, NET_MAX_COUNTERS * sizeof(_net_register_start[0])); /* set initial values to 0 */ memset(net_ctl->values, 0, NET_MAX_COUNTERS*sizeof(net_ctl->values[0])); /* Set last access time for caching purposes */ net_ctl->lastupdate = now; return PAPI_OK; }
static void init_timer() { static int initialized = 0; if (!initialized) { int mpi_initialized=0; #ifdef USING_PAPI PAPI_library_init(PAPI_VER_CURRENT); init_usec = PAPI_get_real_usec(); init_cycles = PAPI_get_real_cyc(); #endif #ifdef USING_CLOCK_GETTIME clock_getres(clockid, &ts_res); clock_gettime(clockid, &ts_init); #endif #ifdef USING_GETTIMEOFDAY gettimeofday(&tv_init, NULL); #endif initialized = 1; } }