GNUnet 0.21.2
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"
31
35#define INSANE_STATISTICS GNUNET_NO
36
41struct PendingRequestList;
42
46struct PeerPlan;
47
48
67{
72
77
82
87
93
99};
100
101
109{
114
119
124
128 struct PeerPlan *pp;
129
136
141
146
151
155 uint64_t priority;
156
161};
162
163
168{
173
178
186
191
196
201};
202
203
208
212static unsigned long long total_delay;
213
217static unsigned long long plan_count;
218
219
232static const struct GNUNET_HashCode *
234{
235 return &GSF_pending_request_get_data_ (rp->pe_head->pr)->query;
236}
237
238
245static void
246plan (struct PeerPlan *pp,
247 struct GSF_RequestPlan *rp)
248{
249#define N ((double) 128.0)
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);
262 prd = GSF_pending_request_get_data_ (rp->pe_head->pr);
263
264 if (rp->transmission_counter < 8)
265 delay =
267 rp->transmission_counter);
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 =
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));
315 rp->earliest_transmission = GNUNET_TIME_relative_to_absolute (delay);
317 "Earliest (re)transmission for `%s' in %us\n",
318 GNUNET_h2s (&prd->query),
319 rp->transmission_counter);
320 GNUNET_assert (rp->hn == NULL);
322 rp->earliest_transmission).rel_value_us)
324 rp,
325 rp->priority);
326 else
327 rp->hn =
329 rp,
330 rp->earliest_transmission.abs_value_us);
333 get_rp_key (rp),
334 rp));
335#undef N
336}
337
338
345struct 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;
358 for (bi = bi->next_PE; NULL != bi; bi = bi->next_PE)
359 {
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
378static 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))) &&
397 (rp->earliest_transmission).rel_value_us))
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 }
415 delay = GNUNET_TIME_absolute_get_remaining (rp->earliest_transmission);
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
426 = GNUNET_SCHEDULER_add_at (rp->earliest_transmission,
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;
444 rp->last_transmission = GNUNET_TIME_absolute_get ();
445 rp->transmission_counter++;
446 total_delay++;
448 "Executing plan %p executed %u times, planning retransmission\n",
449 rp,
450 rp->transmission_counter);
451 GNUNET_assert (NULL == pp->env);
455 pp);
458 rp->priority,
459 pp->env);
462 "# query messages sent to other peers"),
463 1,
464 GNUNET_NO);
465 plan (pp,
466 rp);
467}
468
469
474{
479
484};
485
486
497static int
498merge_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;
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
556void
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);
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
636void
638{
639 const struct GNUNET_PeerIdentity *id;
640 struct PeerPlan *pp;
641 struct GSF_RequestPlan *rp;
642 struct GSF_PendingRequestData *prd;
644
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);
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 {
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"),
705 GNUNET_NO);
708 GNUNET_free (pp);
709}
710
711
721int
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
740 return GNUNET_YES;
741 }
742 }
743 return GNUNET_NO;
744}
745
746
753void
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"),
788 GNUNET_NO);
789}
790
791
795void
797{
799 GNUNET_YES);
800}
801
802
806void
808{
811}
812
813
814/* end of gnunet-service-fs_pe.h */
#define gettext_noop(String)
Definition: gettext.h:74
static int ret
Final status code.
Definition: gnunet-arm.c:94
static struct GNUNET_TIME_Relative ttl
Current record $TTL to use.
static struct GNUNET_IDENTITY_Handle * id
Handle to IDENTITY.
static char * rp
Relying party.
static int result
Global testing status.
struct GNUNET_STATISTICS_Handle * GSF_stats
Handle for reporting statistics.
double GSF_current_priorities
Typical priorities we're seeing from other peers right now.
shared data structures of gnunet-service-fs.c
#define TTL_DECREMENT
By which amount do we decrement the TTL for simple forwarding / indirection of the query; in milli-se...
const struct GNUNET_PeerIdentity * GSF_connected_peer_get_identity2_(const struct GSF_ConnectedPeer *cp)
Obtain the identity of a connected peer.
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.
API to handle 'connected peers'.
#define N
static unsigned long long plan_count
Number of plan entries.
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,...
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...
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.
void GSF_plan_init()
Initialize plan subsystem.
static void schedule_peer_transmission(void *cls)
Figure out when and how to transmit to the given peer.
static struct GNUNET_CONTAINER_MultiPeerMap * plans
Hash map from peer identities to PeerPlans.
static void plan(struct PeerPlan *pp, struct GSF_RequestPlan *rp)
Insert the given request plan into the heap with the appropriate weight.
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.
struct GSF_PendingRequest * get_latest(const struct GSF_RequestPlan *rp)
Get the pending request with the highest TTL from the given plan.
void GSF_plan_add_(struct GSF_ConnectedPeer *cp, struct GSF_PendingRequest *pr)
Create a new query plan entry.
void GSF_plan_done()
Shutdown plan subsystem.
static unsigned long long total_delay
Sum of all transmission counters (equals total delay for all plan entries).
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.
API to manage query plan.
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 ...
struct GSF_PendingRequestData * GSF_pending_request_get_data_(struct GSF_PendingRequest *pr)
Obtain the public data associated with a pending request.
int GSF_pending_request_test_active_(struct GSF_PendingRequest *pr)
Check if the given request is still active.
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.
API to handle pending requests.
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
@ GNUNET_CRYPTO_QUALITY_WEAK
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
#define GNUNET_CONTAINER_MDLL_remove(mdll, head, tail, element)
Remove an element from a MDLL.
#define GNUNET_CONTAINER_MDLL_insert(mdll, head, tail, element)
Insert an element at the head of a MDLL.
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.
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
enum GNUNET_GenericReturnValue 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.
enum GNUNET_GenericReturnValue 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.
enum GNUNET_GenericReturnValue 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.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
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).
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_get_multiple(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map that match a particular key.
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
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.
enum GNUNET_GenericReturnValue 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.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
There must only be one value per key; storing a value should fail if a value under the same key alrea...
void * GNUNET_CONTAINER_heap_remove_node(struct GNUNET_CONTAINER_HeapNode *node)
Removes a node from the heap.
void * GNUNET_CONTAINER_heap_peek(const struct GNUNET_CONTAINER_Heap *heap)
Get element stored at the root of heap.
void * GNUNET_CONTAINER_heap_remove_root(struct GNUNET_CONTAINER_Heap *heap)
Remove root of the heap.
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.
unsigned int GNUNET_CONTAINER_heap_get_size(const struct GNUNET_CONTAINER_Heap *heap)
Get the current size of the heap.
struct GNUNET_CONTAINER_Heap * GNUNET_CONTAINER_heap_create(enum GNUNET_CONTAINER_HeapOrder order)
Create a new heap.
void GNUNET_CONTAINER_heap_destroy(struct GNUNET_CONTAINER_Heap *heap)
Destroys the heap.
@ GNUNET_CONTAINER_HEAP_ORDER_MIN
Heap with the minimum cost at the root.
@ GNUNET_CONTAINER_HEAP_ORDER_MAX
Heap with the maximum cost at the root.
#define GNUNET_log(kind,...)
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
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:638
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:1255
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:981
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:1305
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_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
#define GNUNET_TIME_UNIT_SECONDS
One second.
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:405
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:570
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:111
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:316
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:484
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
Handle to a node in a heap.
Internal representation of the hash map.
Internal representation of the hash map.
A 512-bit hashcode.
The identity of the host (wraps the signing key of the peer).
Entry in list of pending tasks.
Definition: scheduler.c:136
Time for absolute times used by GNUnet, in microseconds.
uint64_t abs_value_us
The actual value.
Time for relative time used by GNUnet, in microseconds.
uint64_t rel_value_us
The actual value.
A connected peer.
Public data (in the sense of not encapsulated within 'gnunet-service-fs_pr', not in the sense of netw...
struct GNUNET_TIME_Absolute ttl
Current TTL for the request.
struct GSF_PendingRequestPlanBijection * pr_head
Fields for the plan module to track a DLL with the request.
struct GSF_PendingRequestPlanBijection * pr_tail
Fields for the plan module to track a DLL with the request.
struct GNUNET_HashCode query
Primary query hash for this request.
M:N binding of plans to pending requests.
struct GSF_PendingRequestPlanBijection * prev_PR
This is a doubly-linked list.
struct GSF_PendingRequest * pr
Associated pending request (identifies request details and one of the origins of the request).
struct GSF_PendingRequestPlanBijection * next_PE
This is a doubly-linked list.
struct GSF_PendingRequestPlanBijection * next_PR
This is a doubly-linked list.
struct GSF_RequestPlan * rp
Associated request plan (tells us one of the peers that we plan to forward the request to).
struct GSF_PendingRequestPlanBijection * prev_PE
This is a doubly-linked list.
An active request.
Information we keep per request per peer.
uint64_t priority
Current priority for this request for this target.
struct GNUNET_TIME_Absolute earliest_transmission
Earliest time we'd be happy to (re)transmit this request.
unsigned int transmission_counter
How often did we transmit this request to this peer?
struct GSF_RequestPlan * next
This is a doubly-linked list.
struct PeerPlan * pp
The transmission plan for a peer that this request is associated with.
struct GSF_PendingRequestPlanBijection * pe_head
Head of list of associated pending requests.
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.
struct GSF_PendingRequestPlanBijection * pe_tail
Tail of list of associated pending requests.
struct GSF_RequestPlan * prev
This is a doubly-linked list.
Closure for merge_pr().
int merged
Set to GNUNET_YES if we succeeded to merge.
struct GSF_PendingRequest * pr
Request we are trying to merge.
Transmission plan for a peer.
struct GNUNET_SCHEDULER_Task * task
Current task for executing the plan.
struct GNUNET_CONTAINER_Heap * priority_heap
Heap with pending queries (struct GSF_RequestPlan), higher weights mean higher priority.
struct GNUNET_CONTAINER_MultiHashMap * plan_map
Map of queries to plan entries.
struct GNUNET_CONTAINER_Heap * delay_heap
Heap with pending queries (struct GSF_RequestPlan), by transmission time, lowest first.
struct GSF_ConnectedPeer * cp
Peer for which this is the plan.
struct GNUNET_MQ_Envelope * env
Current message under transmission for the plan.