Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
get rid of the last swag in SimDag (\o/), hence the encapsulation of
authorFrederic Suter <frederic.suter@cc.in2p3.fr>
Thu, 14 Jan 2016 11:07:33 +0000 (12:07 +0100)
committerFrederic Suter <frederic.suter@cc.in2p3.fr>
Thu, 14 Jan 2016 11:10:05 +0000 (12:10 +0100)
SD_Simulate.

examples/simdag/sd_typed_tasks_test.c
src/simdag/sd_global.cpp
src/simdag/sd_task.cpp
src/simdag/simdag_private.h

index 2deda0b..32f3e59 100644 (file)
@@ -90,9 +90,11 @@ int main(int argc, char **argv)
     XBT_INFO("Task '%s' start time: %f, finish time: %f",
           SD_task_get_name(task),
           SD_task_get_start_time(task), SD_task_get_finish_time(task));
+  }
+
+  xbt_dynar_foreach(changed_tasks, ctr, task) {
     SD_task_destroy(task);
   }
-  xbt_dynar_free_container(&changed_tasks);
   SD_exit();
   return 0;
 }
index ddaddf7..bd067f6 100644 (file)
@@ -47,8 +47,6 @@ void SD_init(int *argc, char **argv)
 {
   TRACE_global_init(argc, argv);
 
-  s_SD_task_t task;
-
   xbt_assert(sd_global == NULL, "SD_init() already called");
 
   sd_global = xbt_new(s_SD_global_t, 1);
@@ -64,9 +62,8 @@ void SD_init(int *argc, char **argv)
   sd_global->initial_task_set = xbt_dynar_new(sizeof(SD_task_t), NULL);
   sd_global->executable_task_set = xbt_dynar_new(sizeof(SD_task_t), NULL);
   sd_global->completed_task_set = xbt_dynar_new(sizeof(SD_task_t), NULL);
+  sd_global->return_set = xbt_dynar_new(sizeof(SD_task_t), NULL);
 
-  sd_global->return_set =
-      xbt_swag_new(xbt_swag_offset(task, return_hookup));
   sd_global->task_number = 0;
 
   surf_init(argc, argv);
@@ -214,18 +211,6 @@ void SD_create_environment(const char *platform_file)
  */
 
 xbt_dynar_t SD_simulate(double how_long) {
-  xbt_dynar_t changed_tasks = xbt_dynar_new(sizeof(SD_task_t), NULL);
-  SD_task_t task;
-
-  SD_simulate_swag(how_long);
-  while( (task = (SD_task_t)xbt_swag_extract(sd_global->return_set)) != NULL) {
-    xbt_dynar_push(changed_tasks, &task);
-  }
-
-  return changed_tasks;
-}
-
-xbt_swag_t SD_simulate_swag(double how_long) {
   /* we stop the simulation when total_time >= how_long */
   double total_time = 0.0;
   double elapsed_time = 0.0;
@@ -245,13 +230,13 @@ xbt_swag_t SD_simulate_swag(double how_long) {
   XBT_VERB("Run simulation for %f seconds", how_long);
   sd_global->watch_point_reached = 0;
 
-  xbt_swag_reset(sd_global->return_set);
+  xbt_dynar_reset(sd_global->return_set);
 
   /* explore the runnable tasks */
   xbt_dynar_foreach(sd_global->executable_task_set , iter, task) {
     XBT_VERB("Executing task '%s'", SD_task_get_name(task));
     if (__SD_task_try_to_run(task)){
-      xbt_swag_insert(task,sd_global->return_set);
+      xbt_dynar_push(sd_global->return_set, &task);
       iter--;
     }
   }
@@ -285,9 +270,10 @@ xbt_swag_t SD_simulate_swag(double how_long) {
         XBT_DEBUG("__SD_task_just_done called on task '%s'",
                SD_task_get_name(task));
 
-        /* the state has changed */
-        XBT_INFO("%d",xbt_swag_belongs(task, sd_global->return_set));
-        xbt_swag_insert(task,sd_global->return_set);
+        /* the state has changed. Add it only if it's the first change */
+        if (xbt_dynar_search_or_negative(sd_global->return_set, &task) < 0) {
+          xbt_dynar_push(sd_global->return_set, &task);
+        }
 
         /* remove the dependencies after this task */
         xbt_dynar_foreach(task->tasks_after, depcnt, dependency) {
@@ -337,7 +323,7 @@ xbt_swag_t SD_simulate_swag(double how_long) {
               && !sd_global->watch_point_reached) {
             XBT_VERB("Executing task '%s'", SD_task_get_name(dst));
             if (__SD_task_try_to_run(dst))
-              xbt_swag_insert(dst,sd_global->return_set);
+              xbt_dynar_push(sd_global->return_set, &dst);
           }
         }
       }
@@ -352,7 +338,7 @@ xbt_swag_t SD_simulate_swag(double how_long) {
         action->unref();
         task->surf_action = NULL;
 
-        xbt_swag_insert(task,sd_global->return_set);
+        xbt_dynar_push(sd_global->return_set, &task);
       }
     }
   }
@@ -409,11 +395,11 @@ void SD_exit(void)
   xbt_free(sd_global->link_list);
   xbt_free(sd_global->recyclable_route);
 
-  XBT_DEBUG("Destroying the dynars and swags...");
+  XBT_DEBUG("Destroying the dynars ...");
   xbt_dynar_free_container(&(sd_global->initial_task_set));
   xbt_dynar_free_container(&(sd_global->executable_task_set));
   xbt_dynar_free_container(&(sd_global->completed_task_set));
-  xbt_swag_free(sd_global->return_set);
+  xbt_dynar_free_container(&(sd_global->return_set));
 
   TRACE_end();
 
index 63d2fe3..1330804 100644 (file)
@@ -35,8 +35,6 @@ void SD_task_recycle_f(void *t)
   task->kind = SD_TASK_NOT_TYPED;
   task->state= SD_NOT_SCHEDULED;
   xbt_dynar_push(sd_global->initial_task_set,&task);
-  task->return_hookup.prev = NULL;
-  task->return_hookup.next = NULL;
 
   task->marked = 0;
 
@@ -232,6 +230,7 @@ SD_task_t SD_task_create_comm_par_mxn_1d_block(const char *name, void *data,
  */
 void SD_task_destroy(SD_task_t task)
 {
+  int idx;
   XBT_DEBUG("Destroying task %s...", SD_task_get_name(task));
 
   __SD_task_remove_dependencies(task);
@@ -239,12 +238,15 @@ void SD_task_destroy(SD_task_t task)
   if (__SD_task_is_scheduled_or_runnable(task))
     __SD_task_destroy_scheduling_data(task);
 
-  xbt_swag_remove(task, sd_global->return_set);
+  idx = xbt_dynar_search_or_negative(sd_global->return_set, &task);
+  if (idx >=0) {
+    xbt_dynar_remove_at(sd_global->return_set, idx, NULL);
+  }
 
   xbt_free(task->name);
 
   if (task->surf_action != NULL)
-       task->surf_action->unref();
+    task->surf_action->unref();
 
   xbt_free(task->workstation_list);
   xbt_free(task->bytes_amount);
@@ -334,37 +336,37 @@ void SD_task_set_state(SD_task_t task, e_SD_task_state_t new_state)
   case SD_SCHEDULABLE:
     if (SD_task_get_state(task) == SD_FAILED){
         xbt_dynar_remove_at(sd_global->completed_task_set,
-            xbt_dynar_search(sd_global->completed_task_set, &task), &task);
+            xbt_dynar_search(sd_global->completed_task_set, &task), NULL);
         xbt_dynar_push(sd_global->initial_task_set,&task);
     }
     break;
   case SD_SCHEDULED:
     if (SD_task_get_state(task) == SD_RUNNABLE){
       xbt_dynar_remove_at(sd_global->executable_task_set,
-          xbt_dynar_search(sd_global->executable_task_set, &task), &task);
+          xbt_dynar_search(sd_global->executable_task_set, &task), NULL);
       xbt_dynar_push(sd_global->initial_task_set,&task);
     }
     break;
   case SD_IN_FIFO:
     xbt_dynar_remove_at(sd_global->executable_task_set,
-       xbt_dynar_search(sd_global->executable_task_set, &task), &task);
+       xbt_dynar_search(sd_global->executable_task_set, &task), NULL);
     xbt_dynar_push(sd_global->initial_task_set,&task);
     break;
   case SD_RUNNABLE:
     idx = xbt_dynar_search_or_negative(sd_global->initial_task_set, &task);
     if (idx >= 0) {
-      xbt_dynar_remove_at(sd_global->initial_task_set, idx, &task);
+      xbt_dynar_remove_at(sd_global->initial_task_set, idx, NULL);
       xbt_dynar_push(sd_global->executable_task_set,&task);
     }
     break;
   case SD_RUNNING:
     if (SD_task_get_state(task) == SD_RUNNABLE){
       xbt_dynar_remove_at(sd_global->executable_task_set,
-         xbt_dynar_search(sd_global->executable_task_set, &task), &task);
+         xbt_dynar_search(sd_global->executable_task_set, &task), NULL);
     } else {
       if (SD_task_get_state(task) == SD_IN_FIFO){
         xbt_dynar_remove_at(sd_global->initial_task_set,
-            xbt_dynar_search(sd_global->initial_task_set, &task), &task);
+            xbt_dynar_search(sd_global->initial_task_set, &task), NULL);
       }
     }
     break;
