#if DEBUG_BANDWIDTH
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Bandwidth has %llu bytes available until deadline in %llums\n",
- (unsigned long long) ((b * deadline.value + 500LL) / 1000LL),
- deadline.value);
+ (unsigned long long) ((b * deadline.abs_value + 500LL) / 1000LL),
+ deadline.abs_value);
#endif
- return (b * deadline.value + 500LL) / 1000LL;
+ return (b * deadline.rel_value + 500LL) / 1000LL;
}
#endif
return GNUNET_TIME_UNIT_FOREVER_REL;
}
- ret.value = size * 1000LL / b;
+ ret.rel_value = size * 1000LL / b;
#if DEBUG_BANDWIDTH
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Bandwidth suggests delay of %llu ms for %llu bytes of traffic\n",
- (unsigned long long) ret.value,
+ (unsigned long long) ret.abs_value,
(unsigned long long) size);
#endif
return ret;
uint64_t max_carry;
now = GNUNET_TIME_absolute_get ();
- delta_time = now.value - av->last_update__.value;
+ delta_time = now.abs_value - av->last_update__.abs_value;
delta_avail = (delta_time * ((unsigned long long) av->available_bytes_per_s__) + 500LL) / 1000LL;
av->consumption_since_last_update__ -= delta_avail;
av->last_update__ = now;
#endif
return GNUNET_TIME_UNIT_ZERO;
}
- ret.value = 1000LL * bytes_needed / (unsigned long long) av->available_bytes_per_s__;
+ ret.rel_value = 1000LL * bytes_needed / (unsigned long long) av->available_bytes_per_s__;
#if DEBUG_BANDWIDTH
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Tracker %p delay for %u bytes is %llu ms\n",
av,
(unsigned int) size,
- (unsigned long long) ret.value);
+ (unsigned long long) ret.abs_value);
#endif
return ret;
}
check_complete (conn);
/* check for timeout */
remaining = GNUNET_TIME_absolute_get_remaining (conn->receive_timeout);
- if (remaining.value == 0)
+ if (remaining.rel_value == 0)
{
/* signal timeout! */
conn->receiver_handler (conn->receiver_handler_cls, NULL);
if (buf == NULL)
{
delay = GNUNET_TIME_absolute_get_remaining (th->timeout);
- delay.value /= 2;
+ delay.rel_value /= 2;
if ( (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & GNUNET_SCHEDULER_get_reason (th->sock->sched))) ||
(GNUNET_YES != th->auto_retry) ||
(0 == --th->attempts_left) ||
- (delay.value < 1) )
+ (delay.rel_value < 1) )
{
#if DEBUG_CLIENT
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Transmission failed %u times, trying again in %llums.\n",
MAX_ATTEMPTS - th->attempts_left,
- (unsigned long long) delay.value);
+ (unsigned long long) delay.abs_value);
#endif
th->reconnect_task = GNUNET_SCHEDULER_add_delayed (th->sock->sched,
delay,
char *last;
char *ft;
- if ((last_bulk_time.value == 0) || (last_bulk_repeat == 0))
+ if ((last_bulk_time.abs_value == 0) || (last_bulk_repeat == 0))
return;
rev = 0;
last = memchr (last_bulk, '\0', BULK_TRACK_SIZE);
else
strcpy (date, "localtime error");
if ((0 != (kind & GNUNET_ERROR_TYPE_BULK)) &&
- (last_bulk_time.value != 0) &&
+ (last_bulk_time.abs_value != 0) &&
(0 == strncmp (buf, last_bulk, sizeof (last_bulk))))
{
last_bulk_repeat++;
- if ((GNUNET_TIME_absolute_get_duration (last_bulk_time).value >
+ if ((GNUNET_TIME_absolute_get_duration (last_bulk_time).rel_value >
BULK_DELAY_THRESHOLD)
|| (last_bulk_repeat > BULK_REPEAT_THRESHOLD))
flush_bulk (date);
ret = GNUNET_CONFIGURATION_get_value_number (cfg, section, option, &num);
if (ret == GNUNET_OK)
- time->value = (uint64_t) num;
+ time->rel_value = (uint64_t) num;
return ret;
}
return;
}
now = GNUNET_TIME_absolute_get ();
- if ((now.value > sh->receive_timeout.value) ||
+ if ((now.abs_value > sh->receive_timeout.abs_value) ||
(0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT)) ||
(0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)))
{
"Receive from `%s' encounters error: time out by %llums... (%p)\n",
GNUNET_a2s (sh->addr, sh->addrlen),
GNUNET_TIME_absolute_get_duration (sh->receive_timeout).
- value, sh);
+ abs_value, sh);
#endif
signal_timeout (sh);
return;
return;
}
now = GNUNET_TIME_absolute_get ();
- if ((now.value > sh->receive_timeout.value) ||
+ if ((now.abs_value > sh->receive_timeout.abs_value) ||
(0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)))
{
#if DEBUG_CONNECTION
while ((cache != NULL) &&
((cache->salen != salen) || (0 != memcmp (cache->sa, sa, salen))))
{
- if (GNUNET_TIME_absolute_get_duration (cache->last_request).value <
+ if (GNUNET_TIME_absolute_get_duration (cache->last_request).rel_value <
60 * 60 * 1000)
{
if (prev != NULL)
if (cache != NULL)
{
cache->last_request = now;
- if (GNUNET_TIME_absolute_get_duration (cache->last_request).value <
+ if (GNUNET_TIME_absolute_get_duration (cache->last_request).rel_value <
60 * 60 * 1000)
{
GNUNET_free_non_null (cache->addr);
struct GNUNET_TIME_Relative delta;
unsigned int n;
- if (load->autodecline.value == GNUNET_TIME_UNIT_FOREVER_REL.value)
+ if (load->autodecline.rel_value == GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
return;
delta = GNUNET_TIME_absolute_get_duration (load->last_update);
- if (delta.value < load->autodecline.value)
+ if (delta.rel_value < load->autodecline.rel_value)
return;
- if (load->autodecline.value == 0)
+ if (load->autodecline.rel_value == 0)
{
load->runavg_delay = 0.0;
load->load = 0;
return;
}
- n = delta.value / load->autodecline.value;
+ n = delta.rel_value / load->autodecline.rel_value;
if (n > 16)
{
load->runavg_delay = 0.0;
static void
socket_set_nosigpipe (const struct GNUNET_NETWORK_Handle *h)
{
- int value = 1;
+ int abs_value = 1;
if (0 !=
- setsockopt (h->fd, SOL_SOCKET, SO_NOSIGPIPE, &value, sizeof (value)))
+ setsockopt (h->fd, SOL_SOCKET, SO_NOSIGPIPE, &abs_value, sizeof (abs_value)))
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt");
}
#endif
if (0 != setsockopt (h->fd, IPPROTO_TCP, TCP_NODELAY, &value, sizeof (value)))
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt");
#else
- const char * value = "1";
- if (0 != setsockopt (h->fd, IPPROTO_TCP, TCP_NODELAY, value, sizeof (value)))
+ const char * abs_value = "1";
+ if (0 != setsockopt (h->fd, IPPROTO_TCP, TCP_NODELAY, abs_value, sizeof (abs_value)))
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt");
#endif
}
}
struct timeval tv;
- tv.tv_sec = timeout.value / GNUNET_TIME_UNIT_SECONDS.value;
+ tv.tv_sec = timeout.rel_value / GNUNET_TIME_UNIT_SECONDS.rel_value;
tv.tv_usec =
- 1000 * (timeout.value - (tv.tv_sec * GNUNET_TIME_UNIT_SECONDS.value));
- if ((nfds == 0) && (timeout.value == GNUNET_TIME_UNIT_FOREVER_REL.value)
+ 1000 * (timeout.rel_value - (tv.tv_sec * GNUNET_TIME_UNIT_SECONDS.rel_value));
+ if ((nfds == 0) && (timeout.rel_value == GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
#ifdef MINGW
&& handles == 0
#endif
(rfds != NULL) ? &rfds->sds : NULL,
(wfds != NULL) ? &wfds->sds : NULL,
(efds != NULL) ? &efds->sds : NULL,
- (timeout.value == GNUNET_TIME_UNIT_FOREVER_REL.value)
+ (timeout.rel_value == GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
? NULL : &tv);
#else
#define SAFE_FD_ISSET(fd, set) (set != NULL && FD_ISSET(fd, set))
/* calculate how long we need to wait in milliseconds */
- if (timeout.value == GNUNET_TIME_UNIT_FOREVER_REL.value)
+ if (timeout.abs_value == GNUNET_TIME_UNIT_FOREVER_REL.abs_value)
ms_total = INFINITE;
else
- ms_total = timeout.value / GNUNET_TIME_UNIT_MILLISECONDS.value;
+ ms_total = timeout.abs_value / GNUNET_TIME_UNIT_MILLISECONDS.abs_value;
/* select() may be used as a portable way to sleep */
if (!(rfds || wfds || efds))
perfHash ();
printf ("Hash perf took %llu ms\n",
(unsigned long long)
- GNUNET_TIME_absolute_get_duration (start).value);
+ GNUNET_TIME_absolute_get_duration (start).rel_value);
return 0;
}
if (pos != NULL)
{
to = GNUNET_TIME_absolute_get_difference (now, pos->timeout);
- if (timeout->value > to.value)
+ if (timeout->rel_value > to.rel_value)
*timeout = to;
if (pos->reason != 0)
*timeout = GNUNET_TIME_UNIT_ZERO;
pos = pos->next;
continue;
}
- if (pos->timeout.value != GNUNET_TIME_UNIT_FOREVER_ABS.value)
+ if (pos->timeout.abs_value != GNUNET_TIME_UNIT_FOREVER_ABS.abs_value)
{
to = GNUNET_TIME_absolute_get_difference (now, pos->timeout);
- if (timeout->value > to.value)
+ if (timeout->rel_value > to.rel_value)
*timeout = to;
}
if (pos->read_fd != -1)
enum GNUNET_SCHEDULER_Reason reason;
reason = task->reason;
- if (now.value >= task->timeout.value)
+ if (now.abs_value >= task->timeout.abs_value)
reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
if ( (0 == (reason & GNUNET_SCHEDULER_REASON_READ_READY)) &&
( ( (task->read_fd != -1) &&
while (pos != NULL)
{
next = pos->next;
- if (now.value >= pos->timeout.value)
+ if (now.abs_value >= pos->timeout.abs_value)
pos->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
if (0 == pos->reason)
break;
}
sched->active_task = pos;
#if PROFILE_DELAYS
- if (GNUNET_TIME_absolute_get_duration (pos->start_time).value >
- DELAY_THRESHOLD.value)
+ if (GNUNET_TIME_absolute_get_duration (pos->start_time).abs_value >
+ DELAY_THRESHOLD.abs_value)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Task %u took %llums to be scheduled\n",
pos->id,
- (unsigned long long) GNUNET_TIME_absolute_get_duration (pos->start_time).value);
+ (unsigned long long) GNUNET_TIME_absolute_get_duration (pos->start_time).abs_value);
}
#endif
tc.sched = sched;
abort ();
break;
}
- if ((ret == 0) && (timeout.value == 0) && (busy_wait_warning > 16))
+ if ((ret == 0) && (timeout.rel_value == 0) && (busy_wait_warning > 16))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_("Looks like we're busy waiting...\n"));
prev = sched->pending_timeout_last;
if (prev != NULL)
{
- if (prev->timeout.value > t->timeout.value)
+ if (prev->timeout.abs_value > t->timeout.abs_value)
prev = NULL;
else
pos = prev->next; /* heuristic success! */
pos = sched->pending_timeout;
}
while ( (pos != NULL) &&
- ( (pos->timeout.value <= t->timeout.value) ||
+ ( (pos->timeout.abs_value <= t->timeout.abs_value) ||
(pos->reason != 0) ) )
{
prev = pos;
{
const char *unit = _( /* time unit */ "ms");
char *ret;
- uint64_t dval = delta.value;
+ uint64_t dval = delta.rel_value;
- if (delta.value == GNUNET_TIME_UNIT_FOREVER_REL.value)
+ if (delta.rel_value == GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
return GNUNET_strdup (_("eternity"));
if (dval > 5 * 1000)
{
time_t tt;
char *ret;
- if (t.value == GNUNET_TIME_UNIT_FOREVER_ABS.value)
+ if (t.abs_value == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value)
return GNUNET_strdup (_("end of time"));
- tt = t.value / 1000;
+ tt = t.abs_value / 1000;
#ifdef ctime_r
ret = ctime_r (&tt, GNUNET_malloc (32));
#else
cbData->section = section;
printf ("\nSection: %s\n", section);
}
- printf ("%s = %s\n", option, value);
+ printf ("%s = %s\n", option, abs_value);
#endif
default:
break;
printf ("%d RSA encrypt/decrypt operations %llums (%d failures)\n",
ITER,
(unsigned long long)
- GNUNET_TIME_absolute_get_duration (start).value, ok);
+ GNUNET_TIME_absolute_get_duration (start).rel_value, ok);
if (ok == 0)
return GNUNET_OK;
else
printf ("%d RSA sign/verify operations %llums\n",
ITER,
(unsigned long long)
- GNUNET_TIME_absolute_get_duration (start).value);
+ GNUNET_TIME_absolute_get_duration (start).rel_value);
return ok;
}
printf ("%d RSA encrypt/decrypt operations %llums (%d failures)\n",
ITER,
(unsigned long long)
- GNUNET_TIME_absolute_get_duration (start).value, ok);
+ GNUNET_TIME_absolute_get_duration (start).rel_value, ok);
GNUNET_CRYPTO_rsa_key_free (hostkey);
if (ok == 0)
return GNUNET_OK;
printf ("%d RSA encrypt operations %llu ms (%d failures)\n",
ITER,
(unsigned long long)
- GNUNET_TIME_absolute_get_duration (start).value, ok);
+ GNUNET_TIME_absolute_get_duration (start).rel_value, ok);
GNUNET_CRYPTO_rsa_key_free (hostkey);
if (ok != 0)
return GNUNET_SYSERR;
printf ("%d RSA encrypt/decrypt SK operations %llus (%d failures)\n",
ITER,
(unsigned long long)
- GNUNET_TIME_absolute_get_duration (start).value, ok);
+ GNUNET_TIME_absolute_get_duration (start).rel_value, ok);
GNUNET_CRYPTO_rsa_key_free (hostkey);
if (ok != 0)
return GNUNET_SYSERR;
printf ("%d RSA sign/verify operations %llums\n",
ITER,
(unsigned long long)
- GNUNET_TIME_absolute_get_duration (start).value);
+ GNUNET_TIME_absolute_get_duration (start).rel_value);
GNUNET_CRYPTO_rsa_key_free (hostkey);
return ok;
}
}
printf ("%d RSA sign operations %llu ms\n", ITER,
(unsigned long long)
- GNUNET_TIME_absolute_get_duration (start).value);
+ GNUNET_TIME_absolute_get_duration (start).rel_value);
GNUNET_CRYPTO_rsa_key_free (hostkey);
return ok;
}
struct GNUNET_TIME_Absolute now;
now = GNUNET_TIME_absolute_get ();
- if (now.value > target.value)
- cumDelta += (now.value - target.value);
+ if (now.abs_value > target.abs_value)
+ cumDelta += (now.abs_value - target.abs_value);
else
- cumDelta += (target.value - now.value);
+ cumDelta += (target.abs_value - now.abs_value);
target =
GNUNET_TIME_relative_to_absolute (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MILLISECONDS, i));
WANT ("btx", b);
if (0 != GNUNET_STRINGS_buffer_tokenize (buf, 2, 2, &r, &b))
return 1;
- at.value = 5000;
+ at.abs_value = 5000;
r = GNUNET_STRINGS_absolute_time_to_string (at);
/* r should be something like "Wed Dec 31 17:00:05 1969"
where the details of the day and hour depend on the timezone;
forever = GNUNET_TIME_absolute_get_forever ();
relForever = GNUNET_TIME_relative_get_forever ();
relUnit = GNUNET_TIME_relative_get_unit ();
- zero.value = 0;
+ zero.abs_value = 0;
last = now = GNUNET_TIME_absolute_get ();
- while (now.value == last.value)
+ while (now.abs_value == last.abs_value)
now = GNUNET_TIME_absolute_get ();
- GNUNET_assert (now.value > last.value);
+ GNUNET_assert (now.abs_value > last.abs_value);
/* test overflow checking in multiply */
rel = GNUNET_TIME_UNIT_SECONDS;
for (i = 0; i < 55; i++)
rel = GNUNET_TIME_relative_multiply (rel, 2);
GNUNET_log_skip (0, GNUNET_NO);
- GNUNET_assert (rel.value == GNUNET_TIME_UNIT_FOREVER_REL.value);
+ GNUNET_assert (rel.rel_value == GNUNET_TIME_UNIT_FOREVER_REL.rel_value);
/*check zero*/
- rel.value = (UINT64_MAX) - 1024;
- GNUNET_assert (GNUNET_TIME_relative_get_zero ().value == GNUNET_TIME_relative_multiply (rel,0).value);
+ rel.rel_value = (UINT64_MAX) - 1024;
+ GNUNET_assert (GNUNET_TIME_relative_get_zero ().rel_value == GNUNET_TIME_relative_multiply (rel,0).rel_value);
/* test infinity-check for relative to absolute */
GNUNET_log_skip (1, GNUNET_NO);
last = GNUNET_TIME_relative_to_absolute (rel);
- GNUNET_assert (last.value == GNUNET_TIME_UNIT_FOREVER_ABS.value);
+ GNUNET_assert (last.abs_value == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value);
GNUNET_log_skip (0, GNUNET_YES);
/*check relative to absolute*/
- rel.value = 0;
- GNUNET_assert (GNUNET_TIME_absolute_get ().value ==
- GNUNET_TIME_relative_to_absolute(rel).value);
+ rel.rel_value = 0;
+ GNUNET_assert (GNUNET_TIME_absolute_get ().abs_value ==
+ GNUNET_TIME_relative_to_absolute(rel).abs_value);
/*check forever*/
- rel.value = UINT64_MAX;
- GNUNET_assert (GNUNET_TIME_absolute_get_forever ().value ==
- GNUNET_TIME_relative_to_absolute(rel).value);
+ rel.rel_value = UINT64_MAX;
+ GNUNET_assert (GNUNET_TIME_absolute_get_forever ().abs_value ==
+ GNUNET_TIME_relative_to_absolute(rel).abs_value);
/* check overflow for r2a */
- rel.value = (UINT64_MAX) - 1024;
+ rel.rel_value = (UINT64_MAX) - 1024;
GNUNET_log_skip (1, GNUNET_NO);
last = GNUNET_TIME_relative_to_absolute (rel);
GNUNET_log_skip (0, GNUNET_NO);
- GNUNET_assert (last.value == GNUNET_TIME_UNIT_FOREVER_ABS.value);
+ GNUNET_assert (last.abs_value == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value);
/* check overflow for relative add */
GNUNET_log_skip (1, GNUNET_NO);
rel = GNUNET_TIME_relative_add (rel, rel);
GNUNET_log_skip (0, GNUNET_NO);
- GNUNET_assert (rel.value == GNUNET_TIME_UNIT_FOREVER_REL.value);
+ GNUNET_assert (rel.rel_value == GNUNET_TIME_UNIT_FOREVER_REL.rel_value);
GNUNET_log_skip (1, GNUNET_NO);
rel = GNUNET_TIME_relative_add (relForever, relForever);
GNUNET_log_skip (0, GNUNET_NO);
- GNUNET_assert (rel.value == relForever.value);
+ GNUNET_assert (rel.rel_value == relForever.rel_value);
GNUNET_log_skip (1, GNUNET_NO);
rel = GNUNET_TIME_relative_add (relUnit, relUnit);
- GNUNET_assert (rel.value == 2 * relUnit.value);
+ GNUNET_assert (rel.rel_value == 2 * relUnit.rel_value);
/* check relation check in get_duration */
- future.value = now.value + 1000000;
- GNUNET_assert (GNUNET_TIME_absolute_get_difference (now, future).value ==
+ future.abs_value = now.abs_value + 1000000;
+ GNUNET_assert (GNUNET_TIME_absolute_get_difference (now, future).rel_value ==
1000000);
- GNUNET_assert (GNUNET_TIME_absolute_get_difference (future, now).value ==
+ GNUNET_assert (GNUNET_TIME_absolute_get_difference (future, now).rel_value ==
0);
- GNUNET_assert (GNUNET_TIME_absolute_get_difference (zero, forever).value ==
- forever.value);
+ GNUNET_assert (GNUNET_TIME_absolute_get_difference (zero, forever).rel_value ==
+ forever.abs_value);
- past.value = now.value - 1000000;
+ past.abs_value = now.abs_value - 1000000;
rel = GNUNET_TIME_absolute_get_duration (future);
- GNUNET_assert (rel.value == 0);
+ GNUNET_assert (rel.rel_value == 0);
rel = GNUNET_TIME_absolute_get_duration (past);
- GNUNET_assert (rel.value >= 1000000);
+ GNUNET_assert (rel.rel_value >= 1000000);
/* check get remaining */
rel = GNUNET_TIME_absolute_get_remaining (now);
- GNUNET_assert (rel.value == 0);
+ GNUNET_assert (rel.rel_value == 0);
rel = GNUNET_TIME_absolute_get_remaining (past);
- GNUNET_assert (rel.value == 0);
+ GNUNET_assert (rel.rel_value == 0);
rel = GNUNET_TIME_absolute_get_remaining (future);
- GNUNET_assert (rel.value > 0);
- GNUNET_assert (rel.value <= 1000000);
+ GNUNET_assert (rel.rel_value > 0);
+ GNUNET_assert (rel.rel_value <= 1000000);
forever = GNUNET_TIME_absolute_get_forever ();
- GNUNET_assert (GNUNET_TIME_relative_get_forever ().value ==
- GNUNET_TIME_absolute_get_remaining (forever).value);
+ GNUNET_assert (GNUNET_TIME_relative_get_forever ().rel_value ==
+ GNUNET_TIME_absolute_get_remaining (forever).rel_value);
/* check endianess */
reln = GNUNET_TIME_relative_hton (rel);
- GNUNET_assert (rel.value == GNUNET_TIME_relative_ntoh (reln).value);
+ GNUNET_assert (rel.rel_value == GNUNET_TIME_relative_ntoh (reln).rel_value);
nown = GNUNET_TIME_absolute_hton (now);
- GNUNET_assert (now.value == GNUNET_TIME_absolute_ntoh (nown).value);
+ GNUNET_assert (now.abs_value == GNUNET_TIME_absolute_ntoh (nown).abs_value);
/* check absolute addition */
future = GNUNET_TIME_absolute_add (now, GNUNET_TIME_UNIT_SECONDS);
- GNUNET_assert (future.value == now.value + 1000);
+ GNUNET_assert (future.abs_value == now.abs_value + 1000);
future = GNUNET_TIME_absolute_add (forever, GNUNET_TIME_UNIT_ZERO);
- GNUNET_assert (future.value == forever.value);
+ GNUNET_assert (future.abs_value == forever.abs_value);
- rel.value = (UINT64_MAX) - 1024;
- now.value = rel.value;
+ rel.rel_value = (UINT64_MAX) - 1024;
+ now.abs_value = rel.rel_value;
future = GNUNET_TIME_absolute_add (now, rel);
- GNUNET_assert (future.value == forever.value);
+ GNUNET_assert (future.abs_value == forever.abs_value);
/* check zero */
future = GNUNET_TIME_absolute_add (now, GNUNET_TIME_UNIT_ZERO);
- GNUNET_assert (future.value == now.value);
+ GNUNET_assert (future.abs_value == now.abs_value);
- GNUNET_assert (forever.value ==
+ GNUNET_assert (forever.abs_value ==
GNUNET_TIME_absolute_subtract (forever,
- GNUNET_TIME_UNIT_MINUTES).value);
+ GNUNET_TIME_UNIT_MINUTES).abs_value);
/*check absolute subtract*/
- now.value= 50000;
- rel.value = 100000;
- GNUNET_assert (GNUNET_TIME_UNIT_ZERO_ABS.value ==
- (GNUNET_TIME_absolute_subtract(now,rel)).value);
- rel.value = 10000;
+ now.abs_value= 50000;
+ rel.rel_value = 100000;
+ GNUNET_assert (GNUNET_TIME_UNIT_ZERO_ABS.abs_value ==
+ (GNUNET_TIME_absolute_subtract(now,rel)).abs_value);
+ rel.rel_value = 10000;
GNUNET_assert (40000 ==
- (GNUNET_TIME_absolute_subtract(now,rel)).value);
+ (GNUNET_TIME_absolute_subtract(now,rel)).abs_value);
/*check relative divide*/
- GNUNET_assert(GNUNET_TIME_UNIT_FOREVER_REL.value ==
- (GNUNET_TIME_relative_divide (rel,0)).value);
+ GNUNET_assert(GNUNET_TIME_UNIT_FOREVER_REL.rel_value ==
+ (GNUNET_TIME_relative_divide (rel,0)).rel_value);
rel = GNUNET_TIME_UNIT_FOREVER_REL;
- GNUNET_assert(GNUNET_TIME_UNIT_FOREVER_REL.value ==
- (GNUNET_TIME_relative_divide (rel,2)).value);
+ GNUNET_assert(GNUNET_TIME_UNIT_FOREVER_REL.rel_value ==
+ (GNUNET_TIME_relative_divide (rel,2)).rel_value);
rel = GNUNET_TIME_relative_divide (relUnit,2);
- GNUNET_assert(rel.value == relUnit.value / 2);
+ GNUNET_assert(rel.rel_value == relUnit.rel_value / 2);
/* check Return absolute time of 0ms*/
zero = GNUNET_TIME_absolute_get_zero ();
/* check GNUNET_TIME_calculate_eta */
- last.value = GNUNET_TIME_absolute_get ().value - 1024;
+ last.abs_value = GNUNET_TIME_absolute_get ().abs_value - 1024;
forever = GNUNET_TIME_absolute_get_forever ();
- forever.value = forever.value - 1024;
- GNUNET_assert(GNUNET_TIME_absolute_get_zero ().value ==
- GNUNET_TIME_calculate_eta (forever, 50000, 100000).value);
+ forever.abs_value = forever.abs_value - 1024;
+ GNUNET_assert(GNUNET_TIME_absolute_get_zero ().abs_value ==
+ GNUNET_TIME_calculate_eta (forever, 50000, 100000).rel_value);
/* check zero */
GNUNET_log_skip (1, GNUNET_NO);
- GNUNET_assert(GNUNET_TIME_UNIT_ZERO.value ==
- (GNUNET_TIME_calculate_eta (last, 60000, 50000)).value);
+ GNUNET_assert(GNUNET_TIME_UNIT_ZERO.rel_value ==
+ (GNUNET_TIME_calculate_eta (last, 60000, 50000)).rel_value);
GNUNET_log_skip (0, GNUNET_YES);
/*check forever*/
- GNUNET_assert(GNUNET_TIME_UNIT_FOREVER_REL.value ==
- (GNUNET_TIME_calculate_eta (last, 0, 50000)).value);
+ GNUNET_assert(GNUNET_TIME_UNIT_FOREVER_REL.rel_value ==
+ (GNUNET_TIME_calculate_eta (last, 0, 50000)).rel_value);
/*check relative subtract*/
now = GNUNET_TIME_absolute_get ();
- rel.value = now.value;
- relForever.value = rel.value + 1024;
+ rel.rel_value = now.abs_value;
+ relForever.rel_value = rel.rel_value + 1024;
GNUNET_assert(1024 ==
- GNUNET_TIME_relative_subtract(relForever,rel).value);
+ GNUNET_TIME_relative_subtract(relForever,rel).rel_value);
/*check zero*/
- GNUNET_assert(GNUNET_TIME_relative_get_zero ().value ==
- GNUNET_TIME_relative_subtract(rel,relForever).value);
+ GNUNET_assert(GNUNET_TIME_relative_get_zero ().rel_value ==
+ GNUNET_TIME_relative_subtract(rel,relForever).rel_value);
/*check forever*/
- rel.value = UINT64_MAX;
- GNUNET_assert(GNUNET_TIME_relative_get_forever ().value ==
- GNUNET_TIME_relative_subtract(rel,relForever).value);
+ rel.rel_value = UINT64_MAX;
+ GNUNET_assert(GNUNET_TIME_relative_get_forever ().rel_value ==
+ GNUNET_TIME_relative_subtract(rel,relForever).rel_value);
/*check GNUNET_TIME_relative_min*/
now = GNUNET_TIME_absolute_get ();
- rel.value = now.value;
- relForever.value = rel.value - 1024;
- GNUNET_assert(relForever.value == GNUNET_TIME_relative_min(rel,relForever).value);
+ rel.rel_value = now.abs_value;
+ relForever.rel_value = rel.rel_value - 1024;
+ GNUNET_assert(relForever.rel_value == GNUNET_TIME_relative_min(rel,relForever).rel_value);
/*check GNUNET_TIME_relative_max */
- GNUNET_assert(rel.value == GNUNET_TIME_relative_max(rel,relForever).value);
+ GNUNET_assert(rel.rel_value == GNUNET_TIME_relative_max(rel,relForever).rel_value);
/*check GNUNET_TIME_absolute_min*/
now = GNUNET_TIME_absolute_get ();
- last.value = now.value - 1024;
- GNUNET_assert(last.value == GNUNET_TIME_absolute_min(now,last).value);
+ last.abs_value = now.abs_value - 1024;
+ GNUNET_assert(last.abs_value == GNUNET_TIME_absolute_min(now,last).abs_value);
/*check GNUNET_TIME_absolute_max*/
- GNUNET_assert(now.value == GNUNET_TIME_absolute_max(now,last).value);
+ GNUNET_assert(now.abs_value == GNUNET_TIME_absolute_max(now,last).abs_value);
return 0;
}
struct timeval tv;
GETTIMEOFDAY (&tv, NULL);
- ret.value =
+ ret.abs_value =
(uint64_t) (((uint64_t) tv.tv_sec * 1000LL) +
((uint64_t) tv.tv_usec / 1000LL));
return ret;
GNUNET_TIME_relative_to_absolute (struct GNUNET_TIME_Relative rel)
{
struct GNUNET_TIME_Absolute ret;
- if (rel.value == UINT64_MAX)
+ if (rel.rel_value == UINT64_MAX)
return GNUNET_TIME_absolute_get_forever ();
struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
- if (rel.value + now.value < rel.value)
+ if (rel.rel_value + now.abs_value < rel.rel_value)
{
GNUNET_break (0); /* overflow... */
return GNUNET_TIME_absolute_get_forever ();
}
- ret.value = rel.value + now.value;
+ ret.abs_value = rel.rel_value + now.abs_value;
return ret;
}
GNUNET_TIME_Relative
t1, struct GNUNET_TIME_Relative t2)
{
- return (t1.value < t2.value) ? t1 : t2;
+ return (t1.rel_value < t2.rel_value) ? t1 : t2;
}
GNUNET_TIME_Relative
t1, struct GNUNET_TIME_Relative t2)
{
- return (t1.value > t2.value) ? t1 : t2;
+ return (t1.rel_value > t2.rel_value) ? t1 : t2;
}
GNUNET_TIME_Absolute
t1, struct GNUNET_TIME_Absolute t2)
{
- return (t1.value < t2.value) ? t1 : t2;
+ return (t1.abs_value < t2.abs_value) ? t1 : t2;
}
GNUNET_TIME_Absolute
t1, struct GNUNET_TIME_Absolute t2)
{
- return (t1.value > t2.value) ? t1 : t2;
+ return (t1.abs_value > t2.abs_value) ? t1 : t2;
}
GNUNET_TIME_absolute_get_remaining (struct GNUNET_TIME_Absolute future)
{
struct GNUNET_TIME_Relative ret;
- if (future.value == UINT64_MAX)
+ if (future.abs_value == UINT64_MAX)
return GNUNET_TIME_relative_get_forever ();
struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
- if (now.value > future.value)
+ if (now.abs_value > future.abs_value)
return GNUNET_TIME_relative_get_zero ();
- ret.value = future.value - now.value;
+ ret.rel_value = future.abs_value - now.abs_value;
return ret;
}
struct GNUNET_TIME_Absolute end)
{
struct GNUNET_TIME_Relative ret;
- if (end.value == UINT64_MAX)
+ if (end.abs_value == UINT64_MAX)
return GNUNET_TIME_relative_get_forever ();
- if (end.value < start.value)
+ if (end.abs_value < start.abs_value)
return GNUNET_TIME_relative_get_zero ();
- ret.value = end.value - start.value;
+ ret.rel_value = end.abs_value - start.abs_value;
return ret;
}
struct GNUNET_TIME_Relative ret;
now = GNUNET_TIME_absolute_get ();
- GNUNET_assert (hence.value != UINT64_MAX);
- if (hence.value > now.value)
+ GNUNET_assert (hence.abs_value != UINT64_MAX);
+ if (hence.abs_value > now.abs_value)
return GNUNET_TIME_relative_get_zero ();
- ret.value = now.value - hence.value;
+ ret.rel_value = now.abs_value - hence.abs_value;
return ret;
}
{
struct GNUNET_TIME_Absolute ret;
- if ((start.value == UINT64_MAX) ||
- (duration.value == UINT64_MAX))
+ if ((start.abs_value == UINT64_MAX) ||
+ (duration.rel_value == UINT64_MAX))
return GNUNET_TIME_absolute_get_forever ();
- if (start.value + duration.value < start.value)
+ if (start.abs_value + duration.rel_value < start.abs_value)
{
GNUNET_break (0);
return GNUNET_TIME_absolute_get_forever ();
}
- ret.value = start.value + duration.value;
+ ret.abs_value = start.abs_value + duration.rel_value;
return ret;
}
duration)
{
struct GNUNET_TIME_Absolute ret;
- if (start.value <= duration.value)
+ if (start.abs_value <= duration.rel_value)
return GNUNET_TIME_UNIT_ZERO_ABS;
- if (start.value == GNUNET_TIME_UNIT_FOREVER_ABS.value)
+ if (start.abs_value == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value)
return GNUNET_TIME_UNIT_FOREVER_ABS;
- ret.value = start.value - duration.value;
+ ret.abs_value = start.abs_value - duration.rel_value;
return ret;
}
struct GNUNET_TIME_Relative ret;
if (factor == 0)
return GNUNET_TIME_relative_get_zero ();
- ret.value = rel.value * (unsigned long long) factor;
- if (ret.value / factor != rel.value)
+ ret.rel_value = rel.rel_value * (unsigned long long) factor;
+ if (ret.rel_value / factor != rel.rel_value)
{
GNUNET_break (0);
return GNUNET_TIME_relative_get_forever ();
{
struct GNUNET_TIME_Relative ret;
if ( (factor == 0) ||
- (rel.value == GNUNET_TIME_UNIT_FOREVER_REL.value) )
+ (rel.rel_value == GNUNET_TIME_UNIT_FOREVER_REL.rel_value) )
return GNUNET_TIME_UNIT_FOREVER_REL;
- ret.value = rel.value / (unsigned long long) factor;
+ ret.rel_value = rel.rel_value / (unsigned long long) factor;
return ret;
}
if (finished == 0)
return GNUNET_TIME_UNIT_FOREVER_REL;
dur = GNUNET_TIME_absolute_get_duration (start);
- exp = ((double) dur.value) * ((double) total) / ((double) finished);
- ret.value = ((uint64_t) exp) - dur.value;
+ exp = ((double) dur.rel_value) * ((double) total) / ((double) finished);
+ ret.rel_value = ((uint64_t) exp) - dur.rel_value;
return ret;
}
{
struct GNUNET_TIME_Relative ret;
- if ((a1.value == UINT64_MAX) || (a2.value == UINT64_MAX))
+ if ((a1.rel_value == UINT64_MAX) || (a2.rel_value == UINT64_MAX))
return GNUNET_TIME_relative_get_forever ();
- if (a1.value + a2.value < a1.value)
+ if (a1.rel_value + a2.rel_value < a1.rel_value)
{
GNUNET_break (0);
return GNUNET_TIME_relative_get_forever ();
}
- ret.value = a1.value + a2.value;
+ ret.rel_value = a1.rel_value + a2.rel_value;
return ret;
}
{
struct GNUNET_TIME_Relative ret;
- if (a2.value >= a1.value)
+ if (a2.rel_value >= a1.rel_value)
return GNUNET_TIME_relative_get_zero ();
- if (a1.value == UINT64_MAX)
+ if (a1.rel_value == UINT64_MAX)
return GNUNET_TIME_relative_get_forever ();
- ret.value = a1.value - a2.value;
+ ret.rel_value = a1.rel_value - a2.rel_value;
return ret;
}
GNUNET_TIME_relative_hton (struct GNUNET_TIME_Relative a)
{
struct GNUNET_TIME_RelativeNBO ret;
- ret.value__ = GNUNET_htonll (a.value);
+ ret.value__ = GNUNET_htonll (a.rel_value);
return ret;
}
GNUNET_TIME_relative_ntoh (struct GNUNET_TIME_RelativeNBO a)
{
struct GNUNET_TIME_Relative ret;
- ret.value = GNUNET_ntohll (a.value__);
+ ret.rel_value = GNUNET_ntohll (a.value__);
return ret;
}
GNUNET_TIME_absolute_hton (struct GNUNET_TIME_Absolute a)
{
struct GNUNET_TIME_AbsoluteNBO ret;
- ret.value__ = GNUNET_htonll (a.value);
+ ret.value__ = GNUNET_htonll (a.abs_value);
return ret;
}
GNUNET_TIME_absolute_ntoh (struct GNUNET_TIME_AbsoluteNBO a)
{
struct GNUNET_TIME_Absolute ret;
- ret.value = GNUNET_ntohll (a.value__);
+ ret.abs_value = GNUNET_ntohll (a.value__);
return ret;
}
projects / oweals / gnunet.git / commitdiff