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

staticint play(struct audio_play *play){  update_stats(play->stats, play->nsamples, play->samples[0]);  if (play->samples[1])    update_stats(play->stats, play->nsamples, play->samples[1]);  return 0;}

int sent_xmsg_stats(User *usr, XMsg *x, char *name) {	switch(x->type) {		case XMSG_X:			usr->xsent++;			user_dirty(usr, "xsent");			update_stats(usr);			inc_stats(STATS_XSENT);			break;		case XMSG_EMOTE:			usr->esent++;			user_dirty(usr, "esent");			update_stats(usr);			inc_stats(STATS_ESENT);			break;		case XMSG_FEELING:			usr->fsent++;			user_dirty(usr, "fsent");			update_stats(usr);			inc_stats(STATS_FSENT);			break;		case XMSG_QUESTION:			usr->qsent++;			user_dirty(usr, "qsent");			update_stats(usr);			inc_stats(STATS_QSENT);			break;		case XMSG_ANSWER:			usr->qansw++;			user_dirty(usr, "qansw");			update_stats(usr);			inc_stats(STATS_QANSW);			break;		default:			;	}	if (name != NULL) {							/* add to talked_to list */		if (usr->talked_to.len <= 0)			gstrcpy(&(usr->talked_to), name);		else {			if (!cstrfind(usr->talked_to.str, name, ',')) {				gstrcat(&(usr->talked_to), ",");				gstrcat(&(usr->talked_to), name);			}		}	}	return 0;}

void *worker(void *arg){	struct lockinfo *l = (struct lockinfo *)arg;	int burn_count = 0;	pthread_t tid = pthread_self();	size_t pagesize = getpagesize();	char *buf = malloc(pagesize);	if (!buf) {		perror("malloc");		exit(1);	}	l->tid = tid;	workers_started = 1;	smp_mb();	while(!all_done) {		l->ops->wait(l);		if (all_done)			break;		burn_count++;	}	pthread_mutex_lock(&worklist_mutex);	total_burns += burn_count;	if (burn_count < min_burns)		min_burns = burn_count;	if (burn_count > max_burns)		max_burns = burn_count;	update_stats(&burn_stats, burn_count);	thread_count--;	pthread_mutex_unlock(&worklist_mutex);	return (void *)0;}

void TournamentSR::round_finished_set_time(Player *p, GTransportTime *race) {    /* server side */    TimesOfPlayer *top = get_times_of_player(p);    if (top) {        GTransportTime *tm = new GTransportTime;        *tm = *race;        tm->to_net();        add_state_response(GPCScoreTransportRaw, GTransportTimeLen, tm);        float diff = race->ms / 1000.0f;        TimesOfPlayer& first_top = times_of_players[0];        bool has_entries = first_top.times.size() > 0;        float best_time = first_top.best;        update_stats(top, diff);        if ((has_entries && diff < best_time) || !has_entries) {            sprintf(buffer, "new record of %s: %.2f", p->get_player_name().c_str(), diff);            add_msg_response(buffer);            add_sound_response("round_complete_best");            if (logger) {                logger->log(ServerLogger::LogTypeRoundFinished, buffer, p, 0, &diff);            }        } else {            add_sound_response("round_complete");            if (logger) {                logger->log(ServerLogger::LogTypeRoundFinished, "round completed", p, 0, &diff);            }        }    }}

	void feed(buffer_s16_t src, Callback callback) {		consume_audio_buffer(src);		if( update_stats(src.count, src.sampling_rate) ) {			callback(statistics);		}	}

