Ejemplo n.º 1
0
void timer_handler(int signo, siginfo_t *info, void *context){
	int i, ret;
	//Read the values with PAPI
	if(signo == SIGRTMIN){
        scheduler_value = 0;

        if((ret = PAPI_accum(scheduler_eventset, &scheduler_value)) != PAPI_OK){
    		fprintf(stderr, "PAPI error: Couldn't read the values %s\n", PAPI_strerror(ret));
    		exit(20);
    	}
    	//Test the quota and send the sigstop
        //fprintf(stderr, "%lld\n", scheduler_value);
    	rt_quota_l3 -= scheduler_value;

    	if((rt_quota_l3 <= 0) && (send == 0)){
            fprintf(stderr, "Scheduler (%d) > Quota exceeded will stop attackers\n", getpid());
    		for(i=0; i<nb_attackers; i++)
    			kill(pid_attacker[i],SIGSTOP);
            send = 1;
    	}

    	new_window --;

    	//If new window send SIGCONT to attackers
        if(!new_window){
            fprintf(stderr, "Scheduler (%d) > New window\n", getpid());
            for(i=0; i<nb_attackers; i++)
        	   kill(pid_attacker[i], SIGCONT);
            new_window = 200;
            rt_quota_l3 = MEMORY_QUOTA;
            send = 0;
        }
    }
}
Ejemplo n.º 2
0
/**
 * \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 */
Ejemplo n.º 3
0
/**
 * \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 */
