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

int main(int argc, char* argv[]) {	LibRzuScopedUse useLibRzu;	init();	ConfigInfo::get()->init(argc, argv);	uint64_t startTime = 0;	Log mainLogger(GlobalCoreConfig::get()->log.enable,	               GlobalCoreConfig::get()->log.level,	               GlobalCoreConfig::get()->log.consoleLevel,	               GlobalCoreConfig::get()->log.dir,	               GlobalCoreConfig::get()->log.file,	               GlobalCoreConfig::get()->log.maxQueueSize);	Log::setDefaultLogger(&mainLogger);	ConfigInfo::get()->dump();	int usecBetweenConnection = CFG_GET("usecperconnection")->getInt();	benchConnections = CFG_GET("benchconnection")->getBool();	config.connectionsDone = config.connectionsStarted = 0;	config.connectionTargetCount = CFG_GET("targetcount")->getInt();	if(benchConnections)		benchmarkConnections();	else		benchmarkAuthentication();	mainLogger.log(Object::LL_Info, "main", 4, "Starting benchmark/n");	if(usecBetweenConnection == 0)		startTime = uv_hrtime();	if(benchConnections)		startBenchConnections(usecBetweenConnection);	else		startBenchAuth(usecBetweenConnection);	if(usecBetweenConnection != 0) {		mainLogger.log(		    Object::LL_Info,		    "main",		    4,		    "Connected %d connections at limited speed, continuing benchmark at full-speed (time counter begin now)/n",		    config.connectionsStarted);		startTime = uv_hrtime();	}	EventLoop::getInstance()->run(UV_RUN_DEFAULT);	uint64_t duration = (uv_hrtime() - startTime) / 1000;  // nanosec to usec	mainLogger.log(Object::LL_Info,	               "main",	               4,	               "%d connections in %" PRIu64 " usec => %f auth/sec/n",	               config.connectionsDone,	               duration,	               config.connectionsDone / ((float) duration / 1000000.0f));}

static void async_bench(const char* path) {  struct async_req reqs[MAX_CONCURRENT_REQS];  struct async_req* req;  uint64_t before;  uint64_t after;  int count;  int i;  for (i = 1; i <= MAX_CONCURRENT_REQS; i++) {    count = NUM_ASYNC_REQS;    for (req = reqs; req < reqs + i; req++) {      req->path = path;      req->count = &count;      uv_fs_stat(uv_default_loop(), &req->fs_req, req->path, stat_cb);    }    before = uv_hrtime();    uv_run(uv_default_loop());    after = uv_hrtime();    printf("%s stats (%d concurrent): %.2fs (%s/s)/n",           fmt(1.0 * NUM_ASYNC_REQS),           i,           (after - before) / 1e9,           fmt((1.0 * NUM_ASYNC_REQS) / ((after - before) / 1e9)));    fflush(stdout);  }}

/// Sleeps for `us` microseconds.////// @param us          Number of microseconds to sleep./// @param ignoreinput If true, ignore all input (including SIGINT/CTRL-C).///                    If false, waiting is aborted on any input.void os_microdelay(uint64_t us, bool ignoreinput){  uint64_t elapsed = 0u;  uint64_t base = uv_hrtime();  // Convert microseconds to nanoseconds, or UINT64_MAX on overflow.  const uint64_t ns = (us < UINT64_MAX / 1000u) ? us * 1000u : UINT64_MAX;  uv_mutex_lock(&delay_mutex);  while (elapsed < ns) {    // If ignoring input, we simply wait the full delay.    // Else we check for input in ~100ms intervals.    const uint64_t ns_delta = ignoreinput                              ? ns - elapsed                              : MIN(ns - elapsed, 100000000u);  // 100ms    const int rv = uv_cond_timedwait(&delay_cond, &delay_mutex, ns_delta);    if (0 != rv && UV_ETIMEDOUT != rv) {      assert(false);      break;    }  // Else: Timeout proceeded normally.    if (!ignoreinput && os_char_avail()) {      break;    }    const uint64_t now = uv_hrtime();    elapsed += now - base;    base = now;  }  uv_mutex_unlock(&delay_mutex);}

void SessionServerCommon::onCheckIdleSockets() {	int kickedConnections = 0;	uint64_t begin;	bool logTrace = Log::get() && Log::get()->wouldLog(LL_Trace);	if(logTrace)		begin = uv_hrtime();	for(auto it = sockets.begin(); it != sockets.end();) {		SocketSession* session = it->first;		Stream* socket = session->getStream();		++it;  // if the socket is removed from the list (when closed), we keep a valid iterator		if(socket && socket->getState() == Stream::ConnectedState) {			if(socket->isPacketTransferedSinceLastCheck() == false) {				StreamAddress remoteAddress = socket->getRemoteAddress();				char ipStr[108];				remoteAddress.getName(ipStr, sizeof(ipStr));				socket->close();				kickedConnections++;				log(LL_Info, "Kicked idle connection: %s:%d/n", ipStr, remoteAddress.port);			} else {				socket->resetPacketTransferedFlag();			}		}	}	// check fo trace to avoid call to uv_hrtime if not needed	if(logTrace)		log(LL_Trace,		    "Idle socket check: kicked %d sockets in %" PRIu64 " ns/n",		    kickedConnections,		    uv_hrtime() - begin);}

int ftw_socket_inbox_shutdown(struct ftw_socket_inbox ** const sock){    uint64_t time;    double elapsed_time;    int rc;    /*  Preconditions expected of LabVIEW. */    ftw_assert(sock);    if (*sock == NULL) {        errno = EBADF;        return -1;    }    time = uv_hrtime();    rc = nn_close((*sock)->id);    nn_sem_post(&(*sock)->deinitialized);    nn_thread_term(&(*sock)->async_recv_thread);    nn_sem_term(&(*sock)->msg_acknowledged);    nn_sem_term(&(*sock)->initialized);    nn_sem_term(&(*sock)->deinitialized);    time = uv_hrtime() - time;    elapsed_time = time / 1000000000.0;    ftw_debug("Inbox Shutdown time: %.3fsec", elapsed_time);    return rc;}

bool event_poll(int32_t ms){  int64_t remaining = ms;  uint64_t end;  bool result;  if (ms > 0) {    // Calculate end time in nanoseconds    end = uv_hrtime() + ms * 1e6;  }  for (;;) {    result = poll_uv_loop((int32_t)remaining);    // Process queued events    process_all_events();    if (ms > 0) {      // Calculate remaining time in milliseconds      remaining = (end - uv_hrtime()) / 1e6;     }    if (input_ready() || got_int) {      // Bail out if we have pending input      return true;    }    if (!result || (ms >= 0 && remaining <= 0)) {      // Or if we timed out        return false;    }  }}

// we expect the AVPacket.data to contain either interleaved S16, or  interleaved F32 audiobool AudioEncoderMP3::encodePacket(AVPacket* p, FLVTag& tag) {  assert(lame_flags);  assert(settings.in_interleaved); /* we only support interleaved audio for now */   int nsamples = 0;  int written = 0;#if defined(USE_GRAPH)  uint64_t enc_start = uv_hrtime() / 1000000;#endif  if(settings.in_bitsize == AV_AUDIO_BITSIZE_S16) {    nsamples = p->data.size() / (sizeof(int16_t) * nchannels);    //printf("----------------- samples: %d, channels: %d, data.size(): %zu/n", nsamples, nchannels, p->data.size());    written = lame_encode_buffer_interleaved(lame_flags, (short int*)&p->data.front(), nsamples, mp3_buffer, AUDIO_ENCODER_BUFFER_SIZE);  }  else if(settings.in_bitsize == AV_AUDIO_BITSIZE_F32) {    nsamples = p->data.size() / (sizeof(float) * nchannels);    written = lame_encode_buffer_interleaved_ieee_float(lame_flags, (const float*)&p->data.front(), nsamples, mp3_buffer, AUDIO_ENCODER_BUFFER_SIZE);  }  if(written > 0) {    bitrate_nbytes += written;  }  uint64_t time_now = uv_hrtime();  if(time_now >= bitrate_timeout) {    bitrate_timeout = time_now + bitrate_delay;    double duration = (time_now - bitrate_time_started) / 1000000000.0; // in s.    bitrate_in_kbps = ((bitrate_nbytes * 8) / 1000) / duration;    STREAMER_STATUS("audio bitrate: %0.2f kbps/n", bitrate_in_kbps);  }#if defined(USE_GRAPH)  frames_graph["enc_audio"] += ((uv_hrtime()/1000000) - enc_start);  frames_graph["enc_audio_video"] += ((uv_hrtime()/1000000) - enc_start);  network_graph["mp3"] += written;#endif#if AUDIO_USE_DATA_PTR  if(written) {    tag.setData(mp3_buffer, written);  }#elif AUDIO_USE_COPY_DATA  tag.bs.clear();  if(written) {    tag.bs.putBytes((uint8_t*)mp3_buffer, written);    tag.setData(tag.bs.getPtr(), tag.bs.size());  }#endif  tag.makeAudioTag();  tag.setTimeStamp(p->timestamp);  return written > 0;}

int ti_threadgroup_fork(ti_threadgroup_t *tg, int16_t ext_tid,                        void **bcast_val){    if (tg->tid_map[ext_tid] == 0) {        tg->envelope = bcast_val ? *bcast_val : NULL;        cpu_sfence();        tg->forked = 1;        tg->group_sense = tg->thread_sense[0]->sense;        // if it's possible that threads are sleeping, signal them        if (tg->sleep_threshold) {            uv_mutex_lock(&tg->alarm_lock);            uv_cond_broadcast(&tg->alarm);            uv_mutex_unlock(&tg->alarm_lock);        }    }    else {        // spin up to threshold ns (count sheep), then sleep        uint64_t spin_ns;        uint64_t spin_start = 0;        while (tg->group_sense !=                tg->thread_sense[tg->tid_map[ext_tid]]->sense) {            if (tg->sleep_threshold) {                if (!spin_start) {                    // Lazily initialize spin_start since uv_hrtime is expensive                    spin_start = uv_hrtime();                    continue;                }                spin_ns = uv_hrtime() - spin_start;                // In case uv_hrtime is not monotonic, we'll sleep earlier                if (spin_ns >= tg->sleep_threshold) {                    uv_mutex_lock(&tg->alarm_lock);                    if (tg->group_sense !=                            tg->thread_sense[tg->tid_map[ext_tid]]->sense) {                        uv_cond_wait(&tg->alarm, &tg->alarm_lock);                    }                    uv_mutex_unlock(&tg->alarm_lock);                    spin_start = 0;                    continue;                }            }            cpu_pause();        }        cpu_lfence();        if (bcast_val)            *bcast_val = tg->envelope;    }    return 0;}

int rxp_clock_start(rxp_clock* clock) {  if (!clock) { return - 1; }   clock->time_start = uv_hrtime();  clock->time_last = clock->time_start;  clock->time = 0;  return 0;}

void ftw_resource_usage(double *user_cpu_time, double *system_cpu_time, double *uptime, uint64_t *hi_res_relative_time,    uint64_t *peak_working_set, uint64_t *lv_dataspace_size, uint64_t *hard_page_faults){    uv_rusage_t rusage;    double up;    MemStatRec stats;    MgErr lvrc;    int rc;    lvrc = DSMemStats(&stats);    if (lvrc == mgNoErr) {        *lv_dataspace_size = (uint64_t)stats.totAllocSize;    }    rc = uv_getrusage(&rusage);    if (rc == 0) {        *user_cpu_time = (double)rusage.ru_utime.tv_sec + rusage.ru_utime.tv_usec * 1e-6;        *system_cpu_time = (double)rusage.ru_stime.tv_sec + rusage.ru_stime.tv_usec * 1e-6;        *peak_working_set = rusage.ru_maxrss;        *hard_page_faults = rusage.ru_majflt;    }    rc = uv_uptime(&up);    if (rc == 0) {        *uptime = up;    }    *hi_res_relative_time = uv_hrtime();    return;}

void RequestHandler::set_response(const SharedRefPtr<Response>& response) {  uint64_t elapsed = uv_hrtime() - start_time_ns();  current_host_->update_latency(elapsed);  connection_->metrics()->record_request(elapsed);  future_->set_response(current_host_->address(), response);  return_connection_and_finish();}

/* Logs the end of a GC run. */void MVM_profiler_log_gc_end(MVMThreadContext *tc) {    MVMProfileThreadData *ptd = get_thread_data(tc);    MVMProfileCallNode   *pcn = ptd->current_call;    MVMuint64 gc_time;    MVMint32  retained_bytes;    /* Record time spent. */    gc_time = uv_hrtime() - ptd->cur_gc_start_time;    ptd->gcs[ptd->num_gcs].time = gc_time;    /* Record retained and promoted bytes. */    retained_bytes = (char *)tc->nursery_alloc - (char *)tc->nursery_tospace;    ptd->gcs[ptd->num_gcs].promoted_bytes = tc->gc_promoted_bytes;    ptd->gcs[ptd->num_gcs].retained_bytes = retained_bytes;    /* Tweak cleared bytes count. */    ptd->gcs[ptd->num_gcs].cleared_bytes -= (retained_bytes + tc->gc_promoted_bytes);    /* Record number of gen 2 roots (from gen2 to nursery) */    ptd->gcs[ptd->num_gcs].num_gen2roots = tc->num_gen2roots;    /* Increment the number of GCs we've done. */    ptd->num_gcs++;    /* Discount GC time from all active frames. */    while (pcn) {        pcn->cur_skip_time += gc_time;        pcn = pcn->pred;    }}

/* Gets the current thread's profiling data structure, creating it if needed. */static MVMProfileThreadData * get_thread_data(MVMThreadContext *tc) {    if (!tc->prof_data) {        tc->prof_data = MVM_calloc(1, sizeof(MVMProfileThreadData));        tc->prof_data->start_time = uv_hrtime();    }    return tc->prof_data;}

 Meter(ThreadState* thread_state)   : one_minute_rate_(1.0 - exp(-static_cast<double>(ExponentiallyWeightedMovingAverage::INTERVAL) / 60.0 / 1), thread_state)   , five_minute_rate_(1.0 - exp(-static_cast<double>(ExponentiallyWeightedMovingAverage::INTERVAL) / 60.0 / 5), thread_state)   , fifteen_minute_rate_(1.0 - exp(-static_cast<double>(ExponentiallyWeightedMovingAverage::INTERVAL) / 60.0 / 15), thread_state)   , count_(thread_state)   , start_time_(uv_hrtime())   , last_tick_(start_time_) {}

int uv__loop_init(uv_loop_t* loop, int default_loop) {#if HAVE_KQUEUE    int flags = EVBACKEND_KQUEUE;#else    int flags = EVFLAG_AUTO;#endif    memset(loop, 0, sizeof(*loop));    RB_INIT(&loop->ares_handles);    RB_INIT(&loop->timer_handles);    ngx_queue_init(&loop->active_reqs);    ngx_queue_init(&loop->idle_handles);    ngx_queue_init(&loop->async_handles);    ngx_queue_init(&loop->check_handles);    ngx_queue_init(&loop->prepare_handles);    ngx_queue_init(&loop->handle_queue);    loop->closing_handles = NULL;    loop->channel = NULL;    loop->time = uv_hrtime() / 1000000;    loop->async_pipefd[0] = -1;    loop->async_pipefd[1] = -1;    loop->ev = (default_loop ? ev_default_loop : ev_loop_new)(flags);    ev_set_userdata(loop->ev, loop);    eio_channel_init(&loop->uv_eio_channel, loop);#if __linux__    RB_INIT(&loop->inotify_watchers);    loop->inotify_fd = -1;#endif#if HAVE_PORTS_FS    loop->fs_fd = -1;#endif    return 0;}

static void microdelay(uint64_t microseconds){  uint64_t hrtime;  int64_t ns = microseconds * 1000;  // convert to nanoseconds  uv_mutex_lock(&delay_mutex);  while (ns > 0) {    hrtime =  uv_hrtime();    if (uv_cond_timedwait(&delay_cond, &delay_mutex, ns) == UV_ETIMEDOUT)      break;    ns -= uv_hrtime() - hrtime;  }  uv_mutex_unlock(&delay_mutex);}

/* Log that we're entering a new frame. */void MVM_profile_log_enter(MVMThreadContext *tc, MVMStaticFrame *sf, MVMuint64 mode) {    MVMProfileThreadData *ptd = get_thread_data(tc);    /* Try to locate the entry node, if it's in the call graph already. */    MVMProfileCallNode *pcn = NULL;    MVMuint32 i;    if (ptd->current_call)        for (i = 0; i < ptd->current_call->num_succ; i++)            if (ptd->current_call->succ[i]->sf == sf)                pcn = ptd->current_call->succ[i];    /* If we didn't find a call graph node, then create one and add it to the     * graph. */    if (!pcn) {        pcn     = MVM_calloc(1, sizeof(MVMProfileCallNode));        pcn->sf = sf;        if (ptd->current_call) {            MVMProfileCallNode *pred = ptd->current_call;            pcn->pred = pred;            if (pred->num_succ == pred->alloc_succ) {                pred->alloc_succ += 8;                pred->succ = MVM_realloc(pred->succ,                    pred->alloc_succ * sizeof(MVMProfileCallNode *));            }            pred->succ[pred->num_succ] = pcn;            pred->num_succ++;        }        else {            if (!ptd->call_graph)                ptd->call_graph = pcn;        }    }    /* Increment entry counts. */    pcn->total_entries++;    switch (mode) {        case MVM_PROFILE_ENTER_SPESH:            pcn->specialized_entries++;            break;        case MVM_PROFILE_ENTER_SPESH_INLINE:            pcn->specialized_entries++;            pcn->inlined_entries++;            break;        case MVM_PROFILE_ENTER_JIT:            pcn->jit_entries++;            break;        case MVM_PROFILE_ENTER_JIT_INLINE:            pcn->jit_entries++;            pcn->inlined_entries++;            break;    }    pcn->entry_mode = mode;    /* Log entry time; clear skip time. */    pcn->cur_entry_time = uv_hrtime();    pcn->cur_skip_time  = 0;    /* The current call graph node becomes this one. */    ptd->current_call = pcn;}

void rxs_jitter_update(rxs_jitter* jit) {  uint64_t now  = ((uv_hrtime() - jit->time_start));  rxs_packet* pkt = NULL;    /* only when our buffer is filled */  if (jit->npackets < (jit->packets->npackets / 2)) {    return ;  }  /* check if there is a packet which needs to be shown */  if (jit->timeout == 0) {    jit->timestamp_start = jit->packets->packets[0].timestamp;    jit->time_start = uv_hrtime();    jit->timeout = now;    jit->curr_pkt = &jit->packets->packets[0];    printf("First timeout set: %llu, first seqnum: %u/n", jit->timeout, jit->curr_pkt->seqnum);  }  if (now < jit->timeout) {    return;  }  if (!jit->curr_pkt) {    printf("Error: cannot find curr pkt./n");    return;  }  /* construct a packet, @todo - not sure if we need to check the return value here...  */  rxs_reconstruct_merge_packets(&jit->reconstruct, jit->curr_pkt->timestamp);  /* find the next timeout */  pkt = jitter_next_packet(jit);  if (!pkt) {    printf("Error: no next packet found. This should not happen (unless sender stopped)!/n");    exit(0);  }  else {    jit->timeout = pkt->timestamp - jit->timestamp_start;    jit->curr_pkt = pkt;    return ;  }  printf("no next packet found/n");  exit(0);  return ;}

 double mean_rate() const {   if (count() == 0) {     return 0.0;   } else {     double elapsed = static_cast<double>(uv_hrtime() - start_time_) / 1e9;     return count() / elapsed;   } }

/// Sleeps for a certain amount of microseconds////// @param microseconds Number of microseconds to sleepvoid os_microdelay(uint64_t microseconds){  uint64_t elapsed = 0;  uint64_t ns = microseconds * 1000;  // convert to nanoseconds  uint64_t base = uv_hrtime();  uv_mutex_lock(&delay_mutex);  while (elapsed < ns) {    if (uv_cond_timedwait(&delay_cond, &delay_mutex, ns - elapsed)        == UV_ETIMEDOUT)      break;    uint64_t now = uv_hrtime();    elapsed += now - base;    base = now;  }  uv_mutex_unlock(&delay_mutex);}

// The boundary string is used when posting multipart/form-data void HTTPRequest::generateBoundary() {  if(boundary.size()) {    RX_ERROR("Already created an boundary. Not updating");    return;  }    std::stringstream ss;  ss << uv_hrtime();  boundary = "ROXLU" +ss.str();}

static void sync_bench(const char* path) {  uint64_t before;  uint64_t after;  uv_fs_t req;  int i;  /* do the sync benchmark */  before = uv_hrtime();  for (i = 0; i < NUM_SYNC_REQS; i++)    sync_stat(&req, path);  after = uv_hrtime();  printf("%s stats (sync): %.2fs (%s/s)/n",         fmt(1.0 * NUM_SYNC_REQS),         (after - before) / 1e9,         fmt((1.0 * NUM_SYNC_REQS) / ((after - before) / 1e9)));  fflush(stdout);}

static int pound_it(int concurrency,                    const char* type,                    setup_fn do_setup,                    connect_fn do_connect,                    make_connect_fn make_connect,                    void* arg) {  double secs;  int r;  uint64_t start_time; /* in ns */  uint64_t end_time;  loop = uv_default_loop();  uv_update_time(loop);  start = uv_now(loop);  /* Run benchmark for at least five seconds. */  start_time = uv_hrtime();  do_setup(concurrency, arg);  r = do_connect(concurrency, make_connect, arg);  ASSERT(!r);  uv_run(loop, UV_RUN_DEFAULT);  end_time = uv_hrtime();  /* Number of fractional seconds it took to run the benchmark. */  secs = (double)(end_time - start_time) / NANOSEC;  fprintf(stderr, "%s-conn-pound-%d: %.0f accepts/s (%d failed)/n",          type,          concurrency,          closed_streams / secs,          conns_failed);  fflush(stderr);  MAKE_VALGRIND_HAPPY();  return 0;}

static void on_timer(uv_timer_t* handle) {    char msg[1024];    const char* s = "abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ.";    snprintf(msg, sizeof(msg), "Repeated text: (1) %s (2) %s (3) %s (4) %s", s, s, s, s);    uint64_t elapsed_time = uv_hrtime(); // ns    for(int i = 0; i < bench; i++) {        // uvx_log_send(&xlog, UVX_LOG_INFO, "xlog,test,liigo", msg, "/home/liigo/source.c", i + 1);        UVX_LOG(&xlog, UVX_LOG_INFO, "xlog,test,liigo", "Log content(index %d): %s", i, msg);    }    printf("sent %d logs, elapsed time: %"_UINT64_FMT" us (1000us = 1ms)./n", bench, (uv_hrtime() - elapsed_time) / 1000);}

int uv__loop_init(uv_loop_t* loop, int default_loop) {  unsigned int i;  int flags;  uv__signal_global_once_init();#if HAVE_KQUEUE  flags = EVBACKEND_KQUEUE;#else  flags = EVFLAG_AUTO;#endif  memset(loop, 0, sizeof(*loop));  RB_INIT(&loop->timer_handles);  ngx_queue_init(&loop->wq);  ngx_queue_init(&loop->active_reqs);  ngx_queue_init(&loop->idle_handles);  ngx_queue_init(&loop->async_handles);  ngx_queue_init(&loop->check_handles);  ngx_queue_init(&loop->prepare_handles);  ngx_queue_init(&loop->handle_queue);  loop->closing_handles = NULL;  loop->time = uv_hrtime() / 1000000;  loop->async_pipefd[0] = -1;  loop->async_pipefd[1] = -1;  loop->async_sweep_needed = 0;  loop->signal_pipefd[0] = -1;  loop->signal_pipefd[1] = -1;  loop->emfile_fd = -1;  loop->ev = (default_loop ? ev_default_loop : ev_loop_new)(flags);  ev_set_userdata(loop->ev, loop);  uv_signal_init(loop, &loop->child_watcher);  uv__handle_unref(&loop->child_watcher);  loop->child_watcher.flags |= UV__HANDLE_INTERNAL;  for (i = 0; i < ARRAY_SIZE(loop->process_handles); i++)    ngx_queue_init(loop->process_handles + i);  if (uv_mutex_init(&loop->wq_mutex))    abort();  if (uv_async_init(loop, &loop->wq_async, uv__work_done))    abort();  uv__handle_unref(&loop->wq_async);  loop->wq_async.flags |= UV__HANDLE_INTERNAL;  if (uv__platform_loop_init(loop, default_loop))    return -1;  return 0;}

	Node(uint64_t id, int cluster_size, ab_callbacks_t callbacks, void* callbacks_data)	: m_id(id)	, m_cluster_size(cluster_size)	, m_peer_registry(std::make_unique<PeerRegistry>())	, m_codec(std::make_shared<Codec>())	, m_index_counter(0)	, m_trusted_peer(0)	, m_last_leader_active(uv_hrtime())	, m_role(std::make_unique<Role>(*m_peer_registry, id, cluster_size))	, m_mutex(std::make_unique<std::mutex>())	{		m_role->set_callbacks(callbacks, callbacks_data);	}

/* Log that we've entered a native routine */void MVM_profile_log_enter_native(MVMThreadContext *tc, MVMObject *nativecallsite) {    MVMProfileThreadData *ptd = get_thread_data(tc);    MVMProfileCallNode *pcn = NULL;    MVMNativeCallBody *callbody;    MVMuint32 i;    /* We locate the right call node by looking at sf being NULL and the     * native_target_name matching our intended target. */    callbody = MVM_nativecall_get_nc_body(tc, nativecallsite);    if (ptd->current_call)        for (i = 0; i < ptd->current_call->num_succ; i++)            if (ptd->current_call->succ[i]->sf == NULL)                if (strcmp(callbody->sym_name,                           ptd->current_call->succ[i]->native_target_name) == 0) {                    pcn = ptd->current_call->succ[i];                    break;                }    /* If we didn't find a call graph node, then create one and add it to the     * graph. */    if (!pcn) {        pcn     = MVM_calloc(1, sizeof(MVMProfileCallNode));        pcn->native_target_name = callbody->sym_name;        if (ptd->current_call) {            MVMProfileCallNode *pred = ptd->current_call;            pcn->pred = pred;            if (pred->num_succ == pred->alloc_succ) {                pred->alloc_succ += 8;                pred->succ = MVM_realloc(pred->succ,                    pred->alloc_succ * sizeof(MVMProfileCallNode *));            }            pred->succ[pred->num_succ] = pcn;            pred->num_succ++;        }        else {            if (!ptd->call_graph)                ptd->call_graph = pcn;        }    }    /* Increment entry counts. */    pcn->total_entries++;    pcn->entry_mode = 0;    /* Log entry time; clear skip time. */    pcn->cur_entry_time = uv_hrtime();    pcn->cur_skip_time  = 0;    /* The current call graph node becomes this one. */    ptd->current_call = pcn;}

/* Log that we've finished doing bytecode specialization or JIT. */void MVM_profiler_log_spesh_end(MVMThreadContext *tc) {    MVMProfileThreadData *ptd = get_thread_data(tc);    MVMProfileCallNode   *pcn = ptd->current_call;    MVMuint64 spesh_time;    /* Record time spent. */    spesh_time = uv_hrtime() - ptd->cur_spesh_start_time;    ptd->spesh_time += spesh_time;    /* Discount spesh time from all active frames. */    while (pcn) {        pcn->cur_skip_time += spesh_time;        pcn = pcn->pred;    }}

/* Logs the start of a GC run. */void MVM_profiler_log_gc_start(MVMThreadContext *tc, MVMuint32 full) {    MVMProfileThreadData *ptd = get_thread_data(tc);    /* Make a new entry in the GCs. We use the cleared_bytes to store the     * maximum that could be cleared, and after GC is done will subtract     * retained bytes and promoted bytes. */    if (ptd->num_gcs == ptd->alloc_gcs) {        ptd->alloc_gcs += 16;        ptd->gcs = MVM_realloc(ptd->gcs, ptd->alloc_gcs * sizeof(MVMProfileGC));    }    ptd->gcs[ptd->num_gcs].full          = full;    ptd->gcs[ptd->num_gcs].cleared_bytes = (char *)tc->nursery_alloc -                                           (char *)tc->nursery_tospace;    /* Record start time. */    ptd->cur_gc_start_time = uv_hrtime();}