void action_t::execute(){  if ( sim -> log && ! dual )   {    log_t::output( sim, "%s performs %s (%.0f)", player -> name(), name(),                    player -> resource_current[ player -> primary_resource() ] );  }  if ( observer ) *observer = 0;  player_buff();  target_debuff( DMG_DIRECT );  calculate_result();  consume_resource();  if ( result_is_hit() )  {    calculate_direct_damage();    if ( direct_dmg > 0 )    {      assess_damage( direct_dmg, DMG_DIRECT );    }    if ( num_ticks > 0 )    {      if ( dot_behavior == DOT_REFRESH )      {        current_tick = 0;        if ( ! ticking ) schedule_tick();      }      else      {        if ( ticking ) cancel();        snapshot_haste = haste();        schedule_tick();      }    }  }  else  {    if ( sim -> log )    {      log_t::output( sim, "%s avoids %s (%s)", sim -> target -> name(), name(), util_t::result_type_string( result ) );      log_t::miss_event( this );    }  }  update_ready();  if ( ! dual ) update_stats( DMG_DIRECT );  schedule_travel();  if ( repeating && ! proc ) schedule_execute();  if ( harmful ) player -> in_combat = true;}

/** * Send request to peer to start add him to to the set of experimentation nodes * * @param peer the peer to send to */static voidsend_experimentation_request (const struct GNUNET_PeerIdentity *peer){  struct Node *n;  struct NodeComCtx *e_ctx;  size_t size;  size_t c_issuers;  c_issuers = GNUNET_CONTAINER_multihashmap_size (valid_issuers);  size = sizeof (struct Experimentation_Request) +    c_issuers * sizeof (struct GNUNET_CRYPTO_EddsaPublicKey);  n = GNUNET_new (struct Node);  n->id = *peer;  n->timeout_task = GNUNET_SCHEDULER_add_delayed (EXP_RESPONSE_TIMEOUT, &remove_request, n);  n->capabilities = NONE;  e_ctx = GNUNET_new (struct NodeComCtx);  e_ctx->n = n;  e_ctx->e = NULL;  e_ctx->size = size;  e_ctx->notify = &send_experimentation_request_cb;  e_ctx->notify_cls = n;  GNUNET_CONTAINER_DLL_insert_tail(n->e_req_head, n->e_req_tail, e_ctx);  schedule_transmisson (e_ctx);  GNUNET_assert (GNUNET_OK ==		 GNUNET_CONTAINER_multipeermap_put (nodes_requested,						    peer, n,						    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));  update_stats (nodes_requested);}

int psi_show(struct seq_file *m, struct psi_group *group, enum psi_res res){	int full;	if (static_branch_likely(&psi_disabled))		return -EOPNOTSUPP;	update_stats(group);	for (full = 0; full < 2 - (res == PSI_CPU); full++) {		unsigned long avg[3];		u64 total;		int w;		for (w = 0; w < 3; w++)			avg[w] = group->avg[res * 2 + full][w];		total = div_u64(group->total[res * 2 + full], NSEC_PER_USEC);		seq_printf(m, "%s avg10=%lu.%02lu avg60=%lu.%02lu avg300=%lu.%02lu total=%llu/n",			   full ? "full" : "some",			   LOAD_INT(avg[0]), LOAD_FRAC(avg[0]),			   LOAD_INT(avg[1]), LOAD_FRAC(avg[1]),			   LOAD_INT(avg[2]), LOAD_FRAC(avg[2]),			   total);	}	return 0;}

static void psi_update_work(struct work_struct *work){	struct delayed_work *dwork;	struct psi_group *group;	bool nonidle;	dwork = to_delayed_work(work);	group = container_of(dwork, struct psi_group, clock_work);	/*	 * If there is task activity, periodically fold the per-cpu	 * times and feed samples into the running averages. If things	 * are idle and there is no data to process, stop the clock.	 * Once restarted, we'll catch up the running averages in one	 * go - see calc_avgs() and missed_periods.	 */	nonidle = update_stats(group);	if (nonidle) {		unsigned long delay = 0;		u64 now;		now = sched_clock();		if (group->next_update > now)			delay = nsecs_to_jiffies(group->next_update - now) + 1;		schedule_delayed_work(dwork, delay);	}}

