void ssrv_t::req_made () { reqtimes.push_back (sfs_get_tsnow()); while (reqtimes.size () && tsdiff (reqtimes[0], sfs_get_tsnow(), ok_amt_lasi)) reqtimes.pop_front (); load_avg = reqtimes.size (); }
void timecb_check () { struct timespec my_ts; timecb_t *tp, *ntp; if (timecbs.first ()) { sfs_set_global_timestamp (); my_ts = sfs_get_tsnow (); for (tp = timecbs.first (); tp && tp->ts <= my_ts; tp = timecbs_altered ? timecbs.first () : ntp) { ntp = timecbs.next (tp); timecbs.remove (tp); timecbs_altered = false; #ifdef WRAP_DEBUG if (callback_trace & CBTR_TIME) warn ("CALLBACK_TRACE: %stimecb %s <- %s\n", timestring (), tp->cb->dest, tp->cb->line); #endif /* WRAP_DEBUG */ STOP_ACHECK_TIMER (); sfs_leave_sel_loop (); (*tp->cb) (); START_ACHECK_TIMER (); delete tp; } } selwait.tv_usec = 0; selwait.tv_sec = 0; if (!sfs_core::g_busywait && !sigdocheck) { if (!(tp = timecbs.first ())) selwait.tv_sec = 86400; else { if (tp->ts.tv_sec == 0) { selwait.tv_sec = 0; } else { sfs_set_global_timestamp (); my_ts = sfs_get_tsnow (); if (tp->ts < my_ts) selwait.tv_sec = 0; else if (tp->ts.tv_nsec >= my_ts.tv_nsec) { selwait.tv_sec = tp->ts.tv_sec - my_ts.tv_sec; selwait.tv_usec = (tp->ts.tv_nsec - my_ts.tv_nsec) / 1000; } else { selwait.tv_sec = tp->ts.tv_sec - my_ts.tv_sec - 1; selwait.tv_usec = (1000000000 + tp->ts.tv_nsec - my_ts.tv_nsec) / 1000; } } } } }
void mtd_stats_t::report () { if (ok_amt_stat_freq == 0 || !tsdiff (start_sample, sfs_get_tsnow(), ok_amt_stat_freq)) return; epoch_t e = new_epoch (); warn ("STATS: i=%d;o=%d;r=%d;q=%d;a=%d;t=%d;l=%d\n", e.in, e.out, e.rejects, e.queued, e.async_serv, e.to, e.len_msec); }
// returns a time in microseconds int stop_timer (const timespec &tm) { struct timespec tsnow = sfs_get_tsnow (); int ret = (tsnow.tv_nsec - tm.tv_nsec) / THOUSAND; int tmp = (tsnow.tv_sec - tm.tv_sec) * MILLION; ret += tmp; return ret; }
void tpt_do_sample (bool last) { int diff = stop_timer (tpt_last_sample); int num = n_successes - last_n_successes; last_n_successes = n_successes; tpt_samples.push_back (tpt_pair_t (diff, num)); tpt_last_sample = sfs_get_tsnow (); if (!last) sched_tpt_measurement (); }
void svccb::init (asrv *s, const sockaddr *src) { srv = mkref (s); srv->xi->svcadd (); if (!s->xi->xh->connected) { addrlen = s->xi->xh->socksize; addr = (sockaddr *) opnew (addrlen); memcpy (addr, src, addrlen); } // keep track of when this RPC started ts_start = sfs_get_tsnow(); }
timecb_t * delaycb (time_t sec, u_int32_t nsec, cbv cb) { timespec ts; if (sec == 0 && nsec == 0) { ts.tv_sec = 0; ts.tv_nsec = 0; } else { sfs_get_tsnow (&ts, true); ts.tv_sec += sec; ts.tv_nsec += nsec; fixup_timespec (ts); } return timecb (ts, cb); }
static inline const char * timestring () { if (!callback_time) return ""; struct timespec ts; sfs_get_tsnow (&ts, true); static str buf; buf = strbuf ("%d.%06d ", int (ts.tv_sec), int (ts.tv_nsec/1000)); return buf; }
static void lose_patience_cb () { struct timespec tsnow = sfs_get_tsnow (); if (noisy) warnx ("lpcb: td=%d; nleft=%d\n", timediff (tsnow, lastexit), nleft); if (lose_patience_after && timediff (tsnow, lastexit) > lose_patience_after && n_still_patient && nreq < n_still_patient) { stats.exit_timeouts += nreq; global_do_exit (0); } else schedule_lose_patience_timer (); }
static void main2 (int n) { struct timespec tsnow = sfs_get_tsnow (); lastexit = tsnow; startt = tsnow; nleft = n - nconcur; tpt_last_sample = tsnow; sched_tpt_measurement (); for (int i = 0; i < nconcur; i++) { hclient_t *h = New hclient_t (); h->run (); } }
void hclient_t::run () { struct timespec tsnow = sfs_get_tsnow (); if (noisy) warn << "run: " << id << "\n"; if (nrunning >= nconcur) { if (noisy) warn << "queuing: " << id << "\n"; q.push_back (this); return; } nrunning++; if (noisy) warn << "running: " << id << " (nrunning: " << nrunning << ")\n"; if (noisy) warn << "connecting to: " << host << "\n"; cli_start = tsnow; tcb = delaycb (timeout, 0, wrap (this, &hclient_t::timed_out, destroyed)); tcpconnect (host, port, wrap (this, &hclient_t::connected, destroyed)); }
void hclient_t::hclient_do_exit (int c) { if (c == 0) n_successes ++; lastexit = sfs_get_tsnow(); if (noisy) warn << "at cexit2: " << id << "\n"; --nrunning; launch_others (); if (noisy) warn << "done: " << id << " (nreq: " << nreq << ")\n"; if (success) latencies.push_back (stop_timer (cli_start)); if (!--nreq && sdflag) global_do_exit (c); delete this; return; }
epoch_t mtd_stats_t::new_epoch () { epoch_t e = sample; struct timespec tsnow; tsnow = sfs_get_tsnow (); e.len_msec = (tsnow.tv_sec - start_sample.tv_sec) * 1000 + (tsnow.tv_nsec - start_sample.tv_nsec) / 1000000; start_sample = tsnow; sample.in = 0; sample.out = 0; sample.rejects = 0; sample.queued = 0; sample.async_serv = 0; sample.to = 0; return e; }
int main (int argc, char *argv[]) { timeout = 120; noisy = false; zippity = false; srandom(time(0)); setprogname (argv[0]); int ch; int n = 1000; nconcur = 500; bool delay = false; timespec startat; startat.tv_nsec = 0; startat.tv_sec = 0; exited = false; hclient_id = 1; use_latencies = false; num_services = 1; tpt_sample_period_secs = 1; tpt_sample_period_nsecs = 0; int lat_stddv = 25; int lat_mean = 75; lose_patience_after = 0; id_cycler_t *svc_cycler = NULL; id_cycler_t *req_cycler = NULL; mode = NONE; bool no_pub = false; int tmp = 0; static rxx lose_patience_rxx ("(\\d+),(\\d+)"); while ((ch = getopt (argc, argv, "c:dlm:n:pr:t:v:zM:P:S:R:T:V:")) != -1) { switch (ch) { case 'c': if (!convertint (optarg, &nconcur)) usage (); if (noisy) warn << "Concurrency factor: " << nconcur << "\n"; break; case 'd': noisy = true; break; case 'l': use_latencies = true; if (noisy) warn << "Using Latencies\n"; break; case 'm': { switch (optarg[0]) { case 's': case 'S': mode = SEDA; if (noisy) warn << "In SEDA mode\n"; break; case 'o': case 'O': mode = OKWS; if (noisy) warn << "In OKWS mode\n"; break; case 'P': case 'p': mode = PHP; if (noisy) warn << "In PHP mode\n"; break; case 'f': case 'F': mode = FLASH; if (noisy) warn << "In FLASH mode\n"; break; default: usage (); break; } break; } case 'n': if (!convertint (optarg, &n)) usage (); if (noisy) warn << "Number of requests: " << n << "\n"; break; case 'p': no_pub = true; break; case 'r': if (!convertint (optarg, &tmp)) usage (); req_cycler = New id_cycler_t (true, tmp, 1); if (noisy) warn << "Ranging ids from 1 to " << tmp << " (randomly)\n"; break; case 't': { if (!convertint (optarg, &startat.tv_sec)) usage (); delay = true; if (noisy) warn << "Delaying start until time=" << startat.tv_sec << "\n"; time_t mytm = time (NULL); tmp = startat.tv_sec - mytm; if (tmp < 0) { warn << "time stamp alreached (it's " << mytm << " right now)!\n"; usage (); } if (noisy) { warn << "Starting in T minus " << tmp << " seconds\n"; } break; } case 'v': if (!convertint (optarg, &tmp)) usage (); svc_cycler = New id_cycler_t (true, tmp, 1); if (noisy) warn << "Randing services from 1 to " << tmp << " (randomly)\n"; break; case 'z': zippity = true; break; case 'M': if (!convertint (optarg, &lat_mean)) usage (); if (noisy) warn << "Mean of latencies: " << lat_mean << "\n"; break; case 'P': if (!convertint (optarg, &tmp)) usage (); tpt_sample_period_secs = tmp / THOUSAND; tpt_sample_period_nsecs = (tmp % THOUSAND) * MILLION; if (noisy) warn ("Sample throughput period=%d.%03d secs\n", tpt_sample_period_secs, tpt_sample_period_nsecs / MILLION); break; case 'R': req_cycler = New id_cycler_t (); if (!req_cycler->init (optarg)) usage (); break; case 'S': if (!convertint (optarg, &lat_stddv)) usage (); if (noisy) warn << "Standard dev. of latency: " << lat_stddv << "\n"; break; case 'T': if (!lose_patience_rxx.match (optarg) || !convertint (lose_patience_rxx[1], &n_still_patient) || !convertint (lose_patience_rxx[2], &lose_patience_after)) usage (); break; case 'V': svc_cycler = New id_cycler_t (); if (!svc_cycler->init (optarg)) usage (); break; default: usage (); } } argc -= optind; argv += optind; if (argc == 0) usage (); str dest = argv[0]; argc --; argv ++; // make the appropriate cyclers... if (argc > 0) { // in this case, the user supplied extra arguments after the hostname // and port; therefore, they're going to be making their own URL // by alternating static parts and cyclers. if (req_cycler) { warn << "Don't provide -r if you're going to make your own URI\n"; usage (); } if (svc_cycler) { warn << "Don't provide -v if you're going to make your own URI\n"; usage (); } for (int i = 0; i < argc; i++) { if (i % 2 == 0) { uri_parts.push_back (argv[i]); } else { id_cycler_t *tmp = New id_cycler_t (); if (!tmp->init (argv[i])) { warn << "Cannot parse ID cycler: " << argv[i] << "\n"; usage (); } id_cyclers.push_back (tmp); } } } else if (mode != NONE) { // no manual URL building required; just specify some defaults // though if none were specified if (!req_cycler) // roughly a million, but this way all reqs will have the same // number of digits req_cycler = New id_cycler_t (true, 900000, 100000); if (!svc_cycler) // don't cycle --- just always return 1 svc_cycler = New id_cycler_t (false, 1, 1); id_cyclers.push_back (svc_cycler); id_cyclers.push_back (req_cycler); switch (mode) { case SEDA: uri_parts.push_back ("mt"); uri_parts.push_back ("?id="); break; case OKWS: { uri_parts.push_back ("mt"); strbuf b ("?"); if (no_pub) b << "nopub=1&"; b << "id="; uri_parts.push_back (b); break; } case PHP: uri_parts.push_back ("mt"); uri_parts.push_back (".php?id="); break; case FLASH: uri_parts.push_back ("cgi-bin/mt"); uri_parts.push_back ("?"); break; default: break; } } // normdist (mean, std-dev, "precision") if (use_latencies) dist = New normdist_t (200,25); if (!hostport.match (dest)) usage (); host = hostport[1]; str port_s = hostport[3]; if (port_s) { if (!convertint (port_s, &port)) usage (); } else { port = 80; } struct timespec tsnow = sfs_get_tsnow (); // unless we don this, shit won't be initialized, and i'll // starting ripping my hair out as to why all of the timestamps // are negative clock_gettime (CLOCK_REALTIME, &tsnow); nrunning = 0; sdflag = true; nreq = n; nreq_fixed = n; tpt_last_nreq = nreq; if (delay) { timecb (startat, wrap (main2, n)); } else { main2 (n); } amain (); }