自学教程：C++ timer_get函数代码示例

fsal_status_t FSAL_uint64_to_cookie(fsal_handle_t *handle,                                    fsal_op_context_t *p_context,                                    uint64_t *data,                                    fsal_cookie_t *cookie){  fsal_status_t  rc;  msectimer_t    timer_start, timer_end;  timer_start = timer_get();  if (fsal_functions.fsal_uint64_to_cookie)    {      rc = fsal_functions.fsal_uint64_to_cookie(handle,                                                data,                                                cookie);    }  else    {      memset(cookie, 0, sizeof(fsal_cookie_t));      memcpy(cookie, data, sizeof(uint64_t));      ReturnCode(ERR_FSAL_NO_ERROR, 0);    }  timer_end = timer_get();  p_context->latency += timer_end - timer_start;  p_context->count++;  return rc;}

int main(int argc, char **argv){	timer_init();    ((void) argc);        total = 0;        rank = atoi(argv[0]);        open_noc_connectors();	    getwork();	start = timer_get();    friendly_numbers();	end = timer_get();    syncNumbers();	total = timer_diff(start, end);	data_send(outfd, &total, sizeof(uint64_t));    /* Close channels. */    mppa_close(infd);    mppa_close(outfd);    mppa_exit(0);    return (0);}

fsal_status_t FSAL_getattrs_descriptor(fsal_file_t * p_file_descriptor,         /* IN */                                       fsal_handle_t * p_filehandle,            /* IN */                                       fsal_op_context_t * p_context,           /* IN */                                       fsal_attrib_list_t * p_object_attributes /* IN/OUT */ ){  fsal_status_t  rc;  msectimer_t    timer_start, timer_end;  timer_start = timer_get();   if(fsal_functions.fsal_getattrs_descriptor != NULL && p_file_descriptor != NULL)    {      LogFullDebug(COMPONENT_FSAL,                   "FSAL_getattrs_descriptor calling fsal_getattrs_descriptor");      rc = fsal_functions.fsal_getattrs_descriptor(p_file_descriptor, p_filehandle, p_context, p_object_attributes);    }  else    {      LogFullDebug(COMPONENT_FSAL,                   "FSAL_getattrs_descriptor calling fsal_getattrs");      rc = fsal_functions.fsal_getattrs(p_filehandle, p_context, p_object_attributes);    }  timer_end = timer_get();  p_context->latency += timer_end - timer_start;  p_context->count++;  return rc;}

fsal_status_t FSAL_share_op( fsal_file_t       * p_file_descriptor,   /* IN */                             fsal_handle_t     * p_filehandle,        /* IN */                             fsal_op_context_t * p_context,           /* IN */                             void              * p_owner,             /* IN (opaque to FSAL) */                             fsal_share_param_t  request_share)       /* IN */{  fsal_status_t  rc;  msectimer_t    timer_start, timer_end;  timer_start = timer_get();  if(fsal_functions.fsal_share_op != NULL)    rc = fsal_functions.fsal_share_op(p_file_descriptor,                                      p_filehandle,                                      p_context,                                      p_owner,                                      request_share);  else    Return(ERR_FSAL_NOTSUPP, 0, INDEX_FSAL_share_op);  timer_end = timer_get();  p_context->latency += timer_end - timer_start;  p_context->count++;  return rc;}

fsal_status_t FSAL_readdir(fsal_dir_t * p_dir_descriptor,       /* IN */                           fsal_op_context_t * p_context,       /* IN */                           fsal_cookie_t start_position,        /* IN */                           fsal_attrib_mask_t get_attr_mask,    /* IN */                           fsal_mdsize_t buffersize,    /* IN */                           fsal_dirent_t * p_pdirent,   /* OUT */                           fsal_cookie_t * p_end_position,      /* OUT */                           fsal_count_t * p_nb_entries, /* OUT */                           fsal_boolean_t * p_end_of_dir /* OUT */ ){  fsal_status_t  rc;  msectimer_t    timer_start, timer_end;  timer_start = timer_get();  rc = fsal_functions.fsal_readdir(p_dir_descriptor, p_context, start_position, get_attr_mask,                                   buffersize, p_pdirent, p_end_position, p_nb_entries,                                   p_end_of_dir);  timer_end = timer_get();  p_context->latency += timer_end - timer_start;  p_context->count++;  return rc;}

