making GNUNET_SCHEDULER_cancel() perform in O(1) instead of O(n) to help or even fully address #3247

4 files changed, 47 insertions, 47 deletions

diff --git a/src/arm/arm_api.c b/src/arm/arm_api.c
index 1b83c3106..4b68f19de 100644
--- a/src/arm/arm_api.c
+++ b/src/arm/arm_api.c
@@ -91,7 +91,7 @@ struct GNUNET_ARM_Handle
   /**
    * ID of the reconnect task (if any).
    */
-  GNUNET_SCHEDULER_TaskIdentifier reconnect_task;
+  struct GNUNET_SCHEDULER_Task * reconnect_task;
 
   /**
    * Current delay we use for re-trying to connect to core.
@@ -166,7 +166,7 @@ struct ARMControlMessage
   /**
    * Task to run when request times out.
    */
-  GNUNET_SCHEDULER_TaskIdentifier timeout_task_id;
+  struct GNUNET_SCHEDULER_Task * timeout_task_id;
 
   /**
    * Flags for passing std descriptors to ARM (when starting ARM).
@@ -212,7 +212,7 @@ reconnect_arm_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_ARM_Handle *h = cls;
 
-  h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
+  h->reconnect_task = NULL;
   LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to ARM service after delay\n");
   reconnect_arm (h);
 }
@@ -240,7 +240,7 @@ reconnect_arm_later (struct GNUNET_ARM_Handle *h)
     h->client = NULL;
   }
   h->currently_down = GNUNET_YES;
-  GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == h->reconnect_task);
+  GNUNET_assert (NULL == h->reconnect_task);
   h->reconnect_task =
       GNUNET_SCHEDULER_add_delayed (h->retry_backoff, &reconnect_arm_task, h);
   /* Don't clear pending messages on disconnection, deliver them later
@@ -408,7 +408,7 @@ client_notify_handler (void *cls,
     fail = GNUNET_YES;
     break;
   }
-  GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != cm->timeout_task_id);
+  GNUNET_assert (NULL != cm->timeout_task_id);
   GNUNET_SCHEDULER_cancel (cm->timeout_task_id);
   GNUNET_CONTAINER_DLL_remove (h->control_sent_head,
                                h->control_sent_tail, cm);
@@ -493,7 +493,7 @@ transmit_arm_message (void *cls, size_t size, void *buf)
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "transmit_arm_message is running with %p buffer of size %lu. ARM is known to be %s\n",
        buf, size, h->currently_down ? "unconnected" : "connected");
-  GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == h->reconnect_task);
+  GNUNET_assert (NULL == h->reconnect_task);
   h->cth = NULL;
   if ((GNUNET_YES == h->currently_down) && (NULL != buf))
   {
@@ -643,7 +643,7 @@ GNUNET_ARM_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
   h = GNUNET_new (struct GNUNET_ARM_Handle);
   h->cfg = GNUNET_CONFIGURATION_dup (cfg);
   h->currently_down = GNUNET_YES;
-  h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
+  h->reconnect_task = NULL;
   h->conn_status = conn_status;
   h->conn_status_cls = cls;
   if (GNUNET_OK != reconnect_arm (h))
@@ -680,7 +680,7 @@ GNUNET_ARM_disconnect_and_free (struct GNUNET_ARM_Handle *h)
     else
       GNUNET_CONTAINER_DLL_remove (h->control_sent_head,
                                    h->control_sent_tail, cm);
-    GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != cm->timeout_task_id);
+    GNUNET_assert (NULL != cm->timeout_task_id);
     GNUNET_SCHEDULER_cancel (cm->timeout_task_id);
     if (NULL != cm->result_cont)
       cm->result_cont (cm->cont_cls, GNUNET_ARM_REQUEST_DISCONNECTED,
@@ -694,10 +694,10 @@ GNUNET_ARM_disconnect_and_free (struct GNUNET_ARM_Handle *h)
     GNUNET_CLIENT_disconnect (h->client);
     h->client = NULL;
   }
-  if (GNUNET_SCHEDULER_NO_TASK != h->reconnect_task)
+  if (NULL != h->reconnect_task)
   {
     GNUNET_SCHEDULER_cancel (h->reconnect_task);
-    h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
+    h->reconnect_task = NULL;
   }
   if (GNUNET_NO == h->service_test_is_active)
   {
@@ -984,10 +984,10 @@ GNUNET_ARM_request_service_start (struct GNUNET_ARM_Handle *h,
         GNUNET_CLIENT_disconnect (h->client);
         h->client = NULL;
       }
-      if (GNUNET_SCHEDULER_NO_TASK != h->reconnect_task)
+      if (NULL != h->reconnect_task)
       {
         GNUNET_SCHEDULER_cancel (h->reconnect_task);
-        h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
+        h->reconnect_task = NULL;
       }
 
       LOG (GNUNET_ERROR_TYPE_DEBUG,
diff --git a/src/arm/arm_monitor_api.c b/src/arm/arm_monitor_api.c
index 676543f26..c03f5df0f 100644
--- a/src/arm/arm_monitor_api.c
+++ b/src/arm/arm_monitor_api.c
@@ -57,7 +57,7 @@ struct GNUNET_ARM_MonitorHandle
   /**
    * ID of the reconnect task (if any).
    */
