gnunet-service-fs_pe.c File Reference

API to manage query plan. More...

#include "platform.h"
#include "gnunet-service-fs.h"
#include "gnunet-service-fs_cp.h"
#include "gnunet-service-fs_pe.h"
#include "gnunet-service-fs_pr.h"

Include dependency graph for gnunet-service-fs_pe.c:

Go to the source code of this file.

Data Structures
struct	GSF_PendingRequestPlanBijection
	M:N binding of plans to pending requests. More...
struct	GSF_RequestPlan
	Information we keep per request per peer. More...
struct	PeerPlan
	Transmission plan for a peer. More...
struct	MergeContext
	Closure for merge_pr(). More...

Macros
#define	INSANE_STATISTICS   GNUNET_NO
	Collect an instance number of statistics? May cause excessive IPC. More...
#define	N   ((double) 128.0)

Functions
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. More...
static void	plan (struct PeerPlan *pp, struct GSF_RequestPlan *rp)
	Insert the given request plan into the heap with the appropriate weight. More...
struct GSF_PendingRequest *	get_latest (const struct GSF_RequestPlan *rp)
	Get the pending request with the highest TTL from the given plan. More...
static void	schedule_peer_transmission (void *cls)
	Figure out when and how to transmit to the given peer. More...
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. More...
void	GSF_plan_add_ (struct GSF_ConnectedPeer *cp, struct GSF_PendingRequest *pr)
	Create a new query plan entry. More...
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. More...
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. More...
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. More...
void	GSF_plan_init ()
	Initialize plan subsystem. More...
void	GSF_plan_done ()
	Shutdown plan subsystem. More...

Variables
static struct GNUNET_CONTAINER_MultiPeerMap *	plans
	Hash map from peer identities to PeerPlans. More...
static unsigned long long	total_delay
	Sum of all transmission counters (equals total delay for all plan entries). More...
static unsigned long long	plan_count
	Number of plan entries. More...

Detailed Description

API to manage query plan.

Author

Christian Grothoff

Definition in file gnunet-service-fs_pe.c.

Macro Definition Documentation

INSANE_STATISTICS

#define INSANE_STATISTICS   GNUNET_NO

Collect an instance number of statistics? May cause excessive IPC.

Definition at line 35 of file gnunet-service-fs_pe.c.

N

#define N   ((double) 128.0)

Function Documentation

get_rp_key()

static const struct GNUNET_HashCode* get_rp_key ( struct GSF_RequestPlan *  rp )

static

Return the query (key in the plan_map) for the given request plan.

Note that this key may change as there can be multiple pending requests for the same key and we just return one of them; this particular one might complete while another one might still be active, hence the lifetime of the returned hash code is NOT necessarily identical to that of the struct GSF_RequestPlan given.

Parameters

rp	a request plan

Returns

the associated query

Definition at line 233 of file gnunet-service-fs_pe.c.

{
  return &GSF_pending_request_get_data_ (rp->pe_head->pr)->query;
}

References GSF_pending_request_get_data_(), GSF_PendingRequestData::query, and rp.

Referenced by GSF_plan_add_(), GSF_plan_notify_peer_disconnect_(), and plan().

Here is the call graph for this function:

Here is the caller graph for this function:

plan()

static void plan ( struct PeerPlan *  pp, struct GSF_RequestPlan *  rp  )

static

Insert the given request plan into the heap with the appropriate weight.

Parameters

pp	associated peer's plan
rp	request to plan

Running average delay we currently impose.

Definition at line 246 of file gnunet-service-fs_pe.c.