index bd796b9..f6e4b26 100644 (file)
@@ -13,7 +13,6 @@
 #include "xbt/fifo.h"
 #include "simgrid/simdag.h"
 #include "surf/surf.h"
-#include "xbt/swag.h"
 #include "xbt/mallocator.h"
 #include <stdbool.h>
 
@@ -37,7 +36,7 @@ typedef struct SD_global {
   xbt_dynar_t executable_task_set;
   xbt_dynar_t completed_task_set;
 
-  xbt_swag_t return_set;
+  xbt_dynar_t return_set;
   int task_number;
 
 } s_SD_global_t, *SD_global_t;
@@ -66,7 +65,6 @@ static inline SD_storage_priv_t SD_storage_priv(SD_storage_t storage){
 
 /* Task */
 typedef struct SD_task {
-  s_xbt_swag_hookup_t return_hookup;
   e_SD_task_state_t state;
   void *data;                   /* user data */
   char *name;
@@ -110,11 +108,6 @@ typedef struct SD_dependency {
 } s_SD_dependency_t, *SD_dependency_t;
 
 /* SimDag private functions */
-
-/* could be public, but you need to see the SD_task_t internals to use it */
-XBT_PRIVATE xbt_swag_t SD_simulate_swag(double how_long);
-
-
 XBT_PRIVATE SD_workstation_t __SD_workstation_create(const char* name);
 XBT_PRIVATE void __SD_workstation_destroy(void *workstation);
 XBT_PRIVATE int __SD_workstation_is_busy(SD_workstation_t workstation);