static void send_scheduler_task (enum phase_e phase, size_t wid){    size_t tid = user.scheduler_f (phase, wid);    if (tid == NONE)    {	return;    }    enum task_type_e task_type = get_task_type (phase, tid, wid);    size_t	     sid = NONE;    if (task_type == LOCAL || task_type == LOCAL_SPEC)    {	sid = wid;    }    else if (task_type == REMOTE || task_type == REMOTE_SPEC)    {	sid = find_random_chunk_owner (tid);    }    XBT_INFO ("%s %zu assigned to %s %s", (phase==MAP?"map":"reduce"), tid,	    MSG_host_get_name (config.workers[wid]),	    task_type_string (task_type));    send_task (phase, tid, sid, wid);    update_stats (task_type);}

void fs_emu_audio_video_sync(int time_ms) {    for (int i = 0; i < MAX_STREAMS; i++) {        if (g_streams[i]) {            unqueue_old_buffers(i);            update_stats(i, time_ms);            pid_controller_step(i, time_ms);        }    }}

void		load_game(void){  update_background();  update_content();  collisions();  update_stats();  display_content();  draw();}

/** * Remove experimentation request due to timeout * * @param cls the related node * @param tc scheduler's task context */static voidremove_request (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc){  struct Node *n = cls;  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,	      "Removing request for peer %s due to timeout/n",	      GNUNET_i2s (&n->id));  if (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains (nodes_requested, &n->id))  {    GNUNET_break (0 == GNUNET_CONTAINER_multipeermap_remove (nodes_requested, &n->id, n));    update_stats (nodes_requested);    GNUNET_CONTAINER_multipeermap_put (nodes_inactive, &n->id, n,				       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);    update_stats (nodes_inactive);  }  n->timeout_task = GNUNET_SCHEDULER_NO_TASK;}

static void *run(void *data){	(void)data; /* unused parameter. silence warning. */	init_nl();	raw_sample_buf_init();	init_realtime();	set_sample_period(SAMPLE_PERIOD_US);	struct timespec deadline;	clock_gettime(CLOCK_MONOTONIC, &deadline);	int sample_no = 0;	char *iface = strdup(g_iface);	struct iface_stats *stats_frame = raw_sample_buf_produce_next();	snprintf(stats_frame->iface, MAX_IFACE_LEN, "%s", iface);	stats_frame->sample_period_us = sample_period_us;	for (;;) {		update_stats(&(stats_frame->samples[sample_no]), iface,		             deadline);		sample_no++;		sample_no %= SAMPLES_PER_FRAME;		/* set the iface, samples per period at start of each frame*/		if (sample_no == 0) {			pthread_mutex_lock(&g_iface_mutex);			free(iface);			iface = strdup(g_iface);			stats_frame = raw_sample_buf_produce_next();			snprintf(stats_frame->iface, MAX_IFACE_LEN, "%s",			         iface);			pthread_mutex_unlock(&g_iface_mutex);			stats_frame->sample_period_us = sample_period_us;			stats_handler(raw_sample_buf_consume_next());		}		deadline.tv_nsec += 1000 * sample_period_us;		/* Normalize the time to account for the second boundary */		if (deadline.tv_nsec >= 1000000000) {			deadline.tv_nsec -= 1000000000;			deadline.tv_sec++;		}		clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &deadline,		                NULL);	}	return NULL;}

NEURON_OUTPUT UpdateStats(PARAM_LIST *pParamList){	NEURON_OUTPUT output;	update_stats(g_number, g_label, g_certainty, g_activation, NL_WIDTH * NL_HEIGHT, g_result);	g_translate_x = 0;	g_translate_y = 0;	output.fval = g_certainty;	return (output);}

