From: Martin Quinson <martin.quinson@loria.fr>
Date: Thu, 20 Oct 2011 13:20:32 +0000 (+0200)
Subject: reduce the amount of damn paranoid checks in simdag. Valgrind is here to report the... 
X-Git-Tag: exp_20120216~544
X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/commitdiff_plain/f3a6ed3541c05cff15e5634721f1029f8b28e7e2?hp=69a8b72d8b6ded47e92595e5d0d05aed5623dc36

reduce the amount of damn paranoid checks in simdag. Valgrind is here to report the errors, nowadays
---

diff --git a/src/simdag/private.h b/src/simdag/private.h
index 88bb0a92d3..7b55cfa84f 100644
--- a/src/simdag/private.h
+++ b/src/simdag/private.h
@@ -17,9 +17,6 @@
 #include "xbt/mallocator.h"
 #include <stdbool.h>
 
-#define SD_INITIALISED() (sd_global != NULL)
-#define SD_CHECK_INIT_DONE() xbt_assert(SD_INITIALISED(), "Call SD_init() first");
-
 /* Global variables */
 
 typedef struct SD_global {
diff --git a/src/simdag/sd_global.c b/src/simdag/sd_global.c
index eb0b892ca1..8bbdbdf215 100644
--- a/src/simdag/sd_global.c
+++ b/src/simdag/sd_global.c
@@ -52,7 +52,7 @@ void SD_init(int *argc, char **argv)
 
   s_SD_task_t task;
 
-  xbt_assert(!SD_INITIALISED(), "SD_init() already called");
+  xbt_assert(sd_global == NULL, "SD_init() already called");
 
   /* Connect our log channels: that must be done manually under windows */
   XBT_LOG_CONNECT(sd_kernel, sd);
@@ -123,45 +123,38 @@ void SD_application_reinit(void)
 
   s_SD_task_t task;
 
-  if (SD_INITIALISED()) {
-    XBT_DEBUG("Recreating the swags...");
-    xbt_swag_free(sd_global->not_scheduled_task_set);
-    xbt_swag_free(sd_global->schedulable_task_set);
-    xbt_swag_free(sd_global->scheduled_task_set);
-    xbt_swag_free(sd_global->runnable_task_set);
-    xbt_swag_free(sd_global->in_fifo_task_set);
-    xbt_swag_free(sd_global->running_task_set);
-    xbt_swag_free(sd_global->done_task_set);
-    xbt_swag_free(sd_global->failed_task_set);
-
-    sd_global->not_scheduled_task_set =
-        xbt_swag_new(xbt_swag_offset(task, state_hookup));
-    sd_global->schedulable_task_set =
-        xbt_swag_new(xbt_swag_offset(task, state_hookup));
-    sd_global->scheduled_task_set =
-        xbt_swag_new(xbt_swag_offset(task, state_hookup));
-    sd_global->runnable_task_set =
-        xbt_swag_new(xbt_swag_offset(task, state_hookup));
-    sd_global->in_fifo_task_set =
-        xbt_swag_new(xbt_swag_offset(task, state_hookup));
-    sd_global->running_task_set =
-        xbt_swag_new(xbt_swag_offset(task, state_hookup));
-    sd_global->done_task_set =
-        xbt_swag_new(xbt_swag_offset(task, state_hookup));
-    sd_global->failed_task_set =
-        xbt_swag_new(xbt_swag_offset(task, state_hookup));
-    sd_global->task_number = 0;
+  XBT_DEBUG("Recreating the swags...");
+  xbt_swag_free(sd_global->not_scheduled_task_set);
+  xbt_swag_free(sd_global->schedulable_task_set);
+  xbt_swag_free(sd_global->scheduled_task_set);
+  xbt_swag_free(sd_global->runnable_task_set);
+  xbt_swag_free(sd_global->in_fifo_task_set);
+  xbt_swag_free(sd_global->running_task_set);
+  xbt_swag_free(sd_global->done_task_set);
+  xbt_swag_free(sd_global->failed_task_set);
+
+  sd_global->not_scheduled_task_set =
+      xbt_swag_new(xbt_swag_offset(task, state_hookup));
+  sd_global->schedulable_task_set =
+      xbt_swag_new(xbt_swag_offset(task, state_hookup));
+  sd_global->scheduled_task_set =
+      xbt_swag_new(xbt_swag_offset(task, state_hookup));
+  sd_global->runnable_task_set =
+      xbt_swag_new(xbt_swag_offset(task, state_hookup));
+  sd_global->in_fifo_task_set =
+      xbt_swag_new(xbt_swag_offset(task, state_hookup));
+  sd_global->running_task_set =
+      xbt_swag_new(xbt_swag_offset(task, state_hookup));
+  sd_global->done_task_set =
+      xbt_swag_new(xbt_swag_offset(task, state_hookup));
+  sd_global->failed_task_set =
+      xbt_swag_new(xbt_swag_offset(task, state_hookup));
+  sd_global->task_number = 0;
 
 #ifdef HAVE_JEDULE
-    jedule_sd_cleanup();
-    jedule_sd_init();
+  jedule_sd_cleanup();
+  jedule_sd_init();
 #endif
-
-  } else {
-    XBT_WARN("SD_application_reinit called before initialization of SimDag");
-    /* we cannot use exceptions here because xbt is not running! */
-  }
-
 }
 
 /**
@@ -195,7 +188,7 @@ void SD_create_environment(const char *platform_file)
   surf_parse_reset_callbacks();
   // Add config callbacks
   surf_parse_add_callback_config();
-  SD_CHECK_INIT_DONE();
+
   parse_platform_file(platform_file);
   surf_config_models_create_elms();
 
@@ -254,8 +247,6 @@ xbt_swag_t SD_simulate_swag(double how_long) {
   unsigned int iter, depcnt;
   static int first_time = 1;
 
-  SD_CHECK_INIT_DONE();
-
    if (first_time) {
      XBT_VERB("Starting simulation...");
 
@@ -366,7 +357,8 @@ xbt_swag_t SD_simulate_swag(double how_long) {
 
   if (!sd_global->watch_point_reached && how_long<0){
     if (xbt_swag_size(sd_global->done_task_set) < sd_global->task_number){
-        XBT_WARN("Simulation is finished but some tasks are still not done");
+        XBT_WARN("Simulation is finished but %d tasks are still not done",
+            (sd_global->task_number - xbt_swag_size(sd_global->done_task_set)));
       	xbt_swag_foreach_safe (task, task_safe,sd_global->not_scheduled_task_set){
                 XBT_WARN("%s is in SD_NOT_SCHEDULED state", SD_task_get_name(task));
 		}
@@ -391,10 +383,7 @@ xbt_swag_t SD_simulate_swag(double how_long) {
  *
  * \return the current clock, in second
  */