Ejemplo n.º 4
0
int HWCBE_PAPI_Accum (unsigned int tid, long long *store_buffer)
{
	if (PAPI_accum(HWCEVTSET(tid), store_buffer) != PAPI_OK)
	{
		fprintf (stderr, PACKAGE_NAME": PAPI_accum failed for thread %d evtset %d (%s:%d)\n", \
			tid, HWCEVTSET(tid), __FILE__, __LINE__);
		return 0;		
	}
	return 1;
}
Ejemplo n.º 5
0
int _internal_hl_read_cnts(long long * values, int array_len, int flag)
{
   int retval;
   HighLevelInfo *state = NULL;

   if ((retval = _internal_check_state(&state)) != PAPI_OK)
      return (retval);

   if (state->running != HL_START_COUNTERS || array_len < state->num_evts)
      return (PAPI_EINVAL);

   if (flag == PAPI_HL_ACCUM)
      return (PAPI_accum(state->EventSet, values));
   else if (flag == PAPI_HL_READ) {
      if ((retval = PAPI_read(state->EventSet, values)) != PAPI_OK)
         return (retval);
      return (PAPI_reset(state->EventSet));
   }

   /* Invalid flag passed in */
   return (PAPI_EINVAL);
}
Ejemplo n.º 6
0
int main(int argc, char **argv)
{
   int i, retval, EventSet = PAPI_NULL;
   int bins = 100;
   int show_dist = 0, show_std_dev = 0;
   long long totcyc, values[2];
   long long *array;


   tests_quiet(argc, argv);     /* Set TESTS_QUIET variable */

   for (i = 0; i < argc; i++) {
      if (argv[i]) {
         if (strstr(argv[i], "-b")) {
            bins = atoi(argv[i+1]);
            if (bins) i++;
            else {
               printf ("-b requires a bin count!\n");
               exit(1);
            }
         }
         if (strstr(argv[i], "-d"))
            show_dist = 1;
         if (strstr(argv[i], "-h")) {
            print_help();
            exit(1);
         }
         if (strstr(argv[i], "-s"))
            show_std_dev = 1;
         if (strstr(argv[i], "-t")) {
            num_iters = atol(argv[i+1]);
            if (num_iters) i++;
            else {
               printf ("-t requires a threshold value!\n");
               exit(1);
            }
         }
      }
   }

   printf("Cost of execution for PAPI start/stop, read and accum.\n");
   printf("This test takes a while. Please be patient...\n");

   if ((retval = PAPI_library_init(PAPI_VER_CURRENT)) != PAPI_VER_CURRENT)
      test_fail(__FILE__, __LINE__, "PAPI_library_init", retval);
   if ((retval = PAPI_set_debug(PAPI_VERB_ECONT)) != PAPI_OK)
      test_fail(__FILE__, __LINE__, "PAPI_set_debug", retval);
   if ((retval = PAPI_query_event(PAPI_TOT_CYC)) != PAPI_OK)
      test_fail(__FILE__, __LINE__, "PAPI_query_event", retval);
   if ((retval = PAPI_query_event(PAPI_TOT_INS)) != PAPI_OK)
      test_fail(__FILE__, __LINE__, "PAPI_query_event", retval);
   if ((retval = PAPI_create_eventset(&EventSet)) != PAPI_OK)
      test_fail(__FILE__, __LINE__, "PAPI_create_eventset", retval);

   if ((retval = PAPI_add_event(EventSet, PAPI_TOT_CYC)) != PAPI_OK)
      test_fail(__FILE__, __LINE__, "PAPI_add_event", retval);

   if ((retval = PAPI_add_event(EventSet, PAPI_TOT_INS)) != PAPI_OK)
      if ((retval = PAPI_add_event(EventSet, PAPI_TOT_IIS)) != PAPI_OK)
         test_fail(__FILE__, __LINE__, "PAPI_add_event", retval);

   /* Make sure no errors and warm up */

   totcyc = PAPI_get_real_cyc();
   if ((retval = PAPI_start(EventSet)) != PAPI_OK)
      test_fail(__FILE__, __LINE__, "PAPI_start", retval);
   if ((retval = PAPI_stop(EventSet, NULL)) != PAPI_OK)
      test_fail(__FILE__, __LINE__, "PAPI_stop", retval);

   array = (long long *)malloc(num_iters*sizeof(long long));
   if (array == NULL ) 
      test_fail(__FILE__, __LINE__, "PAPI_stop", retval);

   /* Determine clock latency */

   printf("\nPerforming loop latency test...\n");

   for (i = 0; i < num_iters; i++) {
      totcyc = PAPI_get_real_cyc();
      totcyc = PAPI_get_real_cyc() - totcyc;
      array[i] = totcyc;
   }

   do_output(0, array, bins, show_std_dev, show_dist);

   /* Start the start/stop eval */

   printf("\nPerforming start/stop test...\n");

   for (i = 0; i < num_iters; i++) {
      totcyc = PAPI_get_real_cyc();
      PAPI_start(EventSet);
      PAPI_stop(EventSet, values);
      totcyc = PAPI_get_real_cyc() - totcyc;
      array[i] = totcyc;
   }

   do_output(1, array, bins, show_std_dev, show_dist);

   /* Start the read eval */
   printf("\nPerforming read test...\n");

   if ((retval = PAPI_start(EventSet)) != PAPI_OK)
      test_fail(__FILE__, __LINE__, "PAPI_start", retval);
   PAPI_read(EventSet, values);

   for (i = 0; i < num_iters; i++) {
      totcyc = PAPI_get_real_cyc();
      PAPI_read(EventSet, values);
      totcyc = PAPI_get_real_cyc() - totcyc;
      array[i] = totcyc;
   }
   if ((retval = PAPI_stop(EventSet, values)) != PAPI_OK)
      test_fail(__FILE__, __LINE__, "PAPI_stop", retval);

   do_output(2, array, bins, show_std_dev, show_dist);

   /* Start the read with timestamp eval */
   printf("\nPerforming read with timestamp test...\n");

   if ((retval = PAPI_start(EventSet)) != PAPI_OK)
      test_fail(__FILE__, __LINE__, "PAPI_start", retval);
   PAPI_read_ts(EventSet, values, &totcyc);

   for (i = 0; i < num_iters; i++) {
      PAPI_read_ts(EventSet, values, &array[i]);
   }
   if ((retval = PAPI_stop(EventSet, values)) != PAPI_OK)
      test_fail(__FILE__, __LINE__, "PAPI_stop", retval);

   /* post-process the timing array */
   for (i = num_iters - 1; i > 0 ; i--) {
      array[i] -= array[i-1];
   }
   array[0] -= totcyc;

   do_output(3, array, bins, show_std_dev, show_dist);

   /* Start the accum eval */
   printf("\nPerforming accum test...\n");

   if ((retval = PAPI_start(EventSet)) != PAPI_OK)
      test_fail(__FILE__, __LINE__, "PAPI_start", retval);
   PAPI_accum(EventSet, values);

   for (i = 0; i < num_iters; i++) {
      totcyc = PAPI_get_real_cyc();
      PAPI_accum(EventSet, values);
      totcyc = PAPI_get_real_cyc() - totcyc;
      array[i] = totcyc;
   }
   if ((retval = PAPI_stop(EventSet, values)) != PAPI_OK)
      test_fail(__FILE__, __LINE__, "PAPI_stop", retval);

   do_output(4, array, bins, show_std_dev, show_dist);

   /* Start the reset eval */
   printf("\nPerforming reset test...\n");

   if ((retval = PAPI_start(EventSet)) != PAPI_OK)
      test_fail(__FILE__, __LINE__, "PAPI_start", retval);

   for (i = 0; i < num_iters; i++) {
      totcyc = PAPI_get_real_cyc();
      PAPI_reset(EventSet);
      totcyc = PAPI_get_real_cyc() - totcyc;
      array[i] = totcyc;
   }
   if ((retval = PAPI_stop(EventSet, values)) != PAPI_OK)
      test_fail(__FILE__, __LINE__, "PAPI_stop", retval);

   do_output(5, array, bins, show_std_dev, show_dist);

   free(array);
   test_pass(__FILE__, NULL, 0);
   exit(1);
}
Ejemplo n.º 7
0
#endif