/* * Initializes the timer. */void timer_init(void){  uint64_t start, end;    start = timer_get();  end = timer_get();    timer_error = (end - start);}

void task_schedule(GameState *state, task_t *tasks, uint8_t num_tasks) {    uint8_t i;    timer_tick_t now;    task_t *next_task;    GameMode initial_mode = state->mode;    timer_init();    now = timer_get();    /* Start by scheduling the first task.  */    next_task = tasks;    while (state->mode == initial_mode) {        timer_tick_t sleep_min;        /* Wait until the next task is ready to run.  */        timer_wait_until (next_task->reschedule);        /* Schedule the task.  */        next_task->func (state);        /* Update the reschedule time.  */        next_task->reschedule += next_task->period;        sleep_min = ~0;        now = timer_get ();        /* Search array of tasks.  Schedule the first task (highest priority)           that needs to run otherwise wait until first task ready.  */        for (i = 0; i < num_tasks; i++) {            task_t * task = tasks + i;            timer_tick_t overrun;            overrun = now - task->reschedule;            if (overrun < TASK_OVERRUN_MAX) {                /* Have found a task that can run immediately.  */                next_task = task;                break;            }            else {                timer_tick_t sleep;                sleep = -overrun;                if (sleep < sleep_min)                {                    sleep_min = sleep;                    next_task = task;                }            }        }    }}

/* * Runs benchmark. */int main(int argc, char **argv){	int i;              /* Loop index. */	double *mask;       /* Mask.       */	uint64_t end;       /* End time.   */	uint64_t start;     /* Start time. */	unsigned char *img; /* Image.      */		readargs(argc, argv);		timer_init();	srandnum(seed);		/* Benchmark initialization. */	if (verbose)		printf("initializing.../n");	start = timer_get();	img = smalloc(p->imgsize*p->imgsize*sizeof(char));	for (i = 0; i < p->imgsize*p->imgsize; i++)		img[i] = randnum() & 0xff;	mask = smalloc(p->masksize*p->masksize*sizeof(double));	generate_mask(mask);	end = timer_get();	if (verbose)		printf("  time spent: %f/n", timer_diff(start, end)*MICROSEC);			/* Apply filter. */	if (verbose)		printf("applying filter.../n");	start = timer_get();	gauss_filter(img, p->imgsize, mask, p->masksize);	end = timer_get();		total = timer_diff(start, end);	/* Print timing statistics. */	printf("timing statistics:/n");	printf("  master:        %f/n", master*MICROSEC);	for (i = 0; i < nclusters; i++)		printf("  slave %d:      %f/n", i, slave[i]*MICROSEC);	printf("  communication: %f/n", communication*MICROSEC);	printf("  total time:    %f/n", total*MICROSEC);		/* House keeping. */	free(mask);	free(img);		return (0);}

fsal_status_t FSAL_InitClientContext(fsal_op_context_t * p_context){  fsal_status_t  rc;  msectimer_t    timer_start, timer_end;  timer_start = timer_get();  rc = fsal_functions.fsal_initclientcontext(p_context);  timer_end = timer_get();  p_context->latency += timer_end - timer_start;  p_context->count++;  return rc;}