-double SD_get_clock(void)
-{
-  SD_CHECK_INIT_DONE();
-
+double SD_get_clock(void) {
   return surf_get_clock();
 }
 
@@ -412,35 +401,34 @@ void SD_exit(void)
   TRACE_surf_release();
 #endif
 
-  if (SD_INITIALISED()) {
-    xbt_mallocator_free(sd_global->task_mallocator);
+  xbt_mallocator_free(sd_global->task_mallocator);
 
-    XBT_DEBUG("Destroying workstation and link arrays if necessary...");
-    if (sd_global->workstation_list != NULL)
-      xbt_free(sd_global->workstation_list);
+  XBT_DEBUG("Destroying workstation and link arrays if necessary...");
+  if (sd_global->workstation_list != NULL)
+    xbt_free(sd_global->workstation_list);
 
-    if (sd_global->link_list != NULL)
-      xbt_free(sd_global->link_list);
+  if (sd_global->link_list != NULL)
+    xbt_free(sd_global->link_list);
 
-    if (sd_global->recyclable_route != NULL)
-      xbt_free(sd_global->recyclable_route);
+  if (sd_global->recyclable_route != NULL)
+    xbt_free(sd_global->recyclable_route);
 
-    XBT_DEBUG("Destroying the swags...");
-    xbt_swag_free(sd_global->not_scheduled_task_set);
-    xbt_swag_free(sd_global->schedulable_task_set);
-    xbt_swag_free(sd_global->scheduled_task_set);
-    xbt_swag_free(sd_global->runnable_task_set);
-    xbt_swag_free(sd_global->in_fifo_task_set);
-    xbt_swag_free(sd_global->running_task_set);
-    xbt_swag_free(sd_global->done_task_set);
-    xbt_swag_free(sd_global->failed_task_set);
-    xbt_swag_free(sd_global->return_set);
+  XBT_DEBUG("Destroying the swags...");
+  xbt_swag_free(sd_global->not_scheduled_task_set);
+  xbt_swag_free(sd_global->schedulable_task_set);
+  xbt_swag_free(sd_global->scheduled_task_set);
+  xbt_swag_free(sd_global->runnable_task_set);
+  xbt_swag_free(sd_global->in_fifo_task_set);
+  xbt_swag_free(sd_global->running_task_set);
+  xbt_swag_free(sd_global->done_task_set);
+  xbt_swag_free(sd_global->failed_task_set);
+  xbt_swag_free(sd_global->return_set);
 
-    XBT_DEBUG("Exiting Surf...");
-    surf_exit();
+  XBT_DEBUG("Exiting Surf...");
+  surf_exit();
 
-    xbt_free(sd_global);
-    sd_global = NULL;
+  xbt_free(sd_global);
+  sd_global = NULL;
 
 #ifdef HAVE_TRACING
   TRACE_end();
@@ -449,11 +437,6 @@ void SD_exit(void)
   jedule_sd_dump();
   jedule_sd_cleanup();
 #endif
-
-  } else {
-    XBT_WARN("SD_exit() called, but SimDag is not running");
-    /* we cannot use exceptions here because xbt is not running! */
-  }
 }
 
 /**
diff --git a/src/simdag/sd_link.c b/src/simdag/sd_link.c
index c69d93c745..f3a3750fa7 100644
--- a/src/simdag/sd_link.c
+++ b/src/simdag/sd_link.c
@@ -18,9 +18,6 @@ SD_link_t __SD_link_create(void *surf_link, void *data)
   SD_link_t link;
   const char *name;
 
-  SD_CHECK_INIT_DONE();
-  xbt_assert(surf_link != NULL, "surf_link is NULL !");
-
   link = xbt_new(s_SD_link_t, 1);
   link->surf_link = surf_link;
   link->data = data;            /* user data */