void DexesStructure::add_class_no_checks(const MethodRefs& clazz_mrefs,                                         const FieldRefs& clazz_frefs,                                         const TypeRefs& clazz_trefs,                                         DexClass* clazz) {  always_assert_log(m_classes.count(clazz) == 0,                    "Can't emit the same class twice: %s!/n", SHOW(clazz));  auto laclazz = estimate_linear_alloc(clazz);  m_current_dex.add_class_no_checks(clazz_mrefs, clazz_frefs, clazz_trefs,                                    laclazz, clazz);  m_classes.emplace(clazz);  update_stats(clazz_mrefs, clazz_frefs, clazz);}

static struct net_device_stats *el3_get_stats(struct net_device *dev){    struct el3_private *lp = netdev_priv(dev);    unsigned long flags;    struct pcmcia_device *link = lp->p_dev;    if (pcmcia_dev_present(link)) {	spin_lock_irqsave(&lp->lock, flags);	update_stats(dev);	spin_unlock_irqrestore(&lp->lock, flags);    }    return &dev->stats;}

/** * Stop the nodes management */voidGED_nodes_stop (){  if (NULL != ch)  {  		GNUNET_CORE_disconnect (ch);  		ch = NULL;  }  if (NULL != nodes_requested)  {  		GNUNET_CONTAINER_multipeermap_iterate (nodes_requested,  																					 &cleanup_node,  																					 nodes_requested);  		update_stats (nodes_requested);  		GNUNET_CONTAINER_multipeermap_destroy (nodes_requested);  		nodes_requested = NULL;  }  if (NULL != nodes_active)  {  		GNUNET_CONTAINER_multipeermap_iterate (nodes_active,  																					 &cleanup_node,  																					 nodes_active);  		update_stats (nodes_active);  		GNUNET_CONTAINER_multipeermap_destroy (nodes_active);  		nodes_active = NULL;  }  if (NULL != nodes_inactive)  {  		GNUNET_CONTAINER_multipeermap_iterate (nodes_inactive,  																					 &cleanup_node,  																					 nodes_inactive);  		update_stats (nodes_inactive);  		GNUNET_CONTAINER_multipeermap_destroy (nodes_inactive);  		nodes_inactive = NULL;  }}

NEURON_OUTPUT UpdateStats(PARAM_LIST *pParamList){	NEURON_OUTPUT output;		update_stats(g_number, g_label, g_certainty, g_activation, (&char_discr_out)->ww * (&char_discr_out)->wh, g_result);			g_translate_x = 0;	g_translate_y = 0;	output.fval = g_certainty;	return (output);}

/*	Note: User u must be locked*/int recv_XMsg(User *u, XMsg *x) {PList *pl;	if ((pl = new_PList(x)) == NULL)		return -1;	x->refcount++;	append_PList(&(u->recv_xmsgs), pl);	switch(x->type) {		case XMSG_X:			u->xrecv++;			user_dirty(u, "xrecv");			update_stats(u);			inc_stats(STATS_XRECV);			break;		case XMSG_EMOTE:			u->erecv++;			user_dirty(u, "erecv");			update_stats(u);			inc_stats(STATS_ERECV);			break;		case XMSG_FEELING:			u->frecv++;			user_dirty(u, "frecv");			update_stats(u);			inc_stats(STATS_FRECV);			break;		default:			;	}	wakeup(u);	return 0;}

static struct net_device_stats *el3_get_stats(struct net_device *dev){    struct el3_private *lp = (struct el3_private *)dev->priv;    unsigned long flags;    dev_link_t *link = &lp->link;    if (DEV_OK(link)) {	save_flags(flags);	cli();	update_stats(dev);	restore_flags(flags);    }    return &lp->stats;}