{
#define N ((double) 128.0)
  static double avg_delay;
 
  struct GSF_PendingRequestData *prd;
  struct GNUNET_TIME_Relative delay;
 
  GNUNET_assert (rp->pp == pp);
  GNUNET_STATISTICS_set (GSF_stats,
                         gettext_noop ("# average retransmission delay (ms)"),
                         total_delay * 1000LL / plan_count, GNUNET_NO);
  prd = GSF_pending_request_get_data_ (rp->pe_head->pr);
 
  if (rp->transmission_counter < 8)
    delay =
      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
                                     rp->transmission_counter);
  else if (rp->transmission_counter < 32)
    delay =
      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
                                     8
                                     + (1LL << (rp->transmission_counter - 8)));
  else
    delay =
      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
                                     8 + (1LL << 24));
  delay.rel_value_us =
    GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
                              delay.rel_value_us + 1);
  /* Add 0.01 to avg_delay to avoid division-by-zero later */
  avg_delay = (((avg_delay * (N - 1.0)) + delay.rel_value_us) / N) + 0.01;
 
  /*
   * For the priority, we need to consider a few basic rules:
   * 1) if we just started requesting (delay is small), we should
   * virtually always have a priority of zero.
   * 2) for requests with average latency, our priority should match
   * the average priority observed on the network
   * 3) even the longest-running requests should not be WAY out of
   * the observed average (thus we bound by a factor of 2)
   * 4) we add +1 to the observed average priority to avoid everyone
   * staying put at zero (2 * 0 = 0...).
   *
   * Using the specific calculation below, we get:
   *
   * delay = 0 => priority = 0;
   * delay = avg delay => priority = running-average-observed-priority;
   * delay >> avg_delay => priority = 2 * running-average-observed-priority;
   *
   * which satisfies all of the rules above.
   *
   * Note: M_PI_4 = PI/4 = arctan(1)
   */rp->priority =
    round ((GSF_current_priorities
            + 1.0) * atan (delay.rel_value_us / avg_delay)) / M_PI_4;
  /* Note: usage of 'round' and 'atan' requires -lm */
 
  if (rp->transmission_counter != 0)
    delay.rel_value_us += TTL_DECREMENT * 1000;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Considering (re)transmission number %u in %s\n",
              (unsigned int) rp->transmission_counter,
              GNUNET_STRINGS_relative_time_to_string (delay,
                                                      GNUNET_YES));
  rp->earliest_transmission = GNUNET_TIME_relative_to_absolute (delay);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Earliest (re)transmission for `%s' in %us\n",
              GNUNET_h2s (&prd->query),
              rp->transmission_counter);
  GNUNET_assert (rp->hn == NULL);
  if (0 == GNUNET_TIME_absolute_get_remaining (
        rp->earliest_transmission).rel_value_us)
    rp->hn = GNUNET_CONTAINER_heap_insert (pp->priority_heap,
                                           rp,
                                           rp->priority);
  else
    rp->hn =
      GNUNET_CONTAINER_heap_insert (pp->delay_heap,
                                    rp,
                                    rp->earliest_transmission.abs_value_us);
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multihashmap_contains_value (pp->plan_map,
                                                               get_rp_key (rp),
                                                               rp));
#undef N
}

References delay, PeerPlan::delay_heap, get_rp_key(), gettext_noop, GNUNET_assert, GNUNET_CONTAINER_heap_insert(), GNUNET_CONTAINER_multihashmap_contains_value(), GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_set(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_SECONDS, GNUNET_YES, GSF_current_priorities, GSF_pending_request_get_data_(), GSF_stats, N, plan_count, PeerPlan::plan_map, PeerPlan::priority_heap, GSF_PendingRequestData::query, GNUNET_TIME_Relative::rel_value_us, rp, total_delay, and TTL_DECREMENT.

Referenced by GSF_plan_add_(), and schedule_peer_transmission().

Here is the call graph for this function:

Here is the caller graph for this function:

get_latest()

struct GSF_PendingRequest* get_latest

(

const struct GSF_RequestPlan *

rp

)

Get the pending request with the highest TTL from the given plan.

Parameters

rp	plan to investigate

Returns

pending request with highest TTL

Definition at line 346 of file gnunet-service-fs_pe.c.

{
  struct GSF_PendingRequest *ret;
  struct GSF_PendingRequestPlanBijection *bi;
  const struct GSF_PendingRequestData *rprd;
  const struct GSF_PendingRequestData *prd;
 
  bi = rp->pe_head;
  if (NULL == bi)
    return NULL; /* should never happen */
  ret = bi->pr;
  rprd = GSF_pending_request_get_data_ (ret);
  for (bi = bi->next_PE; NULL != bi; bi = bi->next_PE)
  {
    GNUNET_break (GNUNET_YES ==
                  GSF_pending_request_test_active_ (bi->pr));
    prd = GSF_pending_request_get_data_ (bi->pr);
    if (prd->ttl.abs_value_us > rprd->ttl.abs_value_us)
    {
      ret = bi->pr;
      rprd = prd;
    }
  }
  return ret;
}

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_break, GNUNET_YES, GSF_pending_request_get_data_(), GSF_pending_request_test_active_(), GSF_PendingRequestPlanBijection::next_PE, GSF_PendingRequestPlanBijection::pr, ret, rp, and GSF_PendingRequestData::ttl.

Referenced by merge_pr(), and schedule_peer_transmission().

Here is the call graph for this function:

Here is the caller graph for this function:

schedule_peer_transmission()

static void schedule_peer_transmission ( void *  cls )

static

Figure out when and how to transmit to the given peer.

Parameters

cls	the struct PeerPlan

Definition at line 379 of file gnunet-service-fs_pe.c.

{
  struct PeerPlan *pp = cls;
  struct GSF_RequestPlan *rp;
  struct GNUNET_TIME_Relative delay;
 
  if (NULL != pp->task)
  {
    pp->task = NULL;
  }
  else
  {
    GNUNET_assert (NULL != pp->env);
    pp->env = NULL;
  }
  /* move ready requests to priority queue */
  while ((NULL != (rp = GNUNET_CONTAINER_heap_peek (pp->delay_heap))) &&
         (0 == GNUNET_TIME_absolute_get_remaining
            (rp->earliest_transmission).rel_value_us))
  {
    GNUNET_assert (rp == GNUNET_CONTAINER_heap_remove_root (pp->delay_heap));
    rp->hn = GNUNET_CONTAINER_heap_insert (pp->priority_heap,
                                           rp,
                                           rp->priority);
  }
  if (0 == GNUNET_CONTAINER_heap_get_size (pp->priority_heap))
  {
    /* priority heap (still) empty, check for delay... */
    rp = GNUNET_CONTAINER_heap_peek (pp->delay_heap);
    if (NULL == rp)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "No active requests for plan %p.\n",
                  pp);
      return;                   /* both queues empty */
    }
    delay = GNUNET_TIME_absolute_get_remaining (rp->earliest_transmission);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Sleeping for %s before retrying requests on plan %p.\n",
                GNUNET_STRINGS_relative_time_to_string (delay,
                                                        GNUNET_YES),
                pp);
    GNUNET_STATISTICS_set (GSF_stats,
                           gettext_noop ("# delay heap timeout (ms)"),
                           delay.rel_value_us / 1000LL, GNUNET_NO);
 
    pp->task
      = GNUNET_SCHEDULER_add_at (rp->earliest_transmission,
                                 &schedule_peer_transmission,
                                 pp);
    return;
  }
#if INSANE_STATISTICS
  GNUNET_STATISTICS_update (GSF_stats,
                            gettext_noop ("# query plans executed"),
                            1,
                            GNUNET_NO);
#endif
  /* process from priority heap */
  rp = GNUNET_CONTAINER_heap_remove_root (pp->priority_heap);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Executing query plan %p\n",
              rp);
  GNUNET_assert (NULL != rp);
  rp->hn = NULL;
  rp->last_transmission = GNUNET_TIME_absolute_get ();
  rp->transmission_counter++;
  total_delay++;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Executing plan %p executed %u times, planning retransmission\n",
              rp,
              rp->transmission_counter);
  GNUNET_assert (NULL == pp->env);
  pp->env = GSF_pending_request_get_message_ (get_latest (rp));
  GNUNET_MQ_notify_sent (pp->env,
                         &schedule_peer_transmission,
                         pp);
  GSF_peer_transmit_ (pp->cp,
                      GNUNET_YES,
                      rp->priority,
                      pp->env);
  GNUNET_STATISTICS_update (GSF_stats,
                            gettext_noop (
                              "# query messages sent to other peers"),
                            1,
                            GNUNET_NO);
  plan (pp,
        rp);
}

References PeerPlan::cp, delay, PeerPlan::delay_heap, PeerPlan::env, get_latest(), gettext_noop, GNUNET_assert, GNUNET_CONTAINER_heap_get_size(), GNUNET_CONTAINER_heap_insert(), GNUNET_CONTAINER_heap_peek(), GNUNET_CONTAINER_heap_remove_root(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MQ_notify_sent(), GNUNET_NO, GNUNET_SCHEDULER_add_at(), GNUNET_STATISTICS_set(), GNUNET_STATISTICS_update(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_remaining(), GNUNET_YES, GSF_peer_transmit_(), GSF_pending_request_get_message_(), GSF_stats, plan(), PeerPlan::priority_heap, GNUNET_TIME_Relative::rel_value_us, rp, PeerPlan::task, and total_delay.

Referenced by GSF_plan_add_().

Here is the call graph for this function:

Here is the caller graph for this function:

merge_pr()

static int merge_pr ( void *  cls, const struct GNUNET_HashCode *  query, void *  element  )

static

Iterator that checks if an equivalent request is already present for this peer.

Parameters

cls	closure
query	the query
element	request plan stored at the node

Returns

GNUNET_YES if we should continue to iterate, GNUNET_NO if not (merge success)

Definition at line 498 of file gnunet-service-fs_pe.c.

{
  struct MergeContext *mpr = cls;
  struct GSF_RequestPlan *rp = element;
  struct GSF_PendingRequestData *prd;
  struct GSF_PendingRequestPlanBijection *bi;
  struct GSF_PendingRequest *latest;
 
  GNUNET_break (GNUNET_YES ==
                GSF_pending_request_test_active_ (mpr->pr));
  if (GNUNET_OK !=
      GSF_pending_request_is_compatible_ (mpr->pr,
                                          rp->pe_head->pr))
    return GNUNET_YES;
  /* merge new request with existing request plan */
  bi = GNUNET_new (struct GSF_PendingRequestPlanBijection);
  bi->rp = rp;
  bi->pr = mpr->pr;
  prd = GSF_pending_request_get_data_ (mpr->pr);
  GNUNET_CONTAINER_MDLL_insert (PR,
                                prd->pr_head,
                                prd->pr_tail,
                                bi);
  GNUNET_CONTAINER_MDLL_insert (PE,
                                rp->pe_head,
                                rp->pe_tail,
                                bi);
  mpr->merged = GNUNET_YES;
#if INSANE_STATISTICS
  GNUNET_STATISTICS_update (GSF_stats,
                            gettext_noop ("# requests merged"),
                            1,
                            GNUNET_NO);
#endif
  latest = get_latest (rp);
  if (GSF_pending_request_get_data_ (latest)->ttl.abs_value_us <
      prd->ttl.abs_value_us)
  {
#if INSANE_STATISTICS
    GNUNET_STATISTICS_update (GSF_stats,
                              gettext_noop ("# requests refreshed"),
                              1,
                              GNUNET_NO);
#endif
    rp->transmission_counter = 0;       /* reset */
  }
  return GNUNET_NO;
}

References GNUNET_TIME_Absolute::abs_value_us, get_latest(), gettext_noop, GNUNET_break, GNUNET_CONTAINER_MDLL_insert, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_YES, GSF_pending_request_get_data_(), GSF_pending_request_is_compatible_(), GSF_pending_request_test_active_(), GSF_stats, MergeContext::merged, GSF_PendingRequestPlanBijection::pr, MergeContext::pr, GSF_PendingRequestData::pr_head, GSF_PendingRequestData::pr_tail, GSF_PendingRequestPlanBijection::rp, rp, GSF_PendingRequestData::ttl, and ttl.

Referenced by GSF_plan_add_().

Here is the call graph for this function:

Here is the caller graph for this function:

GSF_plan_add_()

void GSF_plan_add_	(	struct GSF_ConnectedPeer *	cp,
		struct GSF_PendingRequest *	pr
	)

Create a new query plan entry.

Parameters

cp	peer with the entry
pr	request with the entry

Definition at line 557 of file gnunet-service-fs_pe.c.

{
  const struct GNUNET_PeerIdentity *id;
  struct PeerPlan *pp;
  struct GSF_PendingRequestData *prd;
  struct GSF_RequestPlan *rp;
  struct GSF_PendingRequestPlanBijection *bi;
  struct MergeContext mpc;
 
  GNUNET_assert (GNUNET_YES ==
                 GSF_pending_request_test_active_ (pr));
  GNUNET_assert (NULL != cp);
  id = GSF_connected_peer_get_identity2_ (cp);
  pp = GNUNET_CONTAINER_multipeermap_get (plans, id);
  if (NULL == pp)
  {
    pp = GNUNET_new (struct PeerPlan);
    pp->plan_map = GNUNET_CONTAINER_multihashmap_create (128, GNUNET_NO);
    pp->priority_heap =
      GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MAX);
    pp->delay_heap =
      GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
    pp->cp = cp;
    GNUNET_assert (GNUNET_OK ==
                   GNUNET_CONTAINER_multipeermap_put (plans,
                                                      id,
                                                      pp,
                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
    pp->task = GNUNET_SCHEDULER_add_now (&schedule_peer_transmission,
                                         pp);
  }
  mpc.merged = GNUNET_NO;
  mpc.pr = pr;
  prd = GSF_pending_request_get_data_ (pr);
  GNUNET_CONTAINER_multihashmap_get_multiple (pp->plan_map,
                                              &prd->query,
                                              &merge_pr,
                                              &mpc);
  if (GNUNET_NO != mpc.merged)
    return;
  plan_count++;
  GNUNET_STATISTICS_update (GSF_stats,
                            gettext_noop ("# query plan entries"),
                            1,
                            GNUNET_NO);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Planning transmission of query `%s' to peer `%s'\n",
              GNUNET_h2s (&prd->query),
              GNUNET_i2s (id));
  rp = GNUNET_new (struct GSF_RequestPlan);
  bi = GNUNET_new (struct GSF_PendingRequestPlanBijection);
  bi->rp = rp;
  bi->pr = pr;
  GNUNET_CONTAINER_MDLL_insert (PR,
                                prd->pr_head,
                                prd->pr_tail,
                                bi);
  GNUNET_CONTAINER_MDLL_insert (PE,
                                rp->pe_head,
                                rp->pe_tail,
                                bi);
  rp->pp = pp;
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multihashmap_put (pp->plan_map,
                                                    get_rp_key (rp),
                                                    rp,
                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
  plan (pp,
        rp);
}