@@ -51,9 +48,6 @@ const SD_link_t *SD_link_get_list(void)
   void **data;
   int i;
 
-  SD_CHECK_INIT_DONE();
-  xbt_assert(SD_link_get_number() > 0, "There is no link!");
-
   if (sd_global->link_list == NULL) {   /* this is the first time the function is called */
     sd_global->link_list = xbt_new(SD_link_t, link_lib->count);
 
@@ -73,7 +67,6 @@ const SD_link_t *SD_link_get_list(void)
  */
 int SD_link_get_number(void)
 {
-  SD_CHECK_INIT_DONE();
   return link_lib->count;
 }
 
@@ -86,8 +79,6 @@ int SD_link_get_number(void)
  */
 void *SD_link_get_data(SD_link_t link)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(link != NULL, "Invalid parameter");
   return link->data;
 }
 
@@ -103,8 +94,6 @@ void *SD_link_get_data(SD_link_t link)
  */
 void SD_link_set_data(SD_link_t link, void *data)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(link != NULL, "Invalid parameter");
   link->data = data;
 }
 
@@ -116,8 +105,6 @@ void SD_link_set_data(SD_link_t link, void *data)
  */
 const char *SD_link_get_name(SD_link_t link)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(link != NULL, "Invalid parameter");
   return surf_resource_name(link->surf_link);
 }
 