void pulse_control_init(void)// Initialize servo pulse control.{    // Initialize the pulse time values.    pulse_flag = 0;    pulse_duration = 0;    overflow_count = 0;    // Initialize the pulse time.    pulse_time = timer_get();    // Set timer/counter2 control register A.    TCCR2A = (0<<COM2A1) | (0<<COM2A0) |                    // Disconnect OC2A.             (0<<COM2B1) | (0<<COM2B0) |                    // Disconnect OC2B.             (0<<WGM21) | (0<<WGM20);                       // Mode 0 - normal operation.    // Configure PCINT3 to interrupt on change.    PCMSK0 = (1<<PCINT3);    PCMSK1 = 0;    PCMSK2 = 0;    PCICR = (0<<PCIE2) |            (0<<PCIE1) |            (1<<PCIE0);    // Configure PB0/PCINT3 as an input.    DDRB &= ~(1<<DDB3);    PORTB &= ~(1<<PB3);}

 virtual void TearDown() {   SC_closePort(fdin);   Shakespeare::log(Shakespeare::NOTICE, PROCESS, ">>>>>>>>>>>>>>>>>>>>>> END TEST <<<<<<<<<<<<<<<<<<<<<<");   // start timer from call   timer_t wait_timer = timer_get();   timer_start(&wait_timer,2,0);   while (!timer_complete(&wait_timer)) { /* pause */ } }

fsal_status_t FSAL_closedir(fsal_dir_t * p_dir_descriptor, /* IN */                             fsal_op_context_t * p_context  /* IN */ ){  fsal_status_t  rc;  msectimer_t    timer_start, timer_end;  timer_start = timer_get();  rc = fsal_functions.fsal_closedir(p_dir_descriptor, p_context);  timer_end = timer_get();  p_context->latency += timer_end - timer_start;  p_context->count++;  return rc;}

void busy_wait(unsigned int ds){    timer_enable(0);    timer_set_reload(0);    timer_set_counter(get_system_frequency()/10*ds);    timer_enable(1);    while(timer_get());}

fsal_status_t FSAL_link_access(fsal_op_context_t * p_context,    /* IN */                               fsal_attrib_list_t * pattr)      /* IN */{  fsal_status_t  rc;  msectimer_t    timer_start, timer_end;  timer_start = timer_get();  rc = fsal_functions.fsal_link_access(p_context, pattr);  timer_end = timer_get();  p_context->latency += timer_end - timer_start;  p_context->count++;  return rc;}

/* * Runs benchmark. */int main(int argc, char **argv){	int i;          /* Loop index.         */	int *a;         /* Array to be sorted. */	uint64_t end;   /* End time.           */	uint64_t start; /* Start time.         */		readargs(argc, argv);		timer_init();	srandnum(seed);		/* Benchmark initialization. */	if (verbose)		printf("initializing.../n");	start = timer_get();	a = smalloc(p->n*sizeof(int));	for (i = 0; i < p->n; i++)		a[i] = randnum() & 0xfffff;	end = timer_get();	if (verbose)		printf("  time spent: %f/n", timer_diff(start, end)*MICROSEC);		/* Cluster data. */	if (verbose)		printf("sorting.../n");	start = timer_get();	bucketsort(a, p->n);	end = timer_get();	total = timer_diff(start, end);	/* Print timing statistics. */	printf("timing statistics:/n");	printf("  master:        %f/n", master*MICROSEC);	for (i = 0; i < nclusters; i++)		printf("  slave %d:      %f/n", i, slave[i]*MICROSEC);	printf("  communication: %f/n", communication*MICROSEC);	printf("  total time:    %f/n", total*MICROSEC);		/* House keeping. */	free(a);		return (0);}

fsal_status_t FSAL_test_access(fsal_op_context_t * p_context,   /* IN */                               fsal_accessflags_t access_type,  /* IN */                               fsal_attrib_list_t * p_object_attributes /* IN */ ){  fsal_status_t  rc;  msectimer_t    timer_start, timer_end;  timer_start = timer_get();  rc = fsal_functions.fsal_test_access(p_context, access_type, p_object_attributes);  timer_end = timer_get();  p_context->latency += timer_end - timer_start;  p_context->count++;  return rc;}

fsal_status_t FSAL_RemoveXAttrById(fsal_handle_t * p_objecthandle,      /* IN */                                   fsal_op_context_t * p_context,       /* IN */                                   unsigned int xattr_id)       /* IN */{  fsal_status_t  rc;  msectimer_t    timer_start, timer_end;  timer_start = timer_get();  rc = fsal_functions.fsal_removexattrbyid(p_objecthandle, p_context, xattr_id);  timer_end = timer_get();  p_context->latency += timer_end - timer_start;  p_context->count++;  return rc;}

fsal_status_t FSAL_close_by_fileid(fsal_file_t * file_descriptor /* IN */ ,                                   fsal_op_context_t * p_context,  /* IN */                                   fsal_u64_t fileid){  fsal_status_t  rc;  msectimer_t    timer_start, timer_end;  timer_start = timer_get();  rc = fsal_functions.fsal_close_by_fileid(file_descriptor, p_context, fileid);  timer_end = timer_get();  p_context->latency += timer_end - timer_start;  p_context->count++;  return rc;}

fsal_status_t FSAL_getattrs(fsal_handle_t * p_filehandle,       /* IN */                            fsal_op_context_t * p_context,      /* IN */                            fsal_attrib_list_t * p_object_attributes /* IN/OUT */ ){  fsal_status_t  rc;  msectimer_t    timer_start, timer_end;  timer_start = timer_get();  rc = fsal_functions.fsal_getattrs(p_filehandle, p_context, p_object_attributes);  timer_end = timer_get();  p_context->latency += timer_end - timer_start;  p_context->count++;  return rc;}

int timer_get_seconds(){	if (!Timer_inited) {		Int3();		return 0;	}	return (timer_get() / 1000);}

int timer_get_microseconds(){	if (!Timer_inited) {		Int3();					// Make sure you call timer_init before anything that uses timer functions!		return 0;	}	return timer_get() * 1000;}

fsal_status_t FSAL_dynamic_fsinfo(fsal_handle_t * p_filehandle, /* IN */                                  fsal_op_context_t * p_context,        /* IN */                                  fsal_dynamicfsinfo_t * p_dynamicinfo /* OUT */ ){  fsal_status_t  rc;  msectimer_t    timer_start, timer_end;  timer_start = timer_get();  rc = fsal_functions.fsal_dynamic_fsinfo(p_filehandle, p_context, p_dynamicinfo);  timer_end = timer_get();  p_context->latency += timer_end - timer_start;  p_context->count++;  return rc;}

fsal_status_t FSAL_RemoveXAttrByName(fsal_handle_t * p_objecthandle,    /* IN */                                     fsal_op_context_t * p_context,     /* IN */                                     const fsal_name_t * xattr_name)    /* IN */{  fsal_status_t  rc;  msectimer_t    timer_start, timer_end;  timer_start = timer_get();  rc = fsal_functions.fsal_removexattrbyname(p_objecthandle, p_context, xattr_name);  timer_end = timer_get();  p_context->latency += timer_end - timer_start;  p_context->count++;  return rc;}

void cpu_get_timer(QEMUFile *f, CPUTimer *s){    qemu_get_be32s(f, &s->frequency);    qemu_get_be32s(f, &s->disabled);    qemu_get_be64s(f, &s->disabled_mask);    qemu_get_sbe64s(f, &s->clock_offset);    timer_get(f, s->qtimer);}

/** * @function:   timer_restart * @param:      timer_callback_t, timer event callback function. * @brief:      Restarts the timer instance for the given callback function. */void timer_restart (timer_callback_t callback){	struct timer_t * timer = timer_get (callback);		if (timer == NULL)		return;		timer->start = clock_time ();}

/* * Runs benchmark. */int main(int argc, char **argv){	int i;          /* Loop index.      */	int *map;       /* Map of clusters. */	uint64_t end;   /* End time.        */	uint64_t start; /* Start time.      */	vector_t *data; /* Data points.     */		readargs(argc, argv);	printf("CAPBench - KM kernel/n");	printf("  # of threads: %d /n", nthreads);		timer_init();	srandnum(seed);	omp_set_num_threads(nthreads);		/* Benchmark initialization. */	start = timer_get();	data = smalloc(p->npoints*sizeof(vector_t));	for (i = 0; i < p->npoints; i++)	{		data[i] = vector_create(p->dimension);		vector_random(data[i]);	}	end = timer_get();		/* Cluster data. */	printf("Entering in KM ROI - Clustering data.../n");	start = timer_get();	m5_reset_stats(0,0);	map = kmeans(data, p->npoints, p->ncentroids, p->mindistance);	end = timer_get();	m5_dump_stats(0,0);			printf("KM total time:    %f/n", timer_diff(start, end)*MICROSEC);		/* House keeping. */	free(map);	for (i = 0; i < p->npoints; i++)		vector_destroy(data[i]);	free(data);		return (0);}

//zwraca czas w ms jaki czas up
C++ timer_get_fixed_seconds函数代码示例
C++ timer_free函数代码示例