References PeerPlan::cp, PeerPlan::delay_heap, get_rp_key(), gettext_noop, GNUNET_assert, GNUNET_CONTAINER_heap_create(), GNUNET_CONTAINER_HEAP_ORDER_MAX, GNUNET_CONTAINER_HEAP_ORDER_MIN, GNUNET_CONTAINER_MDLL_insert, GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_get(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_STATISTICS_update(), GNUNET_YES, GSF_connected_peer_get_identity2_(), GSF_pending_request_get_data_(), GSF_pending_request_test_active_(), GSF_stats, id, merge_pr(), MergeContext::merged, plan(), plan_count, PeerPlan::plan_map, plans, GSF_PendingRequestPlanBijection::pr, MergeContext::pr, GSF_PendingRequestData::pr_head, GSF_PendingRequestData::pr_tail, PeerPlan::priority_heap, GSF_PendingRequestData::query, GSF_PendingRequestPlanBijection::rp, rp, schedule_peer_transmission(), and PeerPlan::task.

Referenced by consider_peer_for_forwarding(), and consider_request_for_forwarding().

Here is the call graph for this function:

Here is the caller graph for this function:

GSF_plan_notify_peer_disconnect_()

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.

Parameters

cp	connected peer

Definition at line 637 of file gnunet-service-fs_pe.c.

{
  const struct GNUNET_PeerIdentity *id;
  struct PeerPlan *pp;
  struct GSF_RequestPlan *rp;
  struct GSF_PendingRequestData *prd;
  struct GSF_PendingRequestPlanBijection *bi;
 
  id = GSF_connected_peer_get_identity2_ (cp);
  pp = GNUNET_CONTAINER_multipeermap_get (plans, id);
  if (NULL == pp)
    return;                     /* nothing was ever planned for this peer */
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multipeermap_remove (plans, id,
                                                       pp));
  if (NULL != pp->task)
  {
    GNUNET_SCHEDULER_cancel (pp->task);
    pp->task = NULL;
  }
  while (NULL != (rp = GNUNET_CONTAINER_heap_remove_root (pp->priority_heap)))
  {
    GNUNET_break (GNUNET_YES ==
                  GNUNET_CONTAINER_multihashmap_remove (pp->plan_map,
                                                        get_rp_key (rp),
                                                        rp));
    while (NULL != (bi = rp->pe_head))
    {
      GNUNET_CONTAINER_MDLL_remove (PE,
                                    rp->pe_head,
                                    rp->pe_tail,
                                    bi);
      prd = GSF_pending_request_get_data_ (bi->pr);
      GNUNET_CONTAINER_MDLL_remove (PR,
                                    prd->pr_head,
                                    prd->pr_tail,
                                    bi);
      GNUNET_free (bi);
    }
    plan_count--;
    GNUNET_free (rp);
  }
  GNUNET_CONTAINER_heap_destroy (pp->priority_heap);
  while (NULL != (rp = GNUNET_CONTAINER_heap_remove_root (pp->delay_heap)))
  {
    GNUNET_break (GNUNET_YES ==
                  GNUNET_CONTAINER_multihashmap_remove (pp->plan_map,
                                                        get_rp_key (rp),
                                                        rp));
    while (NULL != (bi = rp->pe_head))
    {
      prd = GSF_pending_request_get_data_ (bi->pr);
      GNUNET_CONTAINER_MDLL_remove (PE,
                                    rp->pe_head,
                                    rp->pe_tail,
                                    bi);
      GNUNET_CONTAINER_MDLL_remove (PR,
                                    prd->pr_head,
                                    prd->pr_tail,
                                    bi);
      GNUNET_free (bi);
    }
    plan_count--;
    GNUNET_free (rp);
  }
  GNUNET_STATISTICS_set (GSF_stats,
                         gettext_noop ("# query plan entries"),
                         plan_count,
                         GNUNET_NO);
  GNUNET_CONTAINER_heap_destroy (pp->delay_heap);
  GNUNET_CONTAINER_multihashmap_destroy (pp->plan_map);
  GNUNET_free (pp);
}

