GNUnet  0.11.x
gnunet-service-fs_pe.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2011 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-service-fs.h"
28 #include "gnunet-service-fs_cp.h"
29 #include "gnunet-service-fs_pe.h"
30 #include "gnunet-service-fs_pr.h"
31 
35 #define INSANE_STATISTICS GNUNET_NO
36 
41 struct PendingRequestList;
42 
46 struct PeerPlan;
47 
48 
67 {
72 
77 
82 
87 
93 
99 };
100 
101 
109 {
114 
119 
124 
128  struct PeerPlan *pp;
129 
136 
141 
145  struct GNUNET_TIME_Absolute earliest_transmission;
146 
151 
155  uint64_t priority;
156 
160  unsigned int transmission_counter;
161 };
162 
163 
167 struct PeerPlan
168 {
173 
178 
186 
191 
196 
201 };
202 
203 
208 
212 static unsigned long long total_delay;
213 
217 static unsigned long long plan_count;
218 
219 
232 static const struct GNUNET_HashCode *
234 {
236 }
237 
238 
245 static void
246 plan (struct PeerPlan *pp,
247  struct GSF_RequestPlan *rp)
248 {
249 #define N ((double) 128.0)
250 
253  static double avg_delay;
254 
255  struct GSF_PendingRequestData *prd;
256  struct GNUNET_TIME_Relative delay;
257 
258  GNUNET_assert (rp->pp == pp);
260  gettext_noop ("# average retransmission delay (ms)"),
261  total_delay * 1000LL / plan_count, GNUNET_NO);
263 
264  if (rp->transmission_counter < 8)
265  delay =
268  else if (rp->transmission_counter < 32)
269  delay =
271  8
272  + (1LL << (rp->transmission_counter - 8)));
273  else
274  delay =
276  8 + (1LL << 24));
277  delay.rel_value_us =
279  delay.rel_value_us + 1);
280  /* Add 0.01 to avg_delay to avoid division-by-zero later */
281  avg_delay = (((avg_delay * (N - 1.0)) + delay.rel_value_us) / N) + 0.01;
282 
283  /*
284  * For the priority, we need to consider a few basic rules:
285  * 1) if we just started requesting (delay is small), we should
286  * virtually always have a priority of zero.
287  * 2) for requests with average latency, our priority should match
288  * the average priority observed on the network
289  * 3) even the longest-running requests should not be WAY out of
290  * the observed average (thus we bound by a factor of 2)
291  * 4) we add +1 to the observed average priority to avoid everyone
292  * staying put at zero (2 * 0 = 0...).
293  *
294  * Using the specific calculation below, we get:
295  *
296  * delay = 0 => priority = 0;
297  * delay = avg delay => priority = running-average-observed-priority;
298  * delay >> avg_delay => priority = 2 * running-average-observed-priority;
299  *
300  * which satisfies all of the rules above.
301  *
302  * Note: M_PI_4 = PI/4 = arctan(1)
303  */rp->priority =
304  round ((GSF_current_priorities
305  + 1.0) * atan (delay.rel_value_us / avg_delay)) / M_PI_4;
306  /* Note: usage of 'round' and 'atan' requires -lm */
307 
308  if (rp->transmission_counter != 0)
309  delay.rel_value_us += TTL_DECREMENT * 1000;
311  "Considering (re)transmission number %u in %s\n",
312  (unsigned int) rp->transmission_counter,
314  GNUNET_YES));
317  "Earliest (re)transmission for `%s' in %us\n",
318  GNUNET_h2s (&prd->query),
320  GNUNET_assert (rp->hn == NULL);
324  rp,
325  rp->priority);
326  else
327  rp->hn =
329  rp,
333  get_rp_key (rp),
334  rp));
335 #undef N
336 }
337 
338 
345 struct GSF_PendingRequest *
347 {
348  struct GSF_PendingRequest *ret;
350  const struct GSF_PendingRequestData *rprd;
351  const struct GSF_PendingRequestData *prd;
352 
353  bi = rp->pe_head;
354  if (NULL == bi)
355  return NULL; /* should never happen */
356  ret = bi->pr;
357  rprd = GSF_pending_request_get_data_ (ret);
358  for (bi = bi->next_PE; NULL != bi; bi = bi->next_PE)
359  {
362  prd = GSF_pending_request_get_data_ (bi->pr);
363  if (prd->ttl.abs_value_us > rprd->ttl.abs_value_us)
364  {
365  ret = bi->pr;
366  rprd = prd;
367  }
368  }
369  return ret;
370 }
371 
372 
378 static void
380 {
381  struct PeerPlan *pp = cls;
382  struct GSF_RequestPlan *rp;
383  struct GNUNET_TIME_Relative delay;
384 
385  if (NULL != pp->task)
386  {
387  pp->task = NULL;
388  }
389  else
390  {
391  GNUNET_assert (NULL != pp->env);
392  pp->env = NULL;
393  }
394  /* move ready requests to priority queue */
395  while ((NULL != (rp = GNUNET_CONTAINER_heap_peek (pp->delay_heap))) &&
398  {
401  rp,
402  rp->priority);
403  }
405  {
406  /* priority heap (still) empty, check for delay... */
408  if (NULL == rp)
409  {
411  "No active requests for plan %p.\n",
412  pp);
413  return; /* both queues empty */
414  }
417  "Sleeping for %s before retrying requests on plan %p.\n",
419  GNUNET_YES),
420  pp);
422  gettext_noop ("# delay heap timeout (ms)"),
423  delay.rel_value_us / 1000LL, GNUNET_NO);
424 
425  pp->task
428  pp);
429  return;
430  }
431 #if INSANE_STATISTICS
433  gettext_noop ("# query plans executed"),
434  1,
435  GNUNET_NO);
436 #endif
437  /* process from priority heap */
440  "Executing query plan %p\n",
441  rp);
442  GNUNET_assert (NULL != rp);
443  rp->hn = NULL;
445  rp->transmission_counter++;
446  total_delay++;
448  "Executing plan %p executed %u times, planning retransmission\n",
449  rp,
451  GNUNET_assert (NULL == pp->env);
455  pp);
456  GSF_peer_transmit_ (pp->cp,
457  GNUNET_YES,
458  rp->priority,
459  pp->env);
461  gettext_noop (
462  "# query messages sent to other peers"),
463  1,
464  GNUNET_NO);
465  plan (pp,
466  rp);
467 }
468 
469 
474 {
479 
483  int merged;
484 };
485 
486 
497 static int
498 merge_pr (void *cls,
499  const struct GNUNET_HashCode *query,
500  void *element)
501 {
502  struct MergeContext *mpr = cls;
503  struct GSF_RequestPlan *rp = element;
504  struct GSF_PendingRequestData *prd;
506  struct GSF_PendingRequest *latest;
507 
510  if (GNUNET_OK !=
512  rp->pe_head->pr))
513  return GNUNET_YES;
514  /* merge new request with existing request plan */
516  bi->rp = rp;
517  bi->pr = mpr->pr;
518  prd = GSF_pending_request_get_data_ (mpr->pr);
520  prd->pr_head,
521  prd->pr_tail,
522  bi);
524  rp->pe_head,
525  rp->pe_tail,
526  bi);
527  mpr->merged = GNUNET_YES;
528 #if INSANE_STATISTICS
530  gettext_noop ("# requests merged"),
531  1,
532  GNUNET_NO);
533 #endif
534  latest = get_latest (rp);
535  if (GSF_pending_request_get_data_ (latest)->ttl.abs_value_us <
536  prd->ttl.abs_value_us)
537  {
538 #if INSANE_STATISTICS
540  gettext_noop ("# requests refreshed"),
541  1,
542  GNUNET_NO);
543 #endif
544  rp->transmission_counter = 0; /* reset */
545  }
546  return GNUNET_NO;
547 }
548 
549 
556 void
558  struct GSF_PendingRequest *pr)
559 {
560  const struct GNUNET_PeerIdentity *id;
561  struct PeerPlan *pp;
562  struct GSF_PendingRequestData *prd;
563  struct GSF_RequestPlan *rp;
565  struct MergeContext mpc;
566 
569  GNUNET_assert (NULL != cp);
571  pp = GNUNET_CONTAINER_multipeermap_get (plans, id);
572  if (NULL == pp)
573  {
574  pp = GNUNET_new (struct PeerPlan);
576  pp->priority_heap =
578  pp->delay_heap =
580  pp->cp = cp;
583  id,
584  pp,
587  pp);
588  }
589  mpc.merged = GNUNET_NO;
590  mpc.pr = pr;
593  &prd->query,
594  &merge_pr,
595  &mpc);
596  if (GNUNET_NO != mpc.merged)
597  return;
598  plan_count++;
600  gettext_noop ("# query plan entries"),
601  1,
602  GNUNET_NO);
604  "Planning transmission of query `%s' to peer `%s'\n",
605  GNUNET_h2s (&prd->query),
606  GNUNET_i2s (id));
607  rp = GNUNET_new (struct GSF_RequestPlan);
609  bi->rp = rp;
610  bi->pr = pr;
612  prd->pr_head,
613  prd->pr_tail,
614  bi);
616  rp->pe_head,
617  rp->pe_tail,
618  bi);
619  rp->pp = pp;
622  get_rp_key (rp),
623  rp,
625  plan (pp,
626  rp);
627 }
628 
629 
636 void
638 {
639  const struct GNUNET_PeerIdentity *id;
640  struct PeerPlan *pp;
641  struct GSF_RequestPlan *rp;
642  struct GSF_PendingRequestData *prd;
644 
646  pp = GNUNET_CONTAINER_multipeermap_get (plans, id);
647  if (NULL == pp)
648  return; /* nothing was ever planned for this peer */
651  pp));
652  if (NULL != pp->task)
653  {
655  pp->task = NULL;
656  }
657  while (NULL != (rp = GNUNET_CONTAINER_heap_remove_root (pp->priority_heap)))
658  {
661  get_rp_key (rp),
662  rp));
663  while (NULL != (bi = rp->pe_head))
664  {
666  rp->pe_head,
667  rp->pe_tail,
668  bi);
669  prd = GSF_pending_request_get_data_ (bi->pr);
671  prd->pr_head,
672  prd->pr_tail,
673  bi);
674  GNUNET_free (bi);
675  }
676  plan_count--;
677  GNUNET_free (rp);
678  }
680  while (NULL != (rp = GNUNET_CONTAINER_heap_remove_root (pp->delay_heap)))
681  {
684  get_rp_key (rp),
685  rp));
686  while (NULL != (bi = rp->pe_head))
687  {
688  prd = GSF_pending_request_get_data_ (bi->pr);
690  rp->pe_head,
691  rp->pe_tail,
692  bi);
694  prd->pr_head,
695  prd->pr_tail,
696  bi);
697  GNUNET_free (bi);
698  }
699  plan_count--;
700  GNUNET_free (rp);
701  }
703  gettext_noop ("# query plan entries"),
704  plan_count,
705  GNUNET_NO);
708  GNUNET_free (pp);
709 }
710 
711 
721 int
724  *pr_head,
725  struct GSF_ConnectedPeer *
726  sender,
727  struct GNUNET_TIME_Absolute *
728  result)
729 {
731 
732  for (bi = pr_head; NULL != bi; bi = bi->next_PR)
733  {
734  if (bi->rp->pp->cp == sender)
735  {
736  if (0 == bi->rp->last_transmission.abs_value_us)
738  else
739  *result = bi->rp->last_transmission;
740  return GNUNET_YES;
741  }
742  }
743  return GNUNET_NO;
744 }
745 
746 
753 void
755 {
756  struct GSF_RequestPlan *rp;
757  struct GSF_PendingRequestData *prd;
759 
761  while (NULL != (bi = prd->pr_head))
762  {
763  rp = bi->rp;
765  prd->pr_head,
766  prd->pr_tail,
767  bi);
769  rp->pe_head,
770  rp->pe_tail,
771  bi);
772  GNUNET_assert (bi->pr == pr);
773  if (NULL == rp->pe_head)
774  {
776  plan_count--;
779  &prd->query,
780  rp));
781  GNUNET_free (rp);
782  }
783  GNUNET_free (bi);
784  }
786  gettext_noop ("# query plan entries"),
787  plan_count,
788  GNUNET_NO);
789 }
790 
791 
795 void
797 {
799  GNUNET_YES);
800 }
801 
802 
806 void
808 {
811 }
812 
813 
814 /* end of gnunet-service-fs_pe.h */
API to handle &#39;connected peers&#39;.
Closure for merge_pr().
void GSF_plan_add_(struct GSF_ConnectedPeer *cp, struct GSF_PendingRequest *pr)
Create a new query plan entry.
uint64_t rel_value_us
The actual value.
static unsigned long long total_delay
Sum of all transmission counters (equals total delay for all plan entries).
void GSF_plan_done()
Shutdown plan subsystem.
int GSF_request_plan_reference_get_last_transmission_(struct GSF_PendingRequestPlanBijection *pr_head, struct GSF_ConnectedPeer *sender, struct GNUNET_TIME_Absolute *result)
Get the last transmission attempt time for the request plan list referenced by pr_head, that was sent to sender.
struct GSF_RequestPlan * next
This is a doubly-linked list.
static GNUNET_CronTime last_transmission
struct GNUNET_CONTAINER_MultiHashMap * plan_map
Map of queries to plan entries.
struct GSF_PendingRequestPlanBijection * next_PE
This is a doubly-linked list.
struct GNUNET_CONTAINER_HeapNode * GNUNET_CONTAINER_heap_insert(struct GNUNET_CONTAINER_Heap *heap, void *element, GNUNET_CONTAINER_HeapCostType cost)
Inserts a new element into the heap.
double GSF_current_priorities
Typical priorities we&#39;re seeing from other peers right now.
struct GNUNET_TIME_Absolute ttl
Current TTL for the request.
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
Transmission plan for a peer.
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
void GSF_peer_transmit_(struct GSF_ConnectedPeer *cp, int is_query, uint32_t priority, struct GNUNET_MQ_Envelope *env)
Transmit a message to the given peer as soon as possible.
#define GNUNET_TIME_UNIT_SECONDS
One second.
struct GNUNET_MQ_Envelope * env
Current message under transmission for the plan.
static unsigned long long plan_count
Number of plan entries.
struct GSF_PendingRequestPlanBijection * pr_head
Fields for the plan module to track a DLL with the request.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
struct GNUNET_STATISTICS_Handle * GSF_stats
Handle for reporting statistics.
int GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Remove the given key-value pair from the map.
#define GNUNET_NO
Definition: gnunet_common.h:78
shared data structures of gnunet-service-fs.c
struct GSF_PendingRequestPlanBijection * next_PR
This is a doubly-linked list.
static struct GNUNET_IDENTITY_Handle * id
Handle to identity service.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_new(type)
Allocate a struct or union of the given type.
int GSF_pending_request_is_compatible_(struct GSF_PendingRequest *pra, struct GSF_PendingRequest *prb)
Test if two pending requests are compatible (would generate the same query modulo filters and should ...
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
struct GNUNET_CONTAINER_MultiPeerMap * GNUNET_CONTAINER_multipeermap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
static const struct GNUNET_HashCode * get_rp_key(struct GSF_RequestPlan *rp)
Return the query (key in the plan_map) for the given request plan.
#define N
uint64_t abs_value_us
The actual value.
Internal representation of the hash map.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
struct GSF_ConnectedPeer * cp
Peer for which this is the plan.
struct GSF_RequestPlan * rp
Associated request plan (tells us one of the peers that we plan to forward the request to)...
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
struct GNUNET_HashCode query
Primary query hash for this request.
struct GSF_PendingRequestPlanBijection * pe_head
Head of list of associated pending requests.
struct GSF_PendingRequestPlanBijection * pe_tail
Tail of list of associated pending requests.
API to handle pending requests.
struct GNUNET_CONTAINER_Heap * delay_heap
Heap with pending queries (struct GSF_RequestPlan), by transmission time, lowest first.
Public data (in the sense of not encapsulated within &#39;gnunet-service-fs_pr&#39;, not in the sense of netw...
int merged
Set to GNUNET_YES if we succeeded to merge.
API to manage query plan.
static void schedule_peer_transmission(void *cls)
Figure out when and how to transmit to the given peer.
#define GNUNET_CONTAINER_MDLL_insert(mdll, head, tail, element)
Insert an element at the head of a MDLL.
struct GNUNET_TIME_Absolute earliest_transmission
Earliest time we&#39;d be happy to (re)transmit this request.
struct PeerPlan * pp
The transmission plan for a peer that this request is associated with.
void GNUNET_MQ_notify_sent(struct GNUNET_MQ_Envelope *ev, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
Call a callback once the envelope has been sent, that is, sending it can not be canceled anymore...
Definition: mq.c:774
unsigned int transmission_counter
How often did we transmit this request to this peer?
int GSF_pending_request_test_active_(struct GSF_PendingRequest *pr)
Check if the given request is still active.
void GSF_plan_init()
Initialize plan subsystem.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
#define GNUNET_CONTAINER_MDLL_remove(mdll, head, tail, element)
Remove an element from a MDLL.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1280
void * GNUNET_CONTAINER_heap_peek(const struct GNUNET_CONTAINER_Heap *heap)
Get element stored at the root of heap.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:687
int GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
static int result
Global testing status.
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:442
static void plan(struct PeerPlan *pp, struct GSF_RequestPlan *rp)
Insert the given request plan into the heap with the appropriate weight.
Handle to a node in a heap.
Internal representation of the hash map.
Heap with the minimum cost at the root.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
void GNUNET_CONTAINER_heap_destroy(struct GNUNET_CONTAINER_Heap *heap)
Destroys the heap.
A 512-bit hashcode.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
void GSF_plan_notify_request_done_(struct GSF_PendingRequest *pr)
Notify the plan about a request being done; destroy all entries associated with this request...
Node in the heap.
struct GSF_PendingRequest * pr
Associated pending request (identifies request details and one of the origins of the request)...
unsigned int GNUNET_CONTAINER_heap_get_size(const struct GNUNET_CONTAINER_Heap *heap)
Get the current size of the heap.
There must only be one value per key; storing a value should fail if a value under the same key alrea...
struct GSF_PendingRequestPlanBijection * pr_tail
Fields for the plan module to track a DLL with the request.
struct GNUNET_CONTAINER_HeapNode * hn
Heap node associated with this request and this peer.
struct GNUNET_TIME_Absolute last_transmission
When was the last time we transmitted this request to this peer? 0 for never.
int GNUNET_CONTAINER_multihashmap_contains_value(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Check if the map contains the given value under the given key.
Information we keep per request per peer.
int GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
struct GNUNET_CONTAINER_Heap * GNUNET_CONTAINER_heap_create(enum GNUNET_CONTAINER_HeapOrder order)
Create a new heap.
struct GNUNET_MQ_Envelope * GSF_pending_request_get_message_(struct GSF_PendingRequest *pr)
Generate the message corresponding to the given pending request for transmission to other peers...
Allow multiple values with the same key.
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
The identity of the host (wraps the signing key of the peer).
struct GSF_PendingRequestData * GSF_pending_request_get_data_(struct GSF_PendingRequest *pr)
Obtain the public data associated with a pending request.
int GNUNET_CONTAINER_multihashmap_get_multiple(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map that match a particular key.
const struct GNUNET_PeerIdentity * GSF_connected_peer_get_identity2_(const struct GSF_ConnectedPeer *cp)
Obtain the identity of a connected peer.
void * GNUNET_CONTAINER_multipeermap_get(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Given a key find a value in the map matching the key.
Heap with the maximum cost at the root.
#define GNUNET_log(kind,...)
Entry in list of pending tasks.
Definition: scheduler.c:134
void * GNUNET_CONTAINER_heap_remove_root(struct GNUNET_CONTAINER_Heap *heap)
Remove root of the heap.
#define TTL_DECREMENT
By which amount do we decrement the TTL for simple forwarding / indirection of the query; in milli-se...
struct GSF_PendingRequest * pr
Request we are trying to merge.
A connected peer.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
void GSF_plan_notify_peer_disconnect_(const struct GSF_ConnectedPeer *cp)
Notify the plan about a peer being no longer available; destroy all entries associated with this peer...
struct GSF_RequestPlan * prev
This is a doubly-linked list.
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
Time for absolute times used by GNUnet, in microseconds.
struct GSF_PendingRequestPlanBijection * prev_PR
This is a doubly-linked list.
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_SCHEDULER_Task * task
Current task for executing the plan.
static int merge_pr(void *cls, const struct GNUNET_HashCode *query, void *element)
Iterator that checks if an equivalent request is already present for this peer.
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
An active request.
uint64_t priority
Current priority for this request for this target.
static struct GNUNET_CONTAINER_MultiPeerMap * plans
Hash map from peer identities to PeerPlans.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_at(struct GNUNET_TIME_Absolute at, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run at the specified time.
Definition: scheduler.c:1230
void * GNUNET_CONTAINER_heap_remove_node(struct GNUNET_CONTAINER_HeapNode *node)
Removes a node from the heap.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct GSF_PendingRequestPlanBijection * prev_PE
This is a doubly-linked list.
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
struct GSF_PendingRequest * get_latest(const struct GSF_RequestPlan *rp)
Get the pending request with the highest TTL from the given plan.
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
M:N binding of plans to pending requests.
#define gettext_noop(String)
Definition: gettext.h:69
struct GNUNET_CONTAINER_Heap * priority_heap
Heap with pending queries (struct GSF_RequestPlan), higher weights mean higher priority.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966