@@ -129,8 +116,6 @@ const char *SD_link_get_name(SD_link_t link)
  */
 double SD_link_get_current_bandwidth(SD_link_t link)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(link != NULL, "Invalid parameter");
   return surf_workstation_model->extension.workstation.
       get_link_bandwidth(link->surf_link);
 }
@@ -143,8 +128,6 @@ double SD_link_get_current_bandwidth(SD_link_t link)
  */
 double SD_link_get_current_latency(SD_link_t link)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(link != NULL, "Invalid parameter");
   return surf_workstation_model->extension.workstation.
       get_link_latency(link->surf_link);
 }
@@ -159,8 +142,6 @@ double SD_link_get_current_latency(SD_link_t link)
  */
 e_SD_link_sharing_policy_t SD_link_get_sharing_policy(SD_link_t link)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(link != NULL, "Invalid parameter");
   return link->sharing_policy;
 }
 
@@ -169,8 +150,6 @@ e_SD_link_sharing_policy_t SD_link_get_sharing_policy(SD_link_t link)
  */
 void __SD_link_destroy(void *link)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(link != NULL, "Invalid parameter");
   /* link->surf_link is freed by surf_exit and link->data is freed by the user */
   xbt_free(link);
 }
diff --git a/src/simdag/sd_task.c b/src/simdag/sd_task.c
index f1d202feca..bc6d454bbc 100644
--- a/src/simdag/sd_task.c
+++ b/src/simdag/sd_task.c
@@ -171,8 +171,6 @@ void SD_task_destroy(SD_task_t task)
  */
 void *SD_task_get_data(SD_task_t task)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(task != NULL, "Invalid parameter");
   return task->data;
 }
 
@@ -188,8 +186,6 @@ void *SD_task_get_data(SD_task_t task)
  */
 void SD_task_set_data(SD_task_t task, void *data)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(task != NULL, "Invalid parameter");
   task->data = data;
 }
 
@@ -203,8 +199,6 @@ void SD_task_set_data(SD_task_t task, void *data)
  */
 e_SD_task_state_t SD_task_get_state(SD_task_t task)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(task != NULL, "Invalid parameter");
   return task->state;
 }
 
@@ -267,8 +261,6 @@ void __SD_task_set_state(SD_task_t task, e_SD_task_state_t new_state)
  */
 const char *SD_task_get_name(SD_task_t task)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(task != NULL, "Invalid parameter");
   return task->name;
 }
 
@@ -290,8 +282,6 @@ xbt_dynar_t SD_task_get_parents(SD_task_t task)
   unsigned int i;
   xbt_dynar_t parents;
   SD_dependency_t dep;
-  SD_CHECK_INIT_DONE();
-  xbt_assert(task != NULL, "Invalid parameter");
 
   parents = xbt_dynar_new(sizeof(SD_task_t), NULL);
   xbt_dynar_foreach(task->tasks_before, i, dep) {
@@ -310,8 +300,6 @@ xbt_dynar_t SD_task_get_children(SD_task_t task)
   unsigned int i;
   xbt_dynar_t children;
   SD_dependency_t dep;
-  SD_CHECK_INIT_DONE();
-  xbt_assert(task != NULL, "Invalid parameter");
 
   children = xbt_dynar_new(sizeof(SD_task_t), NULL);
   xbt_dynar_foreach(task->tasks_after, i, dep) {
@@ -328,10 +316,6 @@ xbt_dynar_t SD_task_get_children(SD_task_t task)
  */
 int SD_task_get_workstation_count(SD_task_t task)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(task != NULL, "Invalid parameter");
-  //xbt_assert(task->state_set != sd_global->scheduled_task_set,
-  //           "Unscheduled task %s", task->name);
   return task->workstation_nb;
 }
 
@@ -343,10 +327,6 @@ int SD_task_get_workstation_count(SD_task_t task)
  */
 SD_workstation_t *SD_task_get_workstation_list(SD_task_t task)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(task != NULL, "Invalid parameter");
-  //xbt_assert(task->state_set != sd_global->scheduled_task_set,
-  //           "Unscheduled task %s", task->name);
   return task->workstation_list;
 }
 