int main(){	int studentRec=0;	int courseRec=0;	int numberOfResults =0;	int menuSelector=0;	int programExiter = 0;	struct student studData[50];	struct course corsMat[50];	struct exam examResult[50];	struct stats examStats[50];	printf("%s/n","This program will be used to record information regarding students , Courses and exams./n");	/*This is the option menu which runs the program*/	while(!programExiter){		printf("%s/n","Please use the following menu to run the program/n1) Add student records/n2) Add courses Information/n3) Input exam results/n4) Calculate course statistics/n5) Remove results if higher grades available/n6) Show Student information/n7) Show Course information/n8) Show statistics/n9) Exit the program");		scanf("%d",&menuSelector);		switch(menuSelector){			/*This adds data stored about students*/			case 1: input_student_info(studData, &studentRec);				break;			/*This adds data stored about courses*/			case 2: input_course_info(corsMat, &courseRec);				break;			/*This is used input information regarding */			case 3: input_exam_info(examResult, &numberOfResults, corsMat, &courseRec,studData, &studentRec);				break;			case 4: update_stats(examStats,corsMat, &courseRec,examResult, &numberOfResults);				break;			case 5: 				break;			/*This prints the stored records to the consol*/			case 6: printStudentInformation(studData, &studentRec);				break;			/*This Prints all the data stored in exams*/			case 7:	printCorsInformation(corsMat, &courseRec);				break;			case 8: printStatInformation(examStats, &courseRec);				break;			case 9: programExiter = 1;				break;			default: 				break;		}			}		return 0;}

longigb_net_ioctl(struct file *filp,	 unsigned int cmd, unsigned long arg){	int ret = 0;	switch (cmd) {	case SEND_STATS:		ret = update_stats((struct stats_struct __user *) arg);		break;	default:		ret = -ENOTTY;	}	return ret;}

/* Hash test: buffer of size byte. Run test n times. */static void run_test(size_t size, unsigned int n, unsigned int l){	uint64_t t;	struct statistics stats;	TEEC_Operation op;	int n0 = n;	alloc_shm(size, algo);	if (!random_in)		memset((uint8_t *)in_shm.buffer + offset, 0, size);	memset(&op, 0, sizeof(op));	op.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_PARTIAL_INPUT,					 TEEC_MEMREF_PARTIAL_OUTPUT,					 TEEC_VALUE_INPUT, TEEC_NONE);	op.params[0].memref.parent = &in_shm;	op.params[0].memref.offset = 0;	op.params[0].memref.size = size + offset;	op.params[1].memref.parent = &out_shm;	op.params[1].memref.offset = 0;	op.params[1].memref.size = hash_size(algo);	op.params[2].value.a = l;	op.params[2].value.b = offset;	verbose("Starting test: %s, size=%zu bytes, ",		algo_str(algo), size);	verbose("random=%s, ", yesno(random_in));	verbose("unaligned=%s, ", yesno(offset));	verbose("inner loops=%u, loops=%u, warm-up=%u s/n", l, n, warmup);	if (warmup)		do_warmup();	memset(&stats, 0, sizeof(stats));	while (n-- > 0) {		t = run_test_once((uint8_t *)in_shm.buffer + offset, size, &op, l);		update_stats(&stats, t);		if (n % (n0/10) == 0)			vverbose("#");	}	vverbose("/n");	printf("min=%gμs max=%gμs mean=%gμs stddev=%gμs (%gMiB/s)/n",	       stats.min/1000, stats.max/1000, stats.m/1000,	       stddev(&stats)/1000, mb_per_sec(size, stats.m));	free_shm();}

/** * Set a specific node as active * * @param n the node */static voidnode_make_active (struct Node *n){  int c1;  GNUNET_CONTAINER_multipeermap_put (nodes_active,				     &n->id, n, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);  update_stats (nodes_active);  GNUNET_log (GNUNET_ERROR_TYPE_INFO,	      _("Added peer `%s' as active node/n"),	      GNUNET_i2s (&n->id));  /* Request experiments for this node to start them */  for (c1 = 0; c1 < n->issuer_count; c1++)  {    GED_experiments_get (n, &n->issuer_id[c1], &get_experiments_cb);  }}

