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

voidsys_timer_set( SysTimer  timer, SysTime  when, SysCallback   _callback, void*  opaque ){    QEMUTimerCB*  callback = (QEMUTimerCB*)_callback;    if (callback == NULL) {  /* unsetting the timer */        if (timer->timer) {            timer_del( timer->timer );            timer_free( timer->timer );            timer->timer = NULL;        }        timer->callback = callback;        timer->opaque   = NULL;        return;    }    if ( timer->timer ) {         if ( timer->callback == callback && timer->opaque == opaque )            goto ReuseTimer;         /* need to replace the timer */         timer_free( timer->timer );    }    timer->timer    = timer_new(QEMU_CLOCK_REALTIME, SCALE_MS, callback, opaque );    timer->callback = callback;    timer->opaque   = opaque;ReuseTimer:    timer_mod( timer->timer, when );}

intmain(int argc, char *argv[]){    pclu_context *pclu = pclu_create_context();    printf("/n%s/n", pclu_context_info(pclu));    matrix *aa = create_random_matrix(SIZE, SIZE);    matrix *bb = create_identity_matrix(SIZE, SIZE);#if PRINT_DATA    printf("Matrix aa:/n");    print_matrix(aa);    printf("/n");    printf("Matrix bb:/n");    print_matrix(bb);    printf("/n");#endif    timer* tt1 = timer_alloc();    matrix *cc = create_matrix(SIZE, SIZE);    matrix_multiply_cl(pclu, cc, aa, bb);        double tm1 = timer_read(tt1);    timer_free(tt1);        printf("Matrix_multiply_cl took %.04f seconds./n", tm1);#if PRINT_DATA    printf("Matrix cc:/n");    print_matrix(cc);    printf("/n");#endif    timer* tt = timer_alloc();    check_result(aa, cc);        double ct = timer_read(tt);    timer_free(tt);        printf("Check result took %.04f seconds./n", ct);    destroy_matrix(aa);    destroy_matrix(bb);    pclu_destroy_context(pclu);    return 0;}

voidconn_remove(const Conn_t *connection){  Conn_t *tmp, *prev;  assert(connection != NULL);  prev = NULL;  tmp = connlist;  while(tmp) {    if (tmp == connection) {      if (prev != NULL) {	prev->next = tmp->next;      } else {	connlist = tmp->next;      }      if (connection->fd) {	close(connection->fd);	event_remove_fd(connection->fd);      }      if (connection->sfd) {	event_remove_fd(connection->sfd);	close(connection->sfd);      }      timer_free(&conn_unit, tmp->timer);      mem_free(&conn_unit, tmp);      return;    }    prev = tmp;    tmp = tmp->next;  }}

static void ipmi_bmc_extern_finalize(Object *obj){    IPMIBmcExtern *ibe = IPMI_BMC_EXTERN(obj);    timer_del(ibe->extern_timer);    timer_free(ibe->extern_timer);}

static void bdrv_qed_detach_aio_context(BlockDriverState *bs){    BDRVQEDState *s = bs->opaque;    qed_cancel_need_check_timer(s);    timer_free(s->need_check_timer);}

/* Enable a timer */static timer_id timer_enable(timer_entry_t *timer){   /* Allocate a new ID */   TIMER_LOCK();   timer->id = timer_alloc_id();   /* Insert ID in hash table */   if (hash_table_insert(timer_id_hash,&timer->id,timer) == -1) {      TIMER_UNLOCK();      free(timer);      return(0);   }   /* Schedule event */   if (timer_schedule(timer) == -1) {      timer_free(timer,FALSE);      timer = NULL;      TIMER_UNLOCK();      return(0);   }   /* Returns timer ID */   TIMER_UNLOCK();         pthread_cond_signal(&timer->queue->schedule);   return(timer->id);}

static voidfifo_output_close(void *data){	struct fifo_data *fd = (struct fifo_data *)data;	timer_free(fd->timer);}

static void_hwSensorClient_free( HwSensorClient*  cl ){    /* remove from sensors's list */    if (cl->sensors) {        HwSensorClient**  pnode = &cl->sensors->clients;        for (;;) {            HwSensorClient*  node = *pnode;            if (node == NULL)                break;            if (node == cl) {                *pnode = cl->next;                break;            }            pnode = &node->next;        }        cl->next    = NULL;        cl->sensors = NULL;    }    /* close QEMUD client, if any */    if (cl->client) {        qemud_client_close(cl->client);        cl->client = NULL;    }    /* remove timer, if any */    if (cl->timer) {        timer_del(cl->timer);        timer_free(cl->timer);        cl->timer = NULL;    }    AFREE(cl);}

int timer_release(FAR struct posix_timer_s *timer){  /* Some sanity checks */  if (!timer)    {      return -EINVAL;    }  /* Release one reference to timer.  Don't delete the timer until the count   * would decrement to zero.   */  if (timer->pt_crefs > 1)    {      timer->pt_crefs--;      return 1;    }  /* Free the underlying watchdog instance (the timer will be canceled by the   * watchdog logic before it is actually deleted)   */  (void)wd_delete(timer->pt_wdog);  /* Release the timer structure */  timer_free(timer);  return OK;}

/* * Configure PORT_1A as data with PORT_1B as the valid signal. Ensure that the * receiver is ready using a channel end. Send a word of data, delay for a while * and send another word to ensure the valid signals are functioning. */void port_test_output(chanend c){  port p = port_enable(XS1_PORT_1A);  port_set_buffered(p);  port_set_transfer_width(p, 32);  port p_ready = port_enable(XS1_PORT_1B);  clock clk = clock_enable(XS1_CLKBLK_1);  clock_start(clk);  port_configure_out_strobed_master(p, p_ready, clk, 0);  chan_input_word(c); // Wait for ack  port_output(p, 0xfeedbeef);  timer tmr = timer_alloc();  timer_delay(tmr, 1000);  timer_free(tmr);  port_output(p, 0x12345678);  chan_input_word(c); // Wait for ack  port_disable(p);  port_disable(p_ready);  clock_disable(clk);  // Get information about the tile/core running the server for debug messages  unsigned tile_id = get_local_tile_id();  unsigned core_id = get_logical_core_id();  debug_printf("%x:%d: output done/n", tile_id, core_id);}

static void wdt_diag288_unrealize(DeviceState *dev, Error **errp){    DIAG288State *diag288 = DIAG288(dev);    timer_del(diag288->timer);    timer_free(diag288->timer);}

int main (int argc, char *argv[])  {  timer *t = timer_alloc();  recorder *parent_rec = recorder_alloc("parent.csv");  recorder *child_rec = recorder_alloc("child.csv");  pid_t pid;  int status, i;  for (i = 0; i < N; i++) {    start_timer(t);    pid = fork();    if (pid == -1) {      // erreur à l'exécution de fork      perror("fork");      return EXIT_FAILURE;    }    // pas d'erreur    // BEGIN    if (pid == 0) {      // processus fils      write_record(child_rec, i, stop_timer(t));      recorder_free(child_rec);      recorder_free(parent_rec);      timer_free(t);      return EXIT_SUCCESS;    }    else {      // processus père      write_record(parent_rec, i, stop_timer(t));      pid = waitpid(pid, &status, 0);      if (pid == -1) {        perror("wait");        return EXIT_FAILURE;      }    }    // END  }  recorder_free(child_rec);  recorder_free(parent_rec);  timer_free(t);  return EXIT_SUCCESS;}

static void nic_cleanup(NetClientState *ncs){#if 0    tnetw1130_t *s = qemu_get_nic_opaque(ncs);    timer_del(d->poll_timer);    timer_free(d->poll_timer);#endif}

/* destroy a timer */static void throttle_timer_destroy(QEMUTimer **timer){    assert(*timer != NULL);    timer_del(*timer);    timer_free(*timer);    *timer = NULL;}

static void colo_compare_timer_del(CompareState *s){    if (s->packet_check_timer) {        timer_del(s->packet_check_timer);        timer_free(s->packet_check_timer);        s->packet_check_timer = NULL;    } }

static void hid_del_idle_timer(HIDState *hs){    if (hs->idle_timer) {        timer_del(hs->idle_timer);        timer_free(hs->idle_timer);        hs->idle_timer = NULL;    }}

static voidthrottlePipe_close( void* opaque ){    ThrottlePipe* pipe = opaque;    timer_del(pipe->timer);    timer_free(pipe->timer);    pingPongPipe_close(&pipe->pingpong);}

void icmp6_cleanup(Slirp *slirp){    if (!slirp->in6_enabled) {        return;    }    timer_del(slirp->ra_timer);    timer_free(slirp->ra_timer);}

void end_resource_tracking(void){	/* call everyone who tracks resources to let them know */	auto_free();	timer_free();	/* decrement the tag counter */	resource_tracking_tag--;}

static void balloon_stats_destroy_timer(VirtIOBalloon *s){    if (balloon_stats_enabled(s)) {        timer_del(s->stats_timer);        timer_free(s->stats_timer);        s->stats_timer = NULL;        s->stats_poll_interval = 0;    }}

static void virtio_rng_device_unrealize(DeviceState *dev, Error **errp){    VirtIODevice *vdev = VIRTIO_DEVICE(dev);    VirtIORNG *vrng = VIRTIO_RNG(dev);    timer_del(vrng->rate_limit_timer);    timer_free(vrng->rate_limit_timer);    unregister_savevm(dev, "virtio-rng", vrng);    virtio_cleanup(vdev);}

static void vhost_vsock_post_load_timer_cleanup(VHostVSock *vsock){    if (!vsock->post_load_timer) {        return;    }    timer_del(vsock->post_load_timer);    timer_free(vsock->post_load_timer);    vsock->post_load_timer = NULL;}

static void baum_close(struct CharDriverState *chr){    BaumDriverState *baum = chr->opaque;    timer_free(baum->cellCount_timer);    if (baum->brlapi) {        brlapi__closeConnection(baum->brlapi);        g_free(baum->brlapi);    }    g_free(baum);}

static voidsys_timer_free( SysTimer  timer ){    if (timer->timer) {        timer_del( timer->timer );        timer_free( timer->timer );        timer->timer = NULL;    }    timer->next    = _s_free_timers;    _s_free_timers = timer;}

void destroy_dst_blacklist(){	int r;	struct dst_blst_entry** crt;	struct dst_blst_entry* e;	if (blst_timer_h){		timer_del(blst_timer_h);		timer_free(blst_timer_h);		blst_timer_h=0;	}#ifdef BLST_LOCK_PER_BUCKET	if (dst_blst_hash)		for(r=0; r<DST_BLST_HASH_SIZE; r++)			lock_destroy(&dst_blst_hash[r].lock);#elif defined BLST_LOCK_SET		if (blst_lock_set){			lock_set_destroy(blst_lock_set);			lock_set_dealloc(blst_lock_set);			blst_lock_set=0;		}#else	if (blst_lock){		lock_destroy(blst_lock);		lock_dealloc(blst_lock);		blst_lock=0;	}#endif	if (dst_blst_hash){		for(r=0; r<DST_BLST_HASH_SIZE; r++){			crt=&dst_blst_hash[r].first;			while(*crt){				e=*crt;				*crt=(*crt)->next;				blst_destroy_entry(e);			}		}		shm_free(dst_blst_hash);		dst_blst_hash=0;	}	if (blst_mem_used){		shm_free((void*)blst_mem_used);		blst_mem_used=0;	}#ifdef DST_BLACKLIST_HOOKS	destroy_blacklist_hooks();#endif#ifdef USE_DST_BLACKLIST_STATS	if (dst_blacklist_stats)		shm_free(dst_blacklist_stats);#endif}

voidtimer_close(timer_t *t){	if (t == NULL) return;	if (t->t_src != NULL) dispatch_source_cancel(t->t_src);	/*	 * We need to make sure that the source's event handler isn't currently running	 * before we free the timer.  We let the source's queue do the actual free.	 */	dispatch_async(t->t_queue, ^{ timer_free(t); });

static voidopenal_close(void *data){	struct openal_data *od = data;	timer_free(od->timer);	alcMakeContextCurrent(od->context);	alDeleteSources(1, &od->source);	alDeleteBuffers(NUM_BUFFERS, od->buffers);	alcDestroyContext(od->context);	alcCloseDevice(od->device);}

void timer_cancelall(FIFO* fifo) {  int e = io_load_eflags();  io_cli();  for (int i = 0; i < MAX_TIMER; ++i) {    TIMER* t = &timerctl.timers0[i];    if (t->flags != 0 && t->flags2 != 0 && t->fifo == fifo) {      timer_cancel(t);      timer_free(t);    }  }  io_store_eflags(e);}

w_err_t wind_timer_destroy(w_timer_s* timer){    w_err_t err;    WIND_ASSERT_RETURN(timer != W_NULL,W_ERR_PTR_NULL);    WIND_ASSERT_RETURN(timer->obj.magic == WIND_TIMER_MAGIC,W_ERR_INVALID);        wind_notice("destroy timer:%s",timer->obj.name != W_NULL?timer->obj.name:"null");    err = wind_obj_deinit(&timer->obj,WIND_TIMER_MAGIC,&timerlist);    WIND_ASSERT_RETURN(err == W_ERR_OK,W_ERR_FAIL);    if(IS_F_TIMER_POOL(timer))        timer_free(timer);    return W_ERR_OK;}

static void destroy_mod(void) {	struct timer_action* a;	DEBUG(MODULE_NAME": destroy: destroying, pid=%d/n", getpid());	while (timer_actions) {		a = timer_actions;		if (a->link) {			timer_del(a->link);			timer_free(a->link);		}		timer_actions = a->next;		shm_free(a);	}}