@@ -359,8 +339,6 @@ SD_workstation_t *SD_task_get_workstation_list(SD_task_t task)
  */
 double SD_task_get_amount(SD_task_t task)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(task != NULL, "Invalid parameter");
   return task->amount;
 }
 
@@ -373,9 +351,6 @@ double SD_task_get_amount(SD_task_t task)
  */
 double SD_task_get_remaining_amount(SD_task_t task)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(task != NULL, "Invalid parameter");
-
   if (task->surf_action)
     return surf_workstation_model->get_remains(task->surf_action);
   else
@@ -489,9 +464,6 @@ void SD_task_dependency_add(const char *name, void *data, SD_task_t src,
   int i;
   SD_dependency_t dependency;
 
-  SD_CHECK_INIT_DONE();
-  xbt_assert(src != NULL && dst != NULL, "Invalid parameter");
-
   dynar = src->tasks_after;
   length = xbt_dynar_length(dynar);
 
@@ -567,7 +539,6 @@ int SD_task_dependency_exists(SD_task_t src, SD_task_t dst)
   unsigned int counter;
   SD_dependency_t dependency;
 
-  SD_CHECK_INIT_DONE();
   xbt_assert(src != NULL
               || dst != NULL,
               "Invalid parameter: both src and dst are NULL");
@@ -603,9 +574,6 @@ void SD_task_dependency_remove(SD_task_t src, SD_task_t dst)
   int i;
   SD_dependency_t dependency;
 
-  SD_CHECK_INIT_DONE();
-  xbt_assert(src != NULL && dst != NULL, "Invalid parameter");
-
   /* remove the dependency from src->tasks_after */
   dynar = src->tasks_after;
   length = xbt_dynar_length(dynar);
@@ -677,10 +645,6 @@ void *SD_task_dependency_get_data(SD_task_t src, SD_task_t dst)
   int i;
   SD_dependency_t dependency;
 
-
-  SD_CHECK_INIT_DONE();
-  xbt_assert(src != NULL && dst != NULL, "Invalid parameter");
-
   dynar = src->tasks_after;
   length = xbt_dynar_length(dynar);
 
@@ -731,9 +695,6 @@ static void __SD_print_watch_points(SD_task_t task)
  */
 void SD_task_watch(SD_task_t task, e_SD_task_state_t state)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(task != NULL, "Invalid parameter");
-
   if (state & SD_NOT_SCHEDULED)
     THROWF(arg_error, 0,
            "Cannot add a watch point for state SD_NOT_SCHEDULED");
@@ -751,8 +712,6 @@ void SD_task_watch(SD_task_t task, e_SD_task_state_t state)
  */
 void SD_task_unwatch(SD_task_t task, e_SD_task_state_t state)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(task != NULL, "Invalid parameter");
   xbt_assert(state != SD_NOT_SCHEDULED,
               "SimDag error: Cannot have a watch point for state SD_NOT_SCHEDULED");
 
@@ -782,9 +741,7 @@ double SD_task_get_execution_time(SD_task_t task,
 {
   double time, max_time = 0.0;
   int i, j;
-  SD_CHECK_INIT_DONE();
-  xbt_assert(task != NULL && workstation_nb > 0
-              && workstation_list != NULL, "Invalid parameter");
+  xbt_assert(workstation_nb > 0, "Invalid parameter");
 
   /* the task execution time is the maximum execution time of the parallel tasks */
 
@@ -814,8 +771,6 @@ double SD_task_get_execution_time(SD_task_t task,
 
 static XBT_INLINE void SD_task_do_schedule(SD_task_t task)
 {
-  SD_CHECK_INIT_DONE();
-
   if (!__SD_task_is_not_scheduled(task) && !__SD_task_is_schedulable(task))
     THROWF(arg_error, 0, "Task '%s' has already been scheduled",
            SD_task_get_name(task));
@@ -897,9 +852,6 @@ void SD_task_schedule(SD_task_t task, int workstation_count,
  */
 void SD_task_unschedule(SD_task_t task)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(task != NULL, "Invalid parameter");
-
   if (task->state_set != sd_global->scheduled_task_set &&
       task->state_set != sd_global->runnable_task_set &&
       task->state_set != sd_global->running_task_set &&
@@ -928,7 +880,6 @@ void SD_task_unschedule(SD_task_t task)
  */
 static void __SD_task_destroy_scheduling_data(SD_task_t task)
 {
-  SD_CHECK_INIT_DONE();
   if (!__SD_task_is_scheduled_or_runnable(task)
       && !__SD_task_is_in_fifo(task))
     THROWF(arg_error, 0,
@@ -950,8 +901,6 @@ void __SD_task_really_run(SD_task_t task)
   int i;
   void **surf_workstations;
 
-  SD_CHECK_INIT_DONE();
-  xbt_assert(task != NULL, "Invalid parameter");
   xbt_assert(__SD_task_is_runnable_or_in_fifo(task),
               "Task '%s' is not runnable or in a fifo! Task state: %d",
               SD_task_get_name(task), SD_task_get_state(task));
@@ -1073,8 +1022,6 @@ int __SD_task_try_to_run(SD_task_t task)
   int i;
   SD_workstation_t workstation;
 
-  SD_CHECK_INIT_DONE();
-  xbt_assert(task != NULL, "Invalid parameter");
   xbt_assert(__SD_task_is_runnable(task),
               "Task '%s' is not runnable! Task state: %d",
               SD_task_get_name(task), SD_task_get_state(task));
@@ -1123,8 +1070,6 @@ void __SD_task_just_done(SD_task_t task)
   SD_task_t *candidates;
   int can_start = 1;
 
-  SD_CHECK_INIT_DONE();
-  xbt_assert(task != NULL, "Invalid parameter");
   xbt_assert(__SD_task_is_running(task),
               "The task must be running! Task state: %d",
               SD_task_get_state(task));
@@ -1290,8 +1235,6 @@ static void __SD_task_remove_dependencies(SD_task_t task)
  */
 double SD_task_get_start_time(SD_task_t task)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(task != NULL, "Invalid parameter");
   if (task->surf_action)
     return surf_workstation_model->
         action_get_start_time(task->surf_action);
@@ -1312,9 +1255,6 @@ double SD_task_get_start_time(SD_task_t task)
  */
 double SD_task_get_finish_time(SD_task_t task)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(task != NULL, "Invalid parameter");
-
   if (task->surf_action)        /* should never happen as actions are destroyed right after their completion */
     return surf_workstation_model->
         action_get_finish_time(task->surf_action);
diff --git a/src/simdag/sd_workstation.c b/src/simdag/sd_workstation.c
index 46808556d0..232b83ce6b 100644
--- a/src/simdag/sd_workstation.c
+++ b/src/simdag/sd_workstation.c
@@ -21,8 +21,6 @@ SD_workstation_t __SD_workstation_create(void *surf_workstation,
 
   SD_workstation_t workstation;
   const char *name;
-  SD_CHECK_INIT_DONE();
-  xbt_assert(surf_workstation != NULL, "surf_workstation is NULL !");
 
   workstation = xbt_new(s_SD_workstation_t, 1);
   workstation->surf_workstation = surf_workstation;
@@ -46,10 +44,6 @@ SD_workstation_t __SD_workstation_create(void *surf_workstation,
  */
 SD_workstation_t SD_workstation_get_by_name(const char *name)
 {
-  SD_CHECK_INIT_DONE();
-
-  xbt_assert(name != NULL, "Invalid parameter");
-
   return xbt_lib_get_or_null(host_lib, name, SD_HOST_LEVEL);
 }
 
@@ -69,7 +63,6 @@ const SD_workstation_t *SD_workstation_get_list(void)
   void **data;
   int i;
 
-  SD_CHECK_INIT_DONE();
   xbt_assert(SD_workstation_get_number() > 0, "There is no workstation!");
 
   if (sd_global->workstation_list == NULL) {    /* this is the first time the function is called */
@@ -93,7 +86,6 @@ const SD_workstation_t *SD_workstation_get_list(void)
  */
 int SD_workstation_get_number(void)
 {
-  SD_CHECK_INIT_DONE();
   return host_lib->count;
 }
 
@@ -106,8 +98,6 @@ int SD_workstation_get_number(void)
  */
 void *SD_workstation_get_data(SD_workstation_t workstation)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(workstation != NULL, "Invalid parameter");
   return workstation->data;
 }
 
@@ -123,8 +113,6 @@ void *SD_workstation_get_data(SD_workstation_t workstation)
  */
 void SD_workstation_set_data(SD_workstation_t workstation, void *data)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(workstation != NULL, "Invalid parameter");
   workstation->data = data;
 }
 
@@ -136,8 +124,6 @@ void SD_workstation_set_data(SD_workstation_t workstation, void *data)
  */
 const char *SD_workstation_get_name(SD_workstation_t workstation)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(workstation != NULL, "Invalid parameter");
   return surf_resource_name(workstation->surf_workstation);
 }
 
@@ -163,9 +149,6 @@ const char *SD_workstation_get_property_value(SD_workstation_t ws,
  */
 xbt_dict_t SD_workstation_get_properties(SD_workstation_t workstation)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert((workstation != NULL), "Invalid parameters");
-
   return surf_workstation_model->extension.
       workstation.get_properties(workstation->surf_workstation);
 
@@ -192,8 +175,6 @@ const SD_link_t *SD_route_get_list(SD_workstation_t src,
   void *surf_link;
   unsigned int cpt;
 
-  SD_CHECK_INIT_DONE();
-
   if (sd_global->recyclable_route == NULL) {
     /* first run */
     sd_global->recyclable_route = xbt_new(SD_link_t, SD_link_get_number());
@@ -223,7 +204,6 @@ const SD_link_t *SD_route_get_list(SD_workstation_t src,
  */
 int SD_route_get_size(SD_workstation_t src, SD_workstation_t dst)
 {
-  SD_CHECK_INIT_DONE();
   return xbt_dynar_length(surf_workstation_model->extension.
                           workstation.get_route(src->surf_workstation,
                                                 dst->surf_workstation));
@@ -238,8 +218,6 @@ int SD_route_get_size(SD_workstation_t src, SD_workstation_t dst)
  */
 double SD_workstation_get_power(SD_workstation_t workstation)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(workstation != NULL, "Invalid parameter");
   return surf_workstation_model->extension.workstation.
       get_speed(workstation->surf_workstation, 1.0);
 }
@@ -253,8 +231,6 @@ double SD_workstation_get_power(SD_workstation_t workstation)
  */
 double SD_workstation_get_available_power(SD_workstation_t workstation)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(workstation != NULL, "Invalid parameter");
   return surf_workstation_model->extension.
       workstation.get_available_speed(workstation->surf_workstation);
 }
@@ -269,8 +245,6 @@ double SD_workstation_get_available_power(SD_workstation_t workstation)
 double SD_workstation_get_computation_time(SD_workstation_t workstation,
                                            double computation_amount)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(workstation != NULL, "Invalid parameter");
   xbt_assert(computation_amount >= 0,
               "computation_amount must be greater than or equal to zero");
   return computation_amount / SD_workstation_get_power(workstation);
@@ -294,8 +268,6 @@ double SD_route_get_current_latency(SD_workstation_t src,
   double latency;
   int i;
 
-  SD_CHECK_INIT_DONE();
-  xbt_assert(src != NULL && dst != NULL, "Invalid parameter");
   links = SD_route_get_list(src, dst);
   nb_links = SD_route_get_size(src, dst);
   latency = 0.0;
@@ -326,9 +298,6 @@ double SD_route_get_current_bandwidth(SD_workstation_t src,
   double min_bandwidth;
   int i;
 
-  SD_CHECK_INIT_DONE();
-  xbt_assert(src != NULL && dst != NULL, "Invalid parameter");
-
   links = SD_route_get_list(src, dst);
   nb_links = SD_route_get_size(src, dst);
   bandwidth = min_bandwidth = -1.0;
@@ -368,8 +337,6 @@ double SD_route_get_communication_time(SD_workstation_t src,
   double latency;
   int i;
 
-  SD_CHECK_INIT_DONE();
-  xbt_assert(src != NULL && dst != NULL, "Invalid parameter");
   xbt_assert(communication_amount >= 0,
               "communication_amount must be greater than or equal to zero");
 
@@ -405,8 +372,6 @@ double SD_route_get_communication_time(SD_workstation_t src,
 e_SD_workstation_access_mode_t
 SD_workstation_get_access_mode(SD_workstation_t workstation)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(workstation != NULL, "Invalid parameter");
   return workstation->access_mode;
 }
 
@@ -429,9 +394,6 @@ void SD_workstation_set_access_mode(SD_workstation_t workstation,
                                     e_SD_workstation_access_mode_t
                                     access_mode)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(workstation != NULL, "Invalid parameter");
-
   if (access_mode == workstation->access_mode) {
     return;                     // nothing is changed
   }
@@ -462,9 +424,6 @@ void SD_workstation_set_access_mode(SD_workstation_t workstation,
  */
 int __SD_workstation_is_busy(SD_workstation_t workstation)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(workstation != NULL, "Invalid parameter");
-
   XBT_DEBUG
       ("Workstation '%s' access mode: '%s', current task: %s, fifo size: %d",
        SD_workstation_get_name(workstation),
@@ -488,8 +447,6 @@ void __SD_workstation_destroy(void *workstation)
 
   SD_workstation_t w;
 
-  SD_CHECK_INIT_DONE();
-  xbt_assert(workstation != NULL, "Invalid parameter");
   /* workstation->surf_workstation is freed by surf_exit and workstation->data is freed by the user */
 
   w = (SD_workstation_t) workstation;
@@ -506,8 +463,6 @@ void __SD_workstation_destroy(void *workstation)
  * \param workstation a workstation */
 SD_task_t SD_workstation_get_current_task(SD_workstation_t workstation)
 {
-  SD_CHECK_INIT_DONE();
-  xbt_assert(workstation != NULL, "Invalid parameter");
   xbt_assert(workstation->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS,
               "Access mode must be set to SD_WORKSTATION_SEQUENTIAL_ACCESS"
               " to use this function");
diff --git a/teshsuite/simdag/basic6.c b/teshsuite/simdag/basic6.c
index 454725e184..f73725d0c7 100644
--- a/teshsuite/simdag/basic6.c
+++ b/teshsuite/simdag/basic6.c
@@ -32,6 +32,8 @@ int main(int argc, char **argv)
                    comm_cost, -1.0);
 
   ret = SD_simulate(-1.0);
+  xbt_assert(xbt_dynar_length(ret) == 2,
+      "I was expecting the terminaison of 2 tasks, but I got %lu instead", xbt_dynar_length(ret));
   xbt_dynar_free(&ret);
   SD_task_destroy(taskA);
   SD_task_destroy(taskB);