void dnet_monitor_stats_update(struct dnet_node *n, const struct dnet_cmd *cmd,                               const int err, const int cache,                               const uint32_t size, const unsigned long time) {	try {		auto real_monitor = ioremap::monitor::get_monitor(n);		if (real_monitor) {			real_monitor->get_statistics().command_counter(cmd->cmd, cmd->trans, err,								       cache, size, time);			auto top_stats = real_monitor->get_statistics().get_top_stats();			if (top_stats) {				top_stats->update_stats(cmd, size);			}		}	} catch (const std::exception &e) {		dnet_log(n, DNET_LOG_DEBUG, "monitor: failed to update stats: %s", e.what());	}}

void reveal_coordinate(int x, int y) {/* Als een cel een mijn bevat, dan is de speler dood*/if (get_cell(x, y)->is_mine == 1 ){    printf("/+/+/+/ MINE EXPLODED /+/+/+/ /n");    printf("/n");    dead = 1;    print_grid();    printf("Spel wordt afgesloten.../n");    draw_grid();    update_stats();    show_stats();    sleep(2);    deallocate_grid(WIDTH, HEIGHT);    exit(0);}/* Als de cel geen mijn is, verander dan zijn staat van covered naar uncovered. */else {    // Zet de status van het vakje op UNCOVERED.    get_cell(x, y)->state = UNCOVERED;  // Test of het vakje geen naburige mijnen heeft.  if (get_cell(x, y)->neighbouring_mines == 0)  {    // Als het 0 naburige vakjes heeft, moeten al zijn buren bekeken worden of zij een mijn in de buurt hebben.    for (int i = -1; i < 2; i++) // Begin bij de cel aan de linkse kant (vandaar de -1).      {        for (int j = -1; j < 2; j++) // Begin bij de cel aan de rechtse kant.        {          if ((x + i) < WIDTH && (x + i)  >= 0 && (y + j) < HEIGHT && (y + j) >= 0) // Controle of een buurcel van de mijn zich niet buiten de randen van het veld bevindt.          {            if (get_cell(x + i, y + j)->state == COVERED)            {          reveal_coordinate(x + i, y + j); // Recursieve oproep op de naburige cellen.            }          }        }      }    }  }}

void stateDRR::handle_departure(int pkt, int src){    update_stats(src);#ifdef DEBUG    fprintf(stdout, "[%ld] Dequeue/t %d/ts %d/tp %d/t sz %ld/tserv %ld/tdef %d/n", this->clock,            this->flows[src].front()->type, this->flows[src].front()->sourceId,            this->flows[src].front()->packetId, this->flows[src].size(),             this->globalStats.totalPackets, this->deficit[src]);#endif    this->flows[src].pop();    this->eventQueue.pop();#ifdef DEBUG    if(this->flows[src].size() > 0) {    cout<<this->clock<<" /t D /t pkt "<<pkt<<" /tsrc "<<src<<endl;    }#endif        if(this->currentPackets >= 1) {        /* When there are multiple packets,must schedule next departure          * to follow work-preserving model.         * Next departure must be from the next immediate active flow.          * When number of flows are small, we can quickly iterate over instead of storing separate list*/        while(1) {            /* loop over until next departure scheduled*/            src = (src+1)%(NUM_SOURCES);            while(flows[src].size() == 0) {#ifdef DEBUG                 cout<<"[Dequeue]/tEmpty "<<src<<" def"<<this->deficit[src]<<endl;#endif                src = (src+1)%(NUM_SOURCES);            }            /* increment deficit for each active  flow _before_ scheduling */            this->deficit[src] += QUANTUM;            /* check for deficit of the active flow */            if(this->deficit[src] >= this->flows[src].front()->packetSize) {                schedule_event(PKT_DEPART, this->flows[src].front()->packetId, src);                this->deficit[src] -=  this->flows[src].front()->packetSize;                break;            }#ifdef DEBUG            cout<<"[Dequeue]/tSkipped: "<<src<<" def: "<<this->deficit[src]<<" pkt ";            cout<<this->flows[src].front()->packetSize<<endl;#endif        }    }}