[GNUnet-SVN] r24493 - in gnunet/src: fs include

[gnunet]

Author: grothoff
Date: 2012-10-23 20:12:22 +0200 (Tue, 23 Oct 2012)
New Revision: 24493

Modified:
   gnunet/src/fs/gnunet-service-fs_pe.c
   gnunet/src/include/gnunet_container_lib.h
   gnunet/src/include/platform.h
Log:
-introducing MDLL macros

Modified: gnunet/src/fs/gnunet-service-fs_pe.c
===================================================================
--- gnunet/src/fs/gnunet-service-fs_pe.c        2012-10-23 17:41:14 UTC (rev 
24492)
+++ gnunet/src/fs/gnunet-service-fs_pe.c        2012-10-23 18:12:22 UTC (rev 
24493)
@@ -48,7 +48,13 @@
 
 /**
  * DLL of request plans a particular pending request is
- * involved with.
+ * involved with.  The corresponding head and tail are
+ * stored in a 'struct GSF_PendingRequest'.  (We need
+ * to be able to lookup all 'plan' entries for a given
+ * request easily).
+ *
+ * There is always one 'struct PendingRequestList'
+ * for each 'struct GSF_RequestPlanReference'.
  */
 struct GSF_RequestPlanReference
 {
@@ -56,12 +62,12 @@
   /**
    * This is a doubly-linked list.
    */
-  struct GSF_RequestPlanReference *next;
+  struct GSF_RequestPlanReference *next_PR;
 
   /**
    * This is a doubly-linked list.
    */
-  struct GSF_RequestPlanReference *prev;
+  struct GSF_RequestPlanReference *prev_PR;
 
   /**
    * Associated request plan.
@@ -77,7 +83,13 @@
 
 /**
  * List of GSF_PendingRequests this request plan
- * participates with.
+ * participates with.  The corresponding head and tail
+ * are stored in a 'struct GSF_RequestPlan'. (We need
+ * to be able to lookup all pending requests corresponding
+ * to a given plan entry.)
+ *
+ * There is always one 'struct PendingRequestList'
+ * for each 'struct GSF_RequestPlanReference'.
  */
 struct PendingRequestList
 {
@@ -85,12 +97,12 @@
   /**
    * This is a doubly-linked list.
    */
-  struct PendingRequestList *next;
+  struct PendingRequestList *next_PE;
 
   /**
    * This is a doubly-linked list.
    */
-  struct PendingRequestList *prev;
+  struct PendingRequestList *prev_PE;
 
   /**
    * Associated pending request.
@@ -364,13 +376,13 @@
 
   prl = rp->prl_head;
   ret = prl->pr;
-  prl = prl->next;
+  prl = prl->next_PE; 
   while (NULL != prl)
   {
     if (GSF_pending_request_get_data_ (prl->pr)->ttl.abs_value >
         GSF_pending_request_get_data_ (ret)->ttl.abs_value)
       ret = prl->pr;
-    prl = prl->next;
+    prl = prl->next_PE;
   }
   return ret;
 }
@@ -544,8 +556,8 @@
   prl->rpr = rpr;
   prl->pr = mpr->pr;
   prd = GSF_pending_request_get_data_ (mpr->pr);
-  GNUNET_CONTAINER_DLL_insert (prd->rpr_head, prd->rpr_tail, rpr);
-  GNUNET_CONTAINER_DLL_insert (rp->prl_head, rp->prl_tail, prl);
+  GNUNET_CONTAINER_MDLL_insert (PR, prd->rpr_head, prd->rpr_tail, rpr);
+  GNUNET_CONTAINER_MDLL_insert (PE, rp->prl_head, rp->prl_tail, prl);
   mpr->merged = GNUNET_YES;
 #if INSANE_STATISTICS
   GNUNET_STATISTICS_update (GSF_stats, gettext_noop ("# requests merged"), 1,
@@ -624,8 +636,8 @@
   rpr->prl = prl;
   prl->rpr = rpr;
   prl->pr = pr;
-  GNUNET_CONTAINER_DLL_insert (prd->rpr_head, prd->rpr_tail, rpr);
-  GNUNET_CONTAINER_DLL_insert (rp->prl_head, rp->prl_tail, prl);
+  GNUNET_CONTAINER_MDLL_insert (PR, prd->rpr_head, prd->rpr_tail, rpr);
+  GNUNET_CONTAINER_MDLL_insert (PE, rp->prl_head, rp->prl_tail, prl);
   rp->pp = pp;
   GNUNET_assert (GNUNET_YES ==
                  GNUNET_CONTAINER_multihashmap_put (pp->plan_map,
@@ -674,9 +686,9 @@
                                                         get_rp_key (rp), rp));
     while (NULL != (prl = rp->prl_head))
     {
-      GNUNET_CONTAINER_DLL_remove (rp->prl_head, rp->prl_tail, prl);
+      GNUNET_CONTAINER_MDLL_remove (PE, rp->prl_head, rp->prl_tail, prl);
       prd = GSF_pending_request_get_data_ (prl->pr);
-      GNUNET_CONTAINER_DLL_remove (prd->rpr_head, prd->rpr_tail, prl->rpr);
+      GNUNET_CONTAINER_MDLL_remove (PR, prd->rpr_head, prd->rpr_tail, 
prl->rpr);
       GNUNET_free (prl->rpr);
       GNUNET_free (prl);
     }
@@ -691,9 +703,9 @@
                                                         get_rp_key (rp), rp));
     while (NULL != (prl = rp->prl_head))
     {
-      GNUNET_CONTAINER_DLL_remove (rp->prl_head, rp->prl_tail, prl);
+      GNUNET_CONTAINER_MDLL_remove (PE, rp->prl_head, rp->prl_tail, prl);
       prd = GSF_pending_request_get_data_ (prl->pr);
-      GNUNET_CONTAINER_DLL_remove (prd->rpr_head, prd->rpr_tail, prl->rpr);
+      GNUNET_CONTAINER_MDLL_remove (PR, prd->rpr_head, prd->rpr_tail, 
prl->rpr);
       GNUNET_free (prl->rpr);
       GNUNET_free (prl);
     }
@@ -707,6 +719,7 @@
   GNUNET_free (pp);
 }
 
+
 /**
  * Get the last transmission attempt time for the request plan list
  * referenced by 'rpr_head', that was sent to 'sender'
@@ -722,7 +735,8 @@
     struct GNUNET_TIME_Absolute *result)
 {
   struct GSF_RequestPlanReference *rpr;
-  for (rpr = rpr_head; rpr; rpr = rpr->next)
+
+  for (rpr = rpr_head; NULL != rpr; rpr = rpr->next_PR)
   {
     if (rpr->rp->pp->cp == sender)
     {
@@ -733,6 +747,7 @@
   return GNUNET_NO;
 }
 
+
 /**
  * Notify the plan about a request being done; destroy all entries
  * associated with this request.
@@ -749,9 +764,9 @@
   prd = GSF_pending_request_get_data_ (pr);
   while (NULL != (rpr = prd->rpr_head))
   {
-    GNUNET_CONTAINER_DLL_remove (prd->rpr_head, prd->rpr_tail, rpr);
+    GNUNET_CONTAINER_MDLL_remove (PR, prd->rpr_head, prd->rpr_tail, rpr);
     rp = rpr->rp;
-    GNUNET_CONTAINER_DLL_remove (rp->prl_head, rp->prl_tail, rpr->prl);
+    GNUNET_CONTAINER_MDLL_remove (PE, rp->prl_head, rp->prl_tail, rpr->prl);
     if (NULL == rp->prl_head)
     {
       GNUNET_CONTAINER_heap_remove_node (rp->hn);

Modified: gnunet/src/include/gnunet_container_lib.h
===================================================================
--- gnunet/src/include/gnunet_container_lib.h   2012-10-23 17:41:14 UTC (rev 
24492)
+++ gnunet/src/include/gnunet_container_lib.h   2012-10-23 18:12:22 UTC (rev 
24493)
@@ -832,7 +832,132 @@
   (element)->prev = NULL; } while (0)
 
 
+/* ************ Multi-DLL interface, allows DLL elements to be
+   in multiple lists at the same time *********************** */
 
+/**
+ * Insert an element at the head of a MDLL. Assumes that head, tail and
+ * element are structs with prev and next fields.
+ *
+ * @param head pointer to the head of the MDLL
+ * @param tail pointer to the tail of the MDLL
+ * @param element element to insert
+ */
+#define GNUNET_CONTAINER_MDLL_insert(mdll,head,tail,element) do {      \
+  GNUNET_assert ( ( (element)->prev_##mdll == NULL) && ((head) != (element))); 
\
+  GNUNET_assert ( ( (element)->next_##mdll == NULL) && ((tail) != (element))); 
\
+  (element)->next_##mdll = (head); \
+  (element)->prev_##mdll = NULL; \
+  if ((tail) == NULL) \
+    (tail) = element; \
+  else \
+    (head)->prev_##mdll = element; \
+  (head) = (element); } while (0)
+
+
+/**
+ * Insert an element at the tail of a MDLL. Assumes that head, tail and
+ * element are structs with prev and next fields.
+ *
+ * @param head pointer to the head of the MDLL
+ * @param tail pointer to the tail of the MDLL
+ * @param element element to insert
+ */
+#define GNUNET_CONTAINER_MDLL_insert_tail(mdll,head,tail,element) do { \
+  GNUNET_assert ( ( (element)->prev_##mdll == NULL) && ((head) != (element))); 
\
+  GNUNET_assert ( ( (element)->next_##mdll == NULL) && ((tail) != (element))); 
\
+  (element)->prev_##mdll = (tail); \
+  (element)->next_##mdll = NULL; \
+  if ((head) == NULL) \
+    (head) = element; \
+  else \
+    (tail)->next_##mdll = element; \
+  (tail) = (element); } while (0)
+
+
+/**
+ * Insert an element into a MDLL after the given other element.  Insert
+ * at the head if the other element is NULL.
+ *
+ * @param head pointer to the head of the MDLL
+ * @param tail pointer to the tail of the MDLL
+ * @param other prior element, NULL for insertion at head of MDLL
+ * @param element element to insert
+ */
+#define GNUNET_CONTAINER_MDLL_insert_after(mdll,head,tail,other,element) do { \
+  GNUNET_assert ( ( (element)->prev_##mdll == NULL) && ((head) != (element))); 
\
+  GNUNET_assert ( ( (element)->next_##mdll == NULL) && ((tail) != (element))); 
\
+  (element)->prev_##mdll = (other); \
+  if (NULL == other) \
+    { \
+      (element)->next_##mdll = (head); \
+      (head) = (element); \
+    } \
+  else \
+    { \
+      (element)->next_##mdll = (other)->next_##mdll; \
+      (other)->next_##mdll = (element); \
+    } \
+  if (NULL == (element)->next_##mdll) \
+    (tail) = (element); \
+  else \
+    (element)->next->prev_##mdll = (element); } while (0)
+
+
+/**
+ * Insert an element into a MDLL before the given other element.  Insert
+ * at the tail if the other element is NULL.
+ *
+ * @param head pointer to the head of the MDLL
+ * @param tail pointer to the tail of the MDLL
+ * @param other prior element, NULL for insertion at head of MDLL
+ * @param element element to insert
+ */
+#define GNUNET_CONTAINER_MDLL_insert_before(mdll,head,tail,other,element) do { 
\
+  GNUNET_assert ( ( (element)->prev_##mdll == NULL) && ((head) != (element))); 
\
+  GNUNET_assert ( ( (element)->next_##mdll == NULL) && ((tail) != (element))); 
\
+  (element)->next_##mdll = (other); \
+  if (NULL == other) \
+    { \
+      (element)->prev = (tail); \
+      (tail) = (element); \
+    } \
+  else \
+    { \
+      (element)->prev_##mdll = (other)->prev_##mdll; \
+      (other)->prev_##mdll = (element); \
+    } \
+  if (NULL == (element)->prev_##mdll) \
+    (head) = (element); \
+  else \
+    (element)->prev_##mdll->next_##mdll = (element); } while (0)
+
+
+/**
+ * Remove an element from a MDLL. Assumes
+ * that head, tail and element are structs
+ * with prev and next fields.
+ *
+ * @param head pointer to the head of the MDLL
+ * @param tail pointer to the tail of the MDLL
+ * @param element element to remove
+ */
+#define GNUNET_CONTAINER_MDLL_remove(mdll,head,tail,element) do {      \
+  GNUNET_assert ( ( (element)->prev_##mdll != NULL) || ((head) == (element))); 
\
+  GNUNET_assert ( ( (element)->next_##mdll != NULL) || ((tail) == (element))); 
\
+  if ((element)->prev_##mdll == NULL) \
+    (head) = (element)->next_##mdll;  \
+  else \
+    (element)->prev_##mdll->next_##mdll = (element)->next_##mdll; \
+  if ((element)->next_##mdll == NULL) \
+    (tail) = (element)->prev_##mdll;  \
+  else \
+    (element)->next_##mdll->prev_##mdll = (element)->prev_##mdll; \
+  (element)->next_##mdll = NULL; \
+  (element)->prev_##mdll = NULL; } while (0)
+
+
+
 /* ******************** Heap *************** */
 
 

Modified: gnunet/src/include/platform.h
===================================================================
--- gnunet/src/include/platform.h       2012-10-23 17:41:14 UTC (rev 24492)
+++ gnunet/src/include/platform.h       2012-10-23 18:12:22 UTC (rev 24493)
@@ -50,7 +50,7 @@
 #include <sys/types.h>
 #endif
 
-#define ALLOW_EXTRA_CHECKS GNUNET_NO
+#define ALLOW_EXTRA_CHECKS GNUNET_YES
 
 /**
  * For strptime (glibc2 needs this).