-  GNUNET_SCHEDULER_TaskIdentifier reconnect_task;
+  struct GNUNET_SCHEDULER_Task * reconnect_task;
 
   /**
    * Current delay we use for re-trying to connect to core.
@@ -82,7 +82,7 @@ struct GNUNET_ARM_MonitorHandle
   /**
    * ID of a task to run if we fail to get a reply to the init message in time.
    */
-  GNUNET_SCHEDULER_TaskIdentifier init_timeout_task_id;
+  struct GNUNET_SCHEDULER_Task * init_timeout_task_id;
 };
 
 static void
@@ -102,7 +102,7 @@ reconnect_arm_monitor_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext
 {
   struct GNUNET_ARM_MonitorHandle *h = cls;
 
-  h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
+  h->reconnect_task = NULL;
   LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to ARM service for monitoring after delay\n");
   reconnect_arm_monitor (h);
 }
@@ -129,13 +129,13 @@ reconnect_arm_monitor_later (struct GNUNET_ARM_MonitorHandle *h)
     h->monitor = NULL;
   }
 
-  if (GNUNET_SCHEDULER_NO_TASK != h->init_timeout_task_id)
+  if (NULL != h->init_timeout_task_id)
   {
     GNUNET_SCHEDULER_cancel (h->init_timeout_task_id);
-    h->init_timeout_task_id = GNUNET_SCHEDULER_NO_TASK;
+    h->init_timeout_task_id = NULL;
   }
 
-  GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == h->reconnect_task);
+  GNUNET_assert (NULL == h->reconnect_task);
   h->reconnect_task =
       GNUNET_SCHEDULER_add_delayed (h->retry_backoff, &reconnect_arm_monitor_task, h);
 
@@ -156,7 +156,7 @@ init_timeout_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Init message timed out\n");
 
-  h->init_timeout_task_id = GNUNET_SCHEDULER_NO_TASK;
+  h->init_timeout_task_id = NULL;
   reconnect_arm_monitor_later (h);
 }
 
@@ -176,8 +176,8 @@ transmit_monitoring_init_message (void *cls, size_t size, void *buf)
   struct GNUNET_MessageHeader *msg;
   uint16_t msize;
 