/**	@class PAPIF_accum
 *	@ingroup PAPIF
 *	@brief accumulate and reset counters in an event set 
 *	
 *	@par Fortran Interface:
 *	\#include "fpapi.h" @n
 *	PAPIF_accum( C_INT EventSet, C_LONG_LONG(*) values, C_INT  check )
 *
 *	@see PAPI_accum
 */
PAPI_FCALL( papif_accum, PAPIF_ACCUM,
			( int *EventSet, long long *values, int *check ) )
{
	*check = PAPI_accum( *EventSet, values );
}

/**	@class PAPIF_add_event
 *	@ingroup PAPIF
 *	@brief add PAPI preset or native hardware event to an event set
 *	
 *	@par Fortran Interface:
 *	\#include "fpapi.h" @n
 *	PAPIF_add_event( C_INT EventSet, C_INT EventCode, C_INT check )
 *
 *	@see PAPI_add_event
 */
PAPI_FCALL( papif_add_event, PAPIF_ADD_EVENT,
			( int *EventSet, int *Event, int *check ) )
{
Ejemplo n.º 8
0
/**
 * \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 execOPENCL_MEMPlan(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.
    OPENCL_MEM_DATA *local_data = (OPENCL_MEM_DATA *)p->vptr;

    cl_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.

    size_t work_size[1];
    int idx,jdx;
    cl_mem buffer;

    for(jdx = 0; jdx < local_data->loop_count; jdx++){
        for(idx = 0; idx < NUM_PATTERNS; idx++){
            error = clSetKernelArg(local_data->kernel,0,sizeof(cl_mem),&(local_data->buffer));
            assert(error == CL_SUCCESS);
            error = clSetKernelArg(local_data->kernel,1,sizeof(cl_ulong),(void *)&patterns[idx]);
            assert(error == CL_SUCCESS);
            work_size[0] = local_data->device_memory / sizeof(unsigned int);
            error = clEnqueueNDRangeKernel(local_data->opencl_queue, local_data->kernel, 1, NULL, work_size, NULL, 0, NULL, NULL);
            assert(error == CL_SUCCESS);

            clEnqueueReadBuffer(local_data->opencl_queue, local_data->buffer, CL_TRUE, 0, local_data->device_memory, local_data->return_buffer, 0, NULL, NULL);
        }
    }
    // --------------------------------------------
    // 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.
} /* execOPENCL_MEMPlan */
Ejemplo n.º 9
0
/**
 * \brief A 2 dimensional complex fast Fourier transform in a memory footprint of "size" bytes.
 * \param [in] plan Holds the data and memory for the plan.
 * \return int Error flag value
 * \sa parseFFT2Plan
 * \sa makeFFT2Plan
 * \sa initFFT2Plan
 * \sa perfFFT2Plan
 * \sa killFFT2Plan
 */
int execFFT2Plan(void *plan){
    #ifdef HAVE_PAPI
    int k;
    long long start, end;
    #endif //HAVE_PAPI

    int i;
    ORB_t t1, t2;
    Plan *p;
    FFTdata *d;
    p = (Plan *)plan;
    d = (FFTdata *)p->vptr;
    assert(d);
    assert(d->forward);
    assert(d->backward);
    /* update execution count */
    p->exec_count++;
//	for(i=0;i<d->M;i++) {
    if(d->forward){
        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

        fftw_execute(d->forward);

        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
    }
    if(d->backward){
        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

        fftw_execute(d->backward);

        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, TIMER1, ORB_cycles_a(t2, t1));
        }         //DO_PERF
    }
//	}
    return ERR_CLEAN;
} /* execFFT2Plan */