GNUnet  0.10.x
time.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2001-2013, 2018 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
10  GNUnet is distributed in the hope that it will be useful, but
11  WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
20 
26 #include "platform.h"
27 #include "gnunet_util_lib.h"
28 #if __STDC_NO_ATOMICS__
29 #define ATOMIC
30 #else
31 #ifdef HAVE_STDATOMIC_H
32 #include <stdatomic.h>
33 #define ATOMIC _Atomic
34 #else
35 #define __STDC_NO_ATOMICS__ 1
36 #define ATOMIC
37 #endif
38 #endif
39 
40 #define LOG(kind, ...) GNUNET_log_from(kind, "util-time", __VA_ARGS__)
41 
45 static long long timestamp_offset;
46 
52 void
53 GNUNET_TIME_set_offset(long long offset)
54 {
55  timestamp_offset = offset;
56 }
57 
58 
64 long long
66 {
67  return timestamp_offset;
68 }
69 
70 
79 int
81 {
82  if (at->abs_value_us == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us)
83  return GNUNET_OK;
84  if (0 == at->abs_value_us % 1000000)
85  return GNUNET_OK;
86  at->abs_value_us -= at->abs_value_us % 1000000;
87  return GNUNET_NO;
88 }
89 
90 
99 int
101 {
102  if (rt->rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
103  return GNUNET_OK;
104  if (0 == rt->rel_value_us % 1000000)
105  return GNUNET_OK;
106  rt->rel_value_us -= rt->rel_value_us % 1000000;
107  return GNUNET_NO;
108 }
109 
110 
119 {
120  struct GNUNET_TIME_Absolute ret;
121  struct timeval tv;
122 
123  gettimeofday(&tv, NULL);
124  ret.abs_value_us = (uint64_t)(((uint64_t)tv.tv_sec * 1000LL * 1000LL) +
125  ((uint64_t)tv.tv_usec)) +
127  return ret;
128 }
129 
130 
136 {
137  static struct GNUNET_TIME_Relative zero;
138 
139  return zero;
140 }
141 
142 
148 {
149  static struct GNUNET_TIME_Absolute zero;
150 
151  return zero;
152 }
153 
154 
160 {
161  static struct GNUNET_TIME_Relative one = { 1 };
162 
163  return one;
164 }
165 
166 
172 {
173  static struct GNUNET_TIME_Relative one = { 1000 };
174 
175  return one;
176 }
177 
178 
184 {
185  static struct GNUNET_TIME_Relative one = { 1000 * 1000LL };
186 
187  return one;
188 }
189 
190 
196 {
197  static struct GNUNET_TIME_Relative one = { 60 * 1000 * 1000LL };
198 
199  return one;
200 }
201 
202 
208 {
209  static struct GNUNET_TIME_Relative one = { 60 * 60 * 1000 * 1000LL };
210 
211  return one;
212 }
213 
214 
220 {
221  static struct GNUNET_TIME_Relative forever = { UINT64_MAX };
222 
223  return forever;
224 }
225 
226 
232 {
233  static struct GNUNET_TIME_Absolute forever = { UINT64_MAX };
234 
235  return forever;
236 }
237 
238 
247 {
248  struct GNUNET_TIME_Absolute ret;
249 
250  if (rel.rel_value_us == UINT64_MAX)
253 
254  if (rel.rel_value_us + now.abs_value_us < rel.rel_value_us)
255  {
256  GNUNET_break(0); /* overflow... */
258  }
259  ret.abs_value_us = rel.rel_value_us + now.abs_value_us;
260  return ret;
261 }
262 
263 
273  struct GNUNET_TIME_Relative t2)
274 {
275  return (t1.rel_value_us < t2.rel_value_us) ? t1 : t2;
276 }
277 
278 
288  struct GNUNET_TIME_Relative t2)
289 {
290  return (t1.rel_value_us > t2.rel_value_us) ? t1 : t2;
291 }
292 
293 
303  struct GNUNET_TIME_Absolute t2)
304 {
305  return (t1.abs_value_us < t2.abs_value_us) ? t1 : t2;
306 }
307 
308 
318  struct GNUNET_TIME_Absolute t2)
319 {
320  return (t1.abs_value_us > t2.abs_value_us) ? t1 : t2;
321 }
322 
323 
332 {
333  struct GNUNET_TIME_Relative ret;
334 
335  if (future.abs_value_us == UINT64_MAX)
338 
339  if (now.abs_value_us > future.abs_value_us)
340  return GNUNET_TIME_UNIT_ZERO;
341  ret.rel_value_us = future.abs_value_us - now.abs_value_us;
342  return ret;
343 }
344 
354  struct GNUNET_TIME_Absolute end)
355 {
356  struct GNUNET_TIME_Relative ret;
357 
358  if (end.abs_value_us == UINT64_MAX)
360  if (end.abs_value_us < start.abs_value_us)
361  return GNUNET_TIME_UNIT_ZERO;
362  ret.rel_value_us = end.abs_value_us - start.abs_value_us;
363  return ret;
364 }
365 
374 {
375  struct GNUNET_TIME_Absolute now;
376  struct GNUNET_TIME_Relative ret;
377 
378  now = GNUNET_TIME_absolute_get();
379  if (whence.abs_value_us > now.abs_value_us)
380  return GNUNET_TIME_UNIT_ZERO;
381  ret.rel_value_us = now.abs_value_us - whence.abs_value_us;
382  return ret;
383 }
384 
385 
395 {
396  struct GNUNET_TIME_Absolute ret;
397 
398  if ((start.abs_value_us == UINT64_MAX) ||
399  (duration.rel_value_us == UINT64_MAX))
401  if (start.abs_value_us + duration.rel_value_us < start.abs_value_us)
402  {
403  GNUNET_break(0);
405  }
406  ret.abs_value_us = start.abs_value_us + duration.rel_value_us;
407  return ret;
408 }
409 
410 
422 {
423  struct GNUNET_TIME_Absolute ret;
424 
425  if (start.abs_value_us <= duration.rel_value_us)
427  if (start.abs_value_us == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us)
429  ret.abs_value_us = start.abs_value_us - duration.rel_value_us;
430  return ret;
431 }
432 
433 
441  unsigned long long factor)
442 {
443  struct GNUNET_TIME_Relative ret;
444 
445  if (0 == factor)
446  return GNUNET_TIME_UNIT_ZERO;
447  if (rel.rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
449  ret.rel_value_us = rel.rel_value_us * factor;
450  if (ret.rel_value_us / factor != rel.rel_value_us)
451  {
452  GNUNET_break(0);
454  }
455  return ret;
456 }
457 
458 
467 {
468  struct GNUNET_TIME_Relative out;
469  double m;
470 
471  GNUNET_assert(0 <= factor);
472 
473  if (0 == factor)
474  return GNUNET_TIME_UNIT_ZERO;
475  if (rel.rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
477 
478  m = ((double)rel.rel_value_us) * factor;
479 
480  if (m >= (double)(GNUNET_TIME_UNIT_FOREVER_REL).rel_value_us)
481  {
482  GNUNET_break(0);
484  }
485 
486  out.rel_value_us = (uint64_t)m;
487  return out;
488 }
489 
490 
500  unsigned long long factor)
501 {
502  struct GNUNET_TIME_Relative ret;
503 
504  if (0 == factor)
505  return GNUNET_TIME_UNIT_ZERO;
506  if (rel.rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
508  ret.rel_value_us = rel.rel_value_us * factor;
509  if (ret.rel_value_us / factor != rel.rel_value_us)
510  {
512  }
513  return ret;
514 }
515 
516 
526  unsigned long long factor)
527 {
528  struct GNUNET_TIME_Relative ret;
529 
530  if ((0 == factor) ||
531  (rel.rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us))
533  ret.rel_value_us = rel.rel_value_us / factor;
534  return ret;
535 }
536 
537 
550  uint64_t finished,
551  uint64_t total)
552 {
553  struct GNUNET_TIME_Relative dur;
554  double exp;
555  struct GNUNET_TIME_Relative ret;
556 
557  GNUNET_break(finished <= total);
558  if (finished >= total)
559  return GNUNET_TIME_UNIT_ZERO;
560  if (0 == finished)
563  exp = ((double)dur.rel_value_us) * ((double)total) / ((double)finished);
564  ret.rel_value_us = ((uint64_t)exp) - dur.rel_value_us;
565  return ret;
566 }
567 
568 
578  struct GNUNET_TIME_Relative a2)
579 {
580  struct GNUNET_TIME_Relative ret;
581 
582  if ((a1.rel_value_us == UINT64_MAX) || (a2.rel_value_us == UINT64_MAX))
584  if (a1.rel_value_us + a2.rel_value_us < a1.rel_value_us)
585  {
586  GNUNET_break(0);
588  }
589  ret.rel_value_us = a1.rel_value_us + a2.rel_value_us;
590  return ret;
591 }
592 
593 
603  struct GNUNET_TIME_Relative a2)
604 {
605  struct GNUNET_TIME_Relative ret;
606 
607  if (a2.rel_value_us >= a1.rel_value_us)
608  return GNUNET_TIME_UNIT_ZERO;
609  if (a1.rel_value_us == UINT64_MAX)
611  ret.rel_value_us = a1.rel_value_us - a2.rel_value_us;
612  return ret;
613 }
614 
615 
624 {
625  struct GNUNET_TIME_RelativeNBO ret;
626 
627  ret.rel_value_us__ = GNUNET_htonll(a.rel_value_us);
628  return ret;
629 }
630 
631 
640 {
641  struct GNUNET_TIME_Relative ret;
642 
643  ret.rel_value_us = GNUNET_ntohll(a.rel_value_us__);
644  return ret;
645 }
646 
647 
656 {
657  struct GNUNET_TIME_AbsoluteNBO ret;
658 
659  ret.abs_value_us__ = GNUNET_htonll(a.abs_value_us);
660  return ret;
661 }
662 
663 
672 {
673  struct GNUNET_TIME_Absolute ret;
674 
675  ret.abs_value_us = GNUNET_ntohll(a.abs_value_us__);
676  return ret;
677 }
678 
679 
683 unsigned int
685 {
686  time_t tp;
687  struct tm *t;
688 
689  tp = time(NULL);
690  t = gmtime(&tp);
691  if (t == NULL)
692  return 0;
693  return t->tm_year + 1900;
694 }
695 
696 
703 unsigned int
705 {
706  struct tm *t;
707  time_t tp;
708 
709  tp = at.abs_value_us / 1000LL / 1000LL; /* microseconds to seconds */
710  t = gmtime(&tp);
711  if (t == NULL)
712  return 0;
713  return t->tm_year + 1900;
714 }
715 
716 
724 GNUNET_TIME_year_to_time(unsigned int year)
725 {
726  struct GNUNET_TIME_Absolute ret;
727  time_t tp;
728  struct tm t;
729 
730  memset(&t, 0, sizeof(t));
731  if (year < 1900)
732  {
733  GNUNET_break(0);
734  return GNUNET_TIME_absolute_get(); /* now */
735  }
736  t.tm_year = year - 1900;
737  t.tm_mday = 1;
738  t.tm_mon = 0;
739  t.tm_wday = 1;
740  t.tm_yday = 1;
741  tp = mktime(&t);
742  GNUNET_break(tp != (time_t)-1);
743  ret.abs_value_us = tp * 1000LL * 1000LL; /* seconds to microseconds */
744  return ret;
745 }
746 
747 
760 {
761  double r = (rand() % 500) / 1000.0;
762  struct GNUNET_TIME_Relative t;
763 
766  2 + r);
768 }
769 
770 
779 {
780  double d = ((rand() % 1001) - 500) / 1000.0;
781 
782  return relative_multiply_double(r, d);
783 }
784 
785 
806  const struct GNUNET_CONFIGURATION_Handle *cfg)
807 {
808  static const struct GNUNET_CONFIGURATION_Handle *last_cfg;
809  static struct GNUNET_TIME_Absolute last_time;
810  static struct GNUNET_DISK_MapHandle *map_handle;
811  static ATOMIC volatile uint64_t *map;
812  struct GNUNET_TIME_Absolute now;
813 
814  now = GNUNET_TIME_absolute_get();
815  if (last_cfg != cfg)
816  {
817  char *filename;
818 
819  if (NULL != map_handle)
820  {
821  GNUNET_DISK_file_unmap(map_handle);
822  map_handle = NULL;
823  }
824  map = NULL;
825 
826  last_cfg = cfg;
827  if ((NULL != cfg) &&
828  (GNUNET_OK ==
830  "util",
831  "MONOTONIC_TIME_FILENAME",
832  &filename)))
833  {
834  struct GNUNET_DISK_FileHandle *fh;
835 
836  fh = GNUNET_DISK_file_open(filename,
843  if (NULL == fh)
844  {
846  _("Failed to map `%s', cannot assure monotonic time!\n"),
847  filename);
848  }
849  else
850  {
851  off_t size;
852 
853  size = 0;
855  if (size < (off_t)sizeof(*map))
856  {
857  struct GNUNET_TIME_AbsoluteNBO o;
858 
859  o = GNUNET_TIME_absolute_hton(now);
860  if (sizeof(o) != GNUNET_DISK_file_write(fh, &o, sizeof(o)))
861  size = 0;
862  else
863  size = sizeof(o);
864  }
865  if (size == sizeof(*map))
866  {
867  map = GNUNET_DISK_file_map(fh,
868  &map_handle,
870  sizeof(*map));
871  if (NULL == map)
873  _(
874  "Failed to map `%s', cannot assure monotonic time!\n"),
875  filename);
876  }
877  else
878  {
879  GNUNET_log(
881  _(
882  "Failed to setup monotonic time file `%s', cannot assure monotonic time!\n"),
883  filename);
884  }
885  }
887  GNUNET_free(filename);
888  }
889  }
890  if (NULL != map)
891  {
892  struct GNUNET_TIME_AbsoluteNBO mt;
893 
894 #if __STDC_NO_ATOMICS__
895 #if __GNUC__
896  mt.abs_value_us__ = __sync_fetch_and_or(map, 0);
897 #else
898  mt.abs_value_us__ = *map; /* godspeed, pray this is atomic */
899 #endif
900 #else
901  mt.abs_value_us__ = atomic_load(map);
902 #endif
903  last_time =
905  }
906  if (now.abs_value_us <= last_time.abs_value_us)
907  now.abs_value_us = last_time.abs_value_us + 1;
908  last_time = now;
909  if (NULL != map)
910  {
911  uint64_t val = GNUNET_TIME_absolute_hton(now).abs_value_us__;
912 #if __STDC_NO_ATOMICS__
913 #if __GNUC__
914  (void)__sync_lock_test_and_set(map, val);
915 #else
916  *map = val; /* godspeed, pray this is atomic */
917 #endif
918 #else
919  atomic_store(map, val);
920 #endif
921  }
922  return now;
923 }
924 
925 
929 void __attribute__ ((destructor)) GNUNET_util_time_fini()
930 {
932 }
933 
934 /* end of time.c */
static const struct GNUNET_CRYPTO_EcdsaPrivateKey zero
Public key of all zeros.
struct GNUNET_TIME_Absolute GNUNET_TIME_year_to_time(unsigned int year)
Convert a year to an expiration time of January 1st of that year.
Definition: time.c:724
static unsigned int threshold
What should the threshold for then key be?
Create file if it doesn&#39;t exist.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_subtract(struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Relative duration)
Subtract a given relative duration from the given start time.
Definition: time.c:420
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:671
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1339
#define GNUNET_TIME_UNIT_ZERO_ABS
Absolute time zero.
uint64_t rel_value_us
The actual value.
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:34
struct GNUNET_TIME_Relative GNUNET_TIME_relative_get_hour_()
Return relative time of 1 hour.
Definition: time.c:207
static long long timestamp_offset
Variable used to simulate clock skew.
Definition: time.c:45
struct GNUNET_TIME_Relative GNUNET_TIME_relative_max(struct GNUNET_TIME_Relative t1, struct GNUNET_TIME_Relative t2)
Return the maximum of two relative time values.
Definition: time.c:287
Read-write memory map.
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:39
struct GNUNET_TIME_Relative GNUNET_TIME_relative_get_unit_()
Return relative time of 1us.
Definition: time.c:159
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:246
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
void * GNUNET_DISK_file_map(const struct GNUNET_DISK_FileHandle *h, struct GNUNET_DISK_MapHandle **m, enum GNUNET_DISK_MapType access, size_t len)
Map a file into memory.
Definition: disk.c:1433
uint64_t rel_value_us__
The actual value (in network byte order).
struct GNUNET_TIME_Relative GNUNET_TIME_relative_get_millisecond_()
Return relative time of 1ms.
Definition: time.c:171
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_add(struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Relative duration)
Add a given relative duration to the given start time.
Definition: time.c:393
struct GNUNET_TIME_Relative relative_multiply_double(struct GNUNET_TIME_Relative rel, double factor)
Multiply relative time by a given floating-point factor.
Definition: time.c:466
Time for relative time used by GNUnet, in microseconds and in network byte order. ...
static struct GNUNET_SCHEDULER_Task * t
Main task.
void GNUNET_TIME_set_offset(long long offset)
Set the timestamp offset for this instance.
Definition: time.c:53
static int ret
Final status code.
Definition: gnunet-arm.c:89
Time for absolute time used by GNUnet, in microseconds and in network byte order. ...
uint64_t abs_value_us
The actual value.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_CONTAINER_MultiPeerMap * map
Handle to the map used to store old latency values for peers.
void __attribute__((destructor))
Destructor.
Definition: time.c:929
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static struct GNUNET_ARM_MonitorHandle * m
Monitor connection with ARM.
Definition: gnunet-arm.c:99
struct GNUNET_TIME_Relative GNUNET_TIME_relative_get_forever_()
Return "forever".
Definition: time.c:219
int GNUNET_TIME_round_abs(struct GNUNET_TIME_Absolute *at)
Round a time value so that it is suitable for transmission via JSON encodings.
Definition: time.c:80
struct GNUNET_TIME_Relative GNUNET_TIME_relative_get_zero_()
Return relative time of 0ms.
Definition: time.c:135
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get_forever_()
Return "forever".
Definition: time.c:231
ssize_t GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: disk.c:817
struct GNUNET_TIME_Relative GNUNET_TIME_relative_get_minute_()
Return relative time of 1 minute.
Definition: time.c:195
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_max(struct GNUNET_TIME_Absolute t1, struct GNUNET_TIME_Absolute t2)
Return the maximum of two relative time values.
Definition: time.c:317
static char * filename
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get_zero_()
Return absolute time of 0ms.
Definition: time.c:147
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:440
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
struct GNUNET_TIME_Relative GNUNET_TIME_randomize(struct GNUNET_TIME_Relative r)
Return a random time value between 0.5*r and 1.5*r.
Definition: time.c:778
static int fh
Handle to the unique file.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_subtract(struct GNUNET_TIME_Relative a1, struct GNUNET_TIME_Relative a2)
Subtract relative timestamp from the other.
Definition: time.c:602
#define ATOMIC
Definition: time.c:36
struct GNUNET_TIME_Relative GNUNET_TIME_relative_ntoh(struct GNUNET_TIME_RelativeNBO a)
Convert relative time from network byte order.
Definition: time.c:639
#define GNUNET_TIME_UNIT_MILLISECONDS
One millisecond.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get()
Get the current time (works just as "time", just that we use the unit of time that the cron-jobs use ...
Definition: time.c:118
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:104
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:35
struct GNUNET_TIME_Relative GNUNET_TIME_relative_min(struct GNUNET_TIME_Relative t1, struct GNUNET_TIME_Relative t2)
Return the minimum of two relative time values.
Definition: time.c:272
static unsigned int size
Size of the "table".
Definition: peer.c:66
struct GNUNET_TIME_RelativeNBO GNUNET_TIME_relative_hton(struct GNUNET_TIME_Relative a)
Convert relative time to network byte order.
Definition: time.c:623
int GNUNET_DISK_file_unmap(struct GNUNET_DISK_MapHandle *h)
Unmap a file.
Definition: disk.c:1469
int GNUNET_TIME_round_rel(struct GNUNET_TIME_Relative *rt)
Round a time value so that it is suitable for transmission via JSON encodings.
Definition: time.c:100
long long GNUNET_TIME_get_offset()
Get the timestamp offset for this instance.
Definition: time.c:65
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get_monotonic(const struct GNUNET_CONFIGURATION_Handle *cfg)
Obtain the current time and make sure it is monotonically increasing.
Definition: time.c:805
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_add(struct GNUNET_TIME_Relative a1, struct GNUNET_TIME_Relative a2)
Add relative times together.
Definition: time.c:577
struct GNUNET_TIME_Relative GNUNET_TIME_relative_get_second_()
Return relative time of 1s.
Definition: time.c:183
unsigned int GNUNET_TIME_get_current_year()
Return the current year (i.e.
Definition: time.c:684
configuration data
Definition: configuration.c:83
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_min(struct GNUNET_TIME_Absolute t1, struct GNUNET_TIME_Absolute t2)
Return the minimum of two relative time values.
Definition: time.c:302
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "when...
Definition: time.c:373
uint64_t abs_value_us__
The actual value (in network byte order).
int GNUNET_DISK_file_handle_size(struct GNUNET_DISK_FileHandle *fh, off_t *size)
Get the size of an open file.
Definition: disk.c:203
#define GNUNET_log(kind,...)
Open the file for both reading and writing.
int GNUNET_CONFIGURATION_get_value_filename(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be the name of a file or directory.
static struct GNUNET_TIME_Relative duration
How long do we run the test?
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:331
struct GNUNET_TIME_Relative GNUNET_TIME_calculate_eta(struct GNUNET_TIME_Absolute start, uint64_t finished, uint64_t total)
Calculate the estimate time of arrival/completion for an operation.
Definition: time.c:549
struct GNUNET_TIME_Relative GNUNET_TIME_relative_divide(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Divide relative time by a given factor.
Definition: time.c:525
Time for absolute times used by GNUnet, in microseconds.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_difference(struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Absolute end)
Compute the time difference between the given start and end times.
Definition: time.c:353
unsigned int GNUNET_TIME_time_to_year(struct GNUNET_TIME_Absolute at)
Convert an expiration time to the respective year (rounds)
Definition: time.c:704
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition: disk.c:1262
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:655
Handle used to access files (and pipes).
struct GNUNET_TIME_Relative GNUNET_TIME_relative_saturating_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Saturating multiply relative time by a given factor.
Definition: time.c:499
struct GNUNET_TIME_Relative GNUNET_TIME_randomized_backoff(struct GNUNET_TIME_Relative rt, struct GNUNET_TIME_Relative threshold)
Randomized exponential back-off, starting at 1 ms and going up by a factor of 2+r, where 0 <= r <= 0.5, up to a maximum of the given threshold.
Definition: time.c:758
Handle for a memory-mapping operation.
Definition: disk.c:1406
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:48
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.