-  GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == h->reconnect_task);
-  GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == h->init_timeout_task_id);
+  GNUNET_assert (NULL == h->reconnect_task);
+  GNUNET_assert (NULL == h->init_timeout_task_id);
   h->cth = NULL;
   if (NULL == buf)
   {
@@ -254,8 +254,8 @@ GNUNET_ARM_monitor (const struct GNUNET_CONFIGURATION_Handle *cfg,
   h = GNUNET_new (struct GNUNET_ARM_MonitorHandle);
   h->cfg = GNUNET_CONFIGURATION_dup (cfg);
   h->currently_down = GNUNET_YES;
-  h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
-  h->init_timeout_task_id = GNUNET_SCHEDULER_NO_TASK;
+  h->reconnect_task = NULL;
+  h->init_timeout_task_id = NULL;
   h->service_status = cont;
   h->cls = cont_cls;
   if (GNUNET_OK != reconnect_arm_monitor (h))
@@ -281,20 +281,20 @@ GNUNET_ARM_monitor_disconnect_and_free (struct GNUNET_ARM_MonitorHandle *h)
     GNUNET_CLIENT_notify_transmit_ready_cancel (h->cth);
     h->cth = NULL;
   }
-  if (GNUNET_SCHEDULER_NO_TASK != h->init_timeout_task_id)
+  if (NULL != h->init_timeout_task_id)
   {
     GNUNET_SCHEDULER_cancel (h->init_timeout_task_id);
-    h->init_timeout_task_id = GNUNET_SCHEDULER_NO_TASK;
+    h->init_timeout_task_id = NULL;
   }
   if (NULL != h->monitor)
   {
     GNUNET_CLIENT_disconnect (h->monitor);
     h->monitor = NULL;
   }
-  if (GNUNET_SCHEDULER_NO_TASK != h->reconnect_task)
+  if (NULL != h->reconnect_task)
   {
     GNUNET_SCHEDULER_cancel (h->reconnect_task);
-    h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
+    h->reconnect_task = NULL;
   }
   GNUNET_CONFIGURATION_destroy (h->cfg);
   GNUNET_free (h);
@@ -335,10 +335,10 @@ monitor_notify_handler (void *cls, const struct GNUNET_MessageHeader *msg)
       reconnect_arm_monitor_later (h);
       return;
     }
-    if (GNUNET_SCHEDULER_NO_TASK != h->init_timeout_task_id)
+    if (NULL != h->init_timeout_task_id)
     {
       GNUNET_SCHEDULER_cancel (h->init_timeout_task_id);
-      h->init_timeout_task_id = GNUNET_SCHEDULER_NO_TASK;
+      h->init_timeout_task_id = NULL;
     }
     res = (const struct GNUNET_ARM_StatusMessage *) msg;
     LOG (GNUNET_ERROR_TYPE_DEBUG,
diff --git a/src/arm/gnunet-service-arm.c b/src/arm/gnunet-service-arm.c
index c6259c273..630816d1d 100644
--- a/src/arm/gnunet-service-arm.c
+++ b/src/arm/gnunet-service-arm.c
@@ -81,7 +81,7 @@ struct ServiceListeningInfo
   /**
    * Task doing the accepting.
    */
-  GNUNET_SCHEDULER_TaskIdentifier accept_task;
+  struct GNUNET_SCHEDULER_Task * accept_task;
 
 };
 
@@ -200,13 +200,13 @@ static char *final_option;
 /**
  * ID of task called whenever we get a SIGCHILD.
  */
-static GNUNET_SCHEDULER_TaskIdentifier child_death_task;
+static struct GNUNET_SCHEDULER_Task * child_death_task;
 
 /**
  * ID of task called whenever the timeout for restarting a child
  * expires.
  */
-static GNUNET_SCHEDULER_TaskIdentifier child_restart_task;
+static struct GNUNET_SCHEDULER_Task * child_restart_task;
 
 /**
  * Pipe used to communicate shutdown via signal.
@@ -421,10 +421,10 @@ start_process (struct ServiceList *sl,
     {
       GNUNET_array_append (lsocks, ls,
                            GNUNET_NETWORK_get_fd (sli->listen_socket));
-      if (sli->accept_task != GNUNET_SCHEDULER_NO_TASK)
+      if (sli->accept_task != NULL)
         {
           GNUNET_SCHEDULER_cancel (sli->accept_task);
-          sli->accept_task = GNUNET_SCHEDULER_NO_TASK;
+          sli->accept_task = NULL;
         }
     }
 #if WINDOWS
@@ -586,7 +586,7 @@ accept_connection (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   struct ServiceListeningInfo *sli = cls;
   struct ServiceList *sl = sli->sl;
 
-  sli->accept_task = GNUNET_SCHEDULER_NO_TASK;
+  sli->accept_task = NULL;
   GNUNET_assert (GNUNET_NO == in_shutdown);
   if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
     return;
@@ -971,10 +971,10 @@ do_shutdown ()
       GNUNET_SERVER_destroy (server);
       server = NULL;
     }
-  if (GNUNET_SCHEDULER_NO_TASK != child_death_task)
+  if (NULL != child_death_task)
     {
       GNUNET_SCHEDULER_cancel (child_death_task);
-      child_death_task = GNUNET_SCHEDULER_NO_TASK;
+      child_death_task = NULL;
     }
 }
 
@@ -1015,10 +1015,10 @@ shutdown_task (void *cls,
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "First shutdown phase\n");
-  if (GNUNET_SCHEDULER_NO_TASK != child_restart_task)
+  if (NULL != child_restart_task)
   {
     GNUNET_SCHEDULER_cancel (child_restart_task);
-    child_restart_task = GNUNET_SCHEDULER_NO_TASK;
+    child_restart_task = NULL;
   }
   in_shutdown = GNUNET_YES;
   /* first, stop listening */