References PeerPlan::delay_heap, get_rp_key(), gettext_noop, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_heap_destroy(), GNUNET_CONTAINER_heap_remove_root(), GNUNET_CONTAINER_MDLL_remove, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_CONTAINER_multipeermap_get(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_free, GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_set(), GNUNET_YES, GSF_connected_peer_get_identity2_(), GSF_pending_request_get_data_(), GSF_stats, id, plan_count, PeerPlan::plan_map, plans, GSF_PendingRequestPlanBijection::pr, GSF_PendingRequestData::pr_head, GSF_PendingRequestData::pr_tail, PeerPlan::priority_heap, rp, and PeerPlan::task.

Referenced by GSF_peer_disconnect_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

GSF_request_plan_reference_get_last_transmission_()

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.

Get the last transmission attempt time for the request plan list referenced by 'rpr_head', that was sent to 'sender'.

Parameters

pr_head	request plan reference list to check.
sender	the peer that we've sent the request to.
result	the timestamp to fill, set to GNUNET_TIME_UNIT_FOREVER_ABS if never transmitted

Returns

GNUNET_YES if result was changed, GNUNET_NO otherwise.

Definition at line 722 of file gnunet-service-fs_pe.c.

{
  struct GSF_PendingRequestPlanBijection *bi;
 
  for (bi = pr_head; NULL != bi; bi = bi->next_PR)
  {
    if (bi->rp->pp->cp == sender)
    {
      if (0 == bi->rp->last_transmission.abs_value_us)
        *result = GNUNET_TIME_UNIT_FOREVER_ABS;
      else
        *result = bi->rp->last_transmission;
      return GNUNET_YES;
    }
  }
  return GNUNET_NO;
}

References GNUNET_TIME_Absolute::abs_value_us, PeerPlan::cp, GNUNET_NO, GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_YES, GSF_RequestPlan::last_transmission, GSF_PendingRequestPlanBijection::next_PR, GSF_RequestPlan::pp, result, and GSF_PendingRequestPlanBijection::rp.

GSF_plan_notify_request_done_()

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.

Parameters

pr	request that is done

Definition at line 754 of file gnunet-service-fs_pe.c.

{
  struct GSF_RequestPlan *rp;
  struct GSF_PendingRequestData *prd;
  struct GSF_PendingRequestPlanBijection *bi;
 
  prd = GSF_pending_request_get_data_ (pr);
  while (NULL != (bi = prd->pr_head))
  {
    rp = bi->rp;
    GNUNET_CONTAINER_MDLL_remove (PR,
                                  prd->pr_head,
                                  prd->pr_tail,
                                  bi);
    GNUNET_CONTAINER_MDLL_remove (PE,
                                  rp->pe_head,
                                  rp->pe_tail,
                                  bi);
    GNUNET_assert (bi->pr == pr);
    if (NULL == rp->pe_head)
    {
      GNUNET_CONTAINER_heap_remove_node (rp->hn);
      plan_count--;
      GNUNET_break (GNUNET_YES ==
                    GNUNET_CONTAINER_multihashmap_remove (rp->pp->plan_map,
                                                          &prd->query,
                                                          rp));
      GNUNET_free (rp);
    }
    GNUNET_free (bi);
  }
  GNUNET_STATISTICS_set (GSF_stats,
                         gettext_noop ("# query plan entries"),
                         plan_count,
                         GNUNET_NO);
}

References gettext_noop, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_heap_remove_node(), GNUNET_CONTAINER_MDLL_remove, GNUNET_CONTAINER_multihashmap_remove(), GNUNET_free, GNUNET_NO, GNUNET_STATISTICS_set(), GNUNET_YES, GSF_pending_request_get_data_(), GSF_stats, plan_count, GSF_PendingRequestPlanBijection::pr, GSF_PendingRequestData::pr_head, GSF_PendingRequestData::pr_tail, GSF_PendingRequestData::query, GSF_PendingRequestPlanBijection::rp, and rp.

Referenced by clean_request(), and GSF_pending_request_cancel_().

Here is the call graph for this function:

Here is the caller graph for this function:

GSF_plan_init()

void GSF_plan_init

(

void

)

Initialize plan subsystem.

Definition at line 796 of file gnunet-service-fs_pe.c.

{
  plans = GNUNET_CONTAINER_multipeermap_create (256,
                                                GNUNET_YES);
}

References GNUNET_CONTAINER_multipeermap_create(), GNUNET_YES, and plans.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

GSF_plan_done()

void GSF_plan_done

(

void

)

Shutdown plan subsystem.

Definition at line 807 of file gnunet-service-fs_pe.c.

{
  GNUNET_assert (0 == GNUNET_CONTAINER_multipeermap_size (plans));
  GNUNET_CONTAINER_multipeermap_destroy (plans);
}

References GNUNET_assert, GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_size(), and plans.

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

plans

struct GNUNET_CONTAINER_MultiPeerMap* plans

static

Hash map from peer identities to PeerPlans.

Definition at line 207 of file gnunet-service-fs_pe.c.

Referenced by GSF_plan_add_(), GSF_plan_done(), GSF_plan_init(), and GSF_plan_notify_peer_disconnect_().

total_delay

unsigned long long total_delay

static

Sum of all transmission counters (equals total delay for all plan entries).

Definition at line 212 of file gnunet-service-fs_pe.c.

Referenced by plan(), and schedule_peer_transmission().

plan_count

unsigned long long plan_count

static

Number of plan entries.

Definition at line 217 of file gnunet-service-fs_pe.c.

Referenced by GSF_plan_add_(), GSF_plan_notify_peer_disconnect_(), GSF_plan_notify_request_done_(), and plan().