src/experimentation/gnunet-daemon-experimentation_scheduler.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      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      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file experimentation/gnunet-daemon-experimentation_scheduler.c
  23  * @brief experimentation daemon: execute experiments
  24  * @author Christian Grothoff
  25  * @author Matthias Wachs
  26  */
  27 #include "platform.h"
  28 #include "gnunet_getopt_lib.h"
  29 #include "gnunet_util_lib.h"
  30 #include "gnunet_core_service.h"
  31 #include "gnunet_statistics_service.h"
  32 #include "gnunet-daemon-experimentation.h"
  33
  34 enum ExperimentState
  35 {
  36         NOT_RUNNING,
  37         REQUESTED,
  38         STARTED,
  39         STOPPED
  40 };
  41
  42 struct ScheduledExperiment {
  43         struct ScheduledExperiment *next;
  44         struct ScheduledExperiment *prev;
  45
  46         struct Experiment *e;
  47         struct Node *n;
  48         int state;
  49         GNUNET_SCHEDULER_TaskIdentifier task;
  50 };
  51
  52 struct ScheduledExperiment *list_head;
  53 struct ScheduledExperiment *list_tail;
  54
  55 static unsigned int experiments_scheduled;
  56 static unsigned int experiments_requested;
  57
  58 static void
  59 request_timeout (void *cls,const struct GNUNET_SCHEDULER_TaskContext* tc)
  60 {
  61         struct ScheduledExperiment *se = cls;
  62         se->task = GNUNET_SCHEDULER_NO_TASK;
  63
  64         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Peer `%s' did not respond to request for experiment `%s'\n",
  65                         GNUNET_i2s (&se->n->id), se->e->name);
  66
  67         GNUNET_CONTAINER_DLL_remove (list_head, list_tail, se);
  68         GNUNET_free (se);
  69
  70         /* Remove experiment */
  71
  72         GNUNET_assert (experiments_requested > 0);
  73         experiments_requested --;
  74         GNUNET_STATISTICS_set (GSE_stats, "# experiments requested", experiments_requested, GNUNET_NO);
  75 }
  76
  77 static void run (void *cls,const struct GNUNET_SCHEDULER_TaskContext* tc)
  78 {
  79         struct ScheduledExperiment *se = cls;
  80         struct GNUNET_TIME_Relative end;
  81         se->task = GNUNET_SCHEDULER_NO_TASK;
  82
  83
  84         if (NOT_RUNNING == se->state)
  85         {
  86                         /* Send start message */
  87                         GNUNET_EXPERIMENT_nodes_request_start (se->n, se->e);
  88                         se->state = REQUESTED;
  89                         se->task = GNUNET_SCHEDULER_add_delayed (EXP_RESPONSE_TIMEOUT, &request_timeout, se);
  90
  91                         GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Sending start request to peer `%s' for `%s'\n",
  92                                         GNUNET_i2s (&se->n->id), se->e->name);
  93                         experiments_requested ++;
  94                         GNUNET_STATISTICS_set (GSE_stats, "# experiments requested", experiments_requested, GNUNET_NO);
  95                         return;
  96         }
  97         else if (REQUESTED == se->state)
  98         {
  99                         /* Already requested */
 100                         return;
 101         }
 102         else if (STARTED == se->state)
 103         {
 104                         /* Experiment is running */
 105                         GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Running experiment `%s' peer for `%s'\n",
 106                                         GNUNET_i2s (&se->n->id), se->e->name);
 107
 108                         /* do work here */
 109
 110                         /* Reschedule */
 111                         end = GNUNET_TIME_absolute_get_remaining(GNUNET_TIME_absolute_add (se->e->stop, se->e->frequency));
 112                         if (0 == end.rel_value)
 113                         {
 114                                 se->state = STOPPED;
 115                                 return; /* End of experiment is reached */
 116                         }
 117                 se->task = GNUNET_SCHEDULER_add_delayed (se->e->frequency, &run, se);
 118         }
 119
 120         else if (STOPPED == se->state)
 121         {
 122                         /* Experiment expired */
 123         }
 124 }
 125
 126 /**
 127  * Start the scheduler component
 128  */
 129 void
 130 GNUNET_EXPERIMENTATION_scheduler_add (struct Node *n, struct Experiment *e)
 131 {
 132         struct ScheduledExperiment *se;
 133         struct GNUNET_TIME_Relative start;
 134         struct GNUNET_TIME_Relative end;
 135
 136         start = GNUNET_TIME_absolute_get_remaining(e->start);
 137         end = GNUNET_TIME_absolute_get_remaining(e->stop);
 138         if (0 == end.rel_value)
 139                         return; /* End of experiment is reached */
 140
 141         /* Add additional checks here if required */
 142
 143         se = GNUNET_malloc (sizeof (struct ScheduledExperiment));
 144         se->state = NOT_RUNNING;
 145         se->e = e;
 146         se->n = n;
 147         if (0 == start.rel_value)
 148                         se->task = GNUNET_SCHEDULER_add_now (&run, se);
 149         else
 150                         se->task = GNUNET_SCHEDULER_add_delayed (start, &run, se);
 151
 152         GNUNET_CONTAINER_DLL_insert (list_head, list_tail, se);
 153         GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Added experiment `%s' for node to be scheduled\n",
 154                         e->name, GNUNET_i2s(&se->n->id));
 155         experiments_scheduled ++;
 156         GNUNET_STATISTICS_set (GSE_stats, "# experiments scheduled", experiments_scheduled, GNUNET_NO);
 157 }
 158
 159 /**
 160  * Start the scheduler component
 161  */
 162 void
 163 GNUNET_EXPERIMENTATION_scheduler_start ()
 164 {
 165         experiments_requested = 0;
 166         experiments_scheduled = 0;
 167 }
 168
 169
 170 /**
 171  * Stop the scheduler component
 172  */
 173 void
 174 GNUNET_EXPERIMENTATION_scheduler_stop ()
 175 {
 176         struct ScheduledExperiment *cur;
 177         struct ScheduledExperiment *next;
 178
 179         next = list_head;
 180         while (NULL != (cur = next))
 181         {
 182                         next = cur->next;
 183                         GNUNET_CONTAINER_DLL_remove (list_head, list_tail, cur);
 184                         if (GNUNET_SCHEDULER_NO_TASK != cur->task)
 185                         {
 186                                         GNUNET_SCHEDULER_cancel (cur->task);
 187                                         cur->task = GNUNET_SCHEDULER_NO_TASK;
 188                         }
 189                         GNUNET_free (cur);
 190                         GNUNET_assert (experiments_scheduled > 0);
 191                         experiments_scheduled --;
 192                         GNUNET_STATISTICS_set (GSE_stats, "# experiments scheduled", experiments_scheduled, GNUNET_NO);
 193         }
 194 }
 195
 196 /* end of gnunet-daemon-experimentation_scheduler.c */