@@ -1028,10 +1028,10 @@ shutdown_task (void *cls,
       {
         GNUNET_CONTAINER_DLL_remove (pos->listen_head,
                                      pos->listen_tail, sli);
-        if (sli->accept_task != GNUNET_SCHEDULER_NO_TASK)
+        if (sli->accept_task != NULL)
           {
             GNUNET_SCHEDULER_cancel (sli->accept_task);
-            sli->accept_task = GNUNET_SCHEDULER_NO_TASK;
+            sli->accept_task = NULL;
           }
         GNUNET_break (GNUNET_OK ==
                       GNUNET_NETWORK_socket_close (sli->listen_socket));
@@ -1082,7 +1082,7 @@ delayed_restart_task (void *cls,
   struct GNUNET_TIME_Relative lowestRestartDelay;
   struct ServiceListeningInfo *sli;
 
-  child_restart_task = GNUNET_SCHEDULER_NO_TASK;
+  child_restart_task = NULL;
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
   GNUNET_assert (GNUNET_NO == in_shutdown);
@@ -1110,7 +1110,7 @@ delayed_restart_task (void *cls,
       {
         /* process is run on-demand, ensure it is re-started if there is demand */
         for (sli = sl->listen_head; NULL != sli; sli = sli->next)
-          if (GNUNET_SCHEDULER_NO_TASK == sli->accept_task)
+          if (NULL == sli->accept_task)
           {
             /* accept was actually paused, so start it again */
             sli->accept_task =
@@ -1164,7 +1164,7 @@ maint_child_death (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   const struct GNUNET_DISK_FileHandle *pr;
 
   pr = GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ);
-  child_death_task = GNUNET_SCHEDULER_NO_TASK;
+  child_death_task = NULL;
   if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY))
     {
       /* shutdown scheduled us, ignore! */
@@ -1239,7 +1239,7 @@ maint_child_death (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
           /* process can still be re-started on-demand, ensure it is re-started if there is demand */
           for (sli = pos->listen_head; NULL != sli; sli = sli->next)
           {
-            GNUNET_break (GNUNET_SCHEDULER_NO_TASK == sli->accept_task);
+            GNUNET_break (NULL == sli->accept_task);
             sli->accept_task =
                 GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                     sli->listen_socket, &accept_connection, sli);
@@ -1255,7 +1255,7 @@ maint_child_death (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
           /* schedule restart */
           pos->restart_at = GNUNET_TIME_relative_to_absolute (pos->backoff);
           pos->backoff = GNUNET_TIME_STD_BACKOFF (pos->backoff);
-          if (GNUNET_SCHEDULER_NO_TASK != child_restart_task)
+          if (NULL != child_restart_task)
             GNUNET_SCHEDULER_cancel (child_restart_task);
           child_restart_task = GNUNET_SCHEDULER_add_with_priority (
             GNUNET_SCHEDULER_PRIORITY_IDLE, &delayed_restart_task, NULL);
diff --git a/src/arm/test_exponential_backoff.c b/src/arm/test_exponential_backoff.c
index 7a552cc7c..17aa8a04c 100644
--- a/src/arm/test_exponential_backoff.c
+++ b/src/arm/test_exponential_backoff.c
@@ -90,7 +90,7 @@ struct ShutdownContext
   /**
    * Task set up to cancel the shutdown request on timeout.
    */
-  GNUNET_SCHEDULER_TaskIdentifier cancel_task;
+  struct GNUNET_SCHEDULER_Task * cancel_task;
 
   /**
    * Task to call once shutdown complete