elapsed
struct timespec elapsed, now;
timespecsub(&now, &st.start, &elapsed);
if (elapsed.tv_sec > 600)
bps = st.bytes / elapsed.tv_sec;
else if (elapsed.tv_sec > 0) {
msec = elapsed.tv_sec * 1000 + elapsed.tv_nsec / 1000000;
} else if (elapsed.tv_nsec > 0)
bps = st.bytes * 1000000000 / elapsed.tv_nsec;
(long long)elapsed.tv_sec, elapsed.tv_nsec / 1000000, bps);
struct timespec elapsed, now;
timespecsub(&now, &mlastchkd, &elapsed);
if (elapsed.tv_sec >= mailcheck_interval) {
elapsed = (double)res.tv_sec + (double)res.tv_usec / 1000000.0;
(void)printf("Time = %f seconds\n", elapsed);
(double)TEST_BLOCK_LEN * count / elapsed);
double elapsed;
void elapsed(const struct pinfo *, VARENT *);
{"etime", "ELAPSED", NULL, USER, elapsed, 12},
struct timespec start, end, elapsed;
timespecsub(&end, &start, &elapsed);
timespecsub(limit, &elapsed, limit);
struct timespec pollstart, pollend, elapsed;
timespecsub(&pollend, &pollstart, &elapsed);
timeout -= elapsed.tv_sec * 1000 + elapsed.tv_nsec / 1000000;
struct timeval elapsed, monostart, monostop, realstart, realstop;
timersub(&monostop, &monostart, &elapsed);
if (elapsed.tv_sec < 0)
timerclear(&elapsed);
timersub(&realstop, &elapsed, &realstart);
print_timing(struct test_distribution *d, char *sub, int m, int n, double elapsed)
d->name, sub, m, n, elapsed);
d->name, sub, n, elapsed);
d->name, m, n, elapsed);
d->name, n, elapsed);
double elapsed;
elapsed = after.tv_sec + after.tv_nsec / 1000000000.0;
print_timing(d, sub, m, n, elapsed);
double elapsed;
elapsed = after.tv_sec + after.tv_nsec / 1000000000.0;
print_timing(d, NULL, 0, n, elapsed);
long long elapsed;
elapsed = 1000000000LL * (tsb.tv_sec - tsl.tv_sec)
(void)printf("%lld nsec\n", elapsed);
timespecsub(¤t_time, &sp->se_started, &elapsed);
if (elapsed.tv_sec < GETTY_SPACING) {
struct timespec current_time, elapsed;
time_t elapsed;
elapsed = *env->now - ta->last_change;
if (elapsed > (time_t)holddown) {
return elapsed-(time_t)holddown;
(long long) ((time_t)holddown-elapsed));
timespecsub(&tp, &last_network_change, &elapsed);
if (sec != SECURE && elapsed.tv_sec < DOUBT_NXDOMAIN_SEC &&
elapsed.tv_sec);
struct timespec tp, elapsed;
timespecsub(&tp, &rq->tp, &elapsed);
ms = elapsed.tv_sec * 1000 + elapsed.tv_nsec / 1000000;
struct timespec tp, elapsed;
timespecsub(&tp, &query_imsg->tp, &elapsed);
ms = elapsed.tv_sec * 1000 + elapsed.tv_nsec / 1000000;
u_int32_t elapsed; /* only for sense */
u_int32_t elapsed; /* only for sense */
u32 elapsed[TF_COUNT], cycles;
cs = intel_ring_begin(rq, 4 + 12 * ARRAY_SIZE(elapsed));
for (i = 1; i <= ARRAY_SIZE(elapsed); i++) {
for (i = 1; i <= ARRAY_SIZE(elapsed); i++) {
elapsed[i - 1] = sema[i] - cycles;
cycles = trifilter(elapsed);
u32 elapsed[TF_COUNT], cycles;
for (i = 0; i < ARRAY_SIZE(elapsed); i++) {
elapsed[i] = ENGINE_READ_FW(ce->engine, RING_TIMESTAMP);
for (i = 0; i < ARRAY_SIZE(elapsed); i++)
elapsed[i] = sema[i] - elapsed[i];
cycles = trifilter(elapsed);
u32 elapsed[TF_COUNT + 1], cycles;
for (i = 1; i <= ARRAY_SIZE(elapsed); i++) {
elapsed[i - 1] = ENGINE_READ_FW(ce->engine, RING_TIMESTAMP);
elapsed[i - 1] = sema[i] - elapsed[i];
cycles = trifilter(elapsed);
u32 elapsed[TF_COUNT + 1], cycles;
for (i = 1; i <= ARRAY_SIZE(elapsed); i++) {
elapsed[i - 1] = sema[i + 1] - sema[i];
cycles = trifilter(elapsed);
u32 elapsed[TF_COUNT + 1], cycles;
for (i = 1; i <= ARRAY_SIZE(elapsed); i++) {
elapsed[i - 1] = sema[2 * i + 2] - sema[2 * i + 1];
cycles = trifilter(elapsed);
u32 elapsed[TF_COUNT], cycles;
for (i = 1; i <= ARRAY_SIZE(elapsed); i++) {
elapsed[i - 1] = ENGINE_READ_FW(ce->engine, RING_TIMESTAMP);
elapsed[i - 1] = sema[2 * i + 0] - elapsed[i - 1];
cycles = trifilter(elapsed);
elapsed[i - 1] = sema[2 * i + 1] - sema[2 * i + 0];
cycles = trifilter(elapsed);
u32 elapsed[TF_COUNT], cycles;
for (i = 1; i <= ARRAY_SIZE(elapsed); i++) {
elapsed[i - 1] = ENGINE_READ_FW(ce->engine, RING_TIMESTAMP);
for (i = 0; i < ARRAY_SIZE(elapsed); i++) {
elapsed[i] = elapsed[i] - sema[i + 1];
cycles = trifilter(elapsed);
uint64_t elapsed;
elapsed = jiffies_to_msecs(jiffies_64 - last);
if (radeon_lockup_timeout && elapsed >= radeon_lockup_timeout) {
ring->idx, elapsed);
time_t elapsed;
elapsed = sc->sc_cur.tv_sec - sc->sc_start.tv_sec;
if (elapsed >= ONERNG_RATE_SECONDS) {
rate = (8 * sc->sc_counted_bytes) / (elapsed * 1024);
time_t elapsed;
elapsed = sc->sc_cur.tv_sec - sc->sc_start.tv_sec;
if (elapsed >= URNG_RATE_SECONDS) {
rate = (8 * sc->sc_counted_bytes) / (elapsed * 1024);
struct timespec booted, elapsed, realstart, st, tmp, uptime, ut;
timespecsub(&uptime, &pr->ps_start, &elapsed);
acct.ac_etime = encode_comp_t(elapsed.tv_sec, elapsed.tv_nsec);
uint64_t elapsed;
elapsed = (now - *next) / period + 1;
*next += period * elapsed;
return elapsed;
struct timespec elapsed, start, stop;
timespecsub(&stop, &start, &elapsed);
timespecsub(tsp, &elapsed, tsp);
timersub(&end, &start, &elapsed);
if (elapsed.tv_sec >= 2 &&
(long)elapsed.tv_sec,
(long)elapsed.tv_usec);
TRACEPOINT(smr, thread, TIMEVAL_TO_NSEC(&elapsed), count);
struct timeval elapsed, end, loglast, start;
struct bintime elapsed;
bintimesub(&new_naptime, &old_naptime, &elapsed);
adj_ticks = BINTIME_TO_NSEC(&elapsed) / tick_nsec;
struct timespec elapsed, remainder, request, start, stop;
timespecsub(&stop, &start, &elapsed);
timespecsub(&request, &elapsed, &request);
struct timespec elapsed;
NSEC_TO_TIMESPEC(nsecs, &elapsed);
itimerdecr(&pr->ps_timer[ITIMER_VIRTUAL], &elapsed) == 0) {
itimerdecr(&pr->ps_timer[ITIMER_PROF], &elapsed) == 0) {
struct timespec elapsed, now;
timespecsub(&now, lastscan, &elapsed);
if (elapsed.tv_sec >= timeout_level_width[level]) {
uint64_t elapsed, start;
elapsed = getnsecuptime() - start;
if (elapsed < SEC_TO_NSEC(1)) {
SEC_TO_NSEC(1) - elapsed);
double elapsed;
elapsed = td.tv_sec + (td.tv_nsec / 1000000000.0);
i = (int)elapsed / 3600;
i = (int)elapsed % 3600;
} else if (bytes <= 0 || elapsed <= 0.0 || cursize > filesize) {
(bytes / elapsed) - elapsed);
double elapsed, pace;
elapsed = td.tv_sec + (td.tv_nsec / 1000000000.0);
bs = bytes / (elapsed == 0.0 ? 1 : elapsed);
(long long)elapsed, (int)(elapsed * 100.0) % 100,
if (siginfo && bytes > 0 && elapsed > 0.0 && filesize >= 0 &&
(bytes / elapsed) - elapsed);
struct timespec elapsed, now;
timespecsub(&now, &start, &elapsed);
return elapsed.tv_sec + elapsed.tv_nsec / 1000000000.0;
struct timeval elapsed;
timersub(&now.ru_utime, &start, &elapsed);
return elapsed.tv_sec + elapsed.tv_usec / 1000000.0;
double elapsed, totalTime;
elapsed = app_timer_real(TM_GET);
if (elapsed > cfg.maxtime)
nConn, elapsed, nConn > 0 ? bytes_read / nConn : 0);
double elapsed = monotime_double() - start, req = seconds, remain;
if (elapsed > MAX_FAIL_DELAY_SECONDS) {
"requested %0.3lfms)", elapsed*1000, req*1000);
while ((remain = seconds - elapsed) < 0.0)
elapsed*1000, remain*1000, req*1000);
time_t time_now, elapsed;
elapsed = time_now - time_start;
time_per_line = (double)elapsed / processed;
processed, fmt_time(elapsed));
fmt_time(elapsed), eta_str);
double elapsed, now;
elapsed = now - last_update;
elapsed = now - start;
if (elapsed != 0)
cur_speed = (transferred / elapsed);
stalled += elapsed;
seconds = elapsed;
struct timespec elapsed, now;
timespecsub(&now, &prev, &elapsed);
etime = elapsed.tv_sec + elapsed.tv_nsec / 1000000000.0;
struct timespec elapsed;
timespecsub(&prev_stop, &prev_start, &elapsed);
wprintw(rw, "%7lld.%02ld %-7s", (long long)elapsed.tv_sec,
elapsed.tv_nsec / 10000000, "real");
double elapsed = (double)(time_end_0 - time_start_0)+
zone_buf, log_buf, num_bytes, elapsed));
struct timeval elapsed, uptime;
timeval_subtract(&elapsed, now, rc_stats_time);
timeval_subtract(&elapsed, now, &xfrd->nsd->metrics->stats_time);
(unsigned long)elapsed.tv_sec, (unsigned long)elapsed.tv_usec);
struct timeval elapsed, uptime;
timeval_subtract(&elapsed, now, &xfrd->nsd->rc->stats_time);
(unsigned long)elapsed.tv_sec, (unsigned long)elapsed.tv_usec))
static void rrl_attenuate_bucket(struct rrl_bucket* b, int32_t elapsed)
if(elapsed > 16) {
b->rate >>= elapsed;
b->rate += (b->counter>>(elapsed-1));
PR_STATSTIME("time.elapsed", shm_stat->time.elapsed);
struct timeval* elapsed)
dt = (double)(elapsed->tv_sec*1000000 + elapsed->tv_usec) / 1000000;
time_t elapsed;
elapsed = *env->now - ta->last_change;
if (elapsed > (time_t)holddown) {
return elapsed-(time_t)holddown;
(long long) ((time_t)holddown-elapsed));