Declare all variables at the begining for ANSI C standard compatibility.

git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/simgrid/simgrid/trunk@2819 48e7efb5-ca39-0410-a469-dd3cf9ba447f

diff --git a/src/msg/gos.c b/src/msg/gos.c
index aa21ba2..51ea845 100644 (file)
--- a/src/msg/gos.c
+++ b/src/msg/gos.c
@@ -24,6 +24,7 @@ static MSG_error_t __MSG_task_get_with_time_out_from_host(m_task_t * task,
   m_process_t process = MSG_process_self();
   m_task_t t = NULL;
   m_host_t h = NULL;
+  m_task_t task_to_wait_for;
   simdata_task_t t_simdata = NULL;
   simdata_host_t h_simdata = NULL;
   int first_time = 1;
@@ -97,7 +98,8 @@ static MSG_error_t __MSG_task_get_with_time_out_from_host(m_task_t * task,
   while(MSG_process_is_suspended(t_simdata->sender)) {
     DEBUG1("Oooups, the sender (%s) has been suspended in the meantime. Let's wait for him", 
           t_simdata->sender->name);
-    m_task_t task_to_wait_for = t_simdata->sender->simdata->waiting_task;
+    /*m_task_t task_to_wait_for = t_simdata->sender->simdata->waiting_task;*/
+    task_to_wait_for = t_simdata->sender->simdata->waiting_task;
     if(__MSG_process_isBlocked(t_simdata->sender)) {
       DEBUG0("He's blocked. Let's wait for him to go in the suspended state");
       __MSG_process_unblock(t_simdata->sender);

diff --git a/src/msg/host.c b/src/msg/host.c
index 8637c56..8d1b47d 100644 (file)
--- a/src/msg/host.c
+++ b/src/msg/host.c
@@ -195,9 +195,10 @@ double MSG_get_host_speed(m_host_t h)
  */
 int MSG_host_is_avail (m_host_t h)
 {
+  e_surf_cpu_state_t cpustate;
   xbt_assert0((h!= NULL), "Invalid parameters");
 
-  e_surf_cpu_state_t cpustate =
+  cpustate =
     surf_workstation_resource->extension_public->get_state(h->simdata->host);
 
   xbt_assert0((cpustate == SURF_CPU_ON || cpustate == SURF_CPU_OFF),

diff --git a/src/simdag/sd_global.c b/src/simdag/sd_global.c
index 21cda51..e92a175 100644 (file)
--- a/src/simdag/sd_global.c
+++ b/src/simdag/sd_global.c
@@ -20,6 +20,9 @@ SD_global_t sd_global = NULL;
  * \see SD_create_environment(), SD_exit()
  */
 void SD_init(int *argc, char **argv) {
+
+  s_SD_task_t task;
+  
   if (SD_INITIALISED()) {
     xbt_assert0(0, "SD_init() already called");
   }
@@ -34,7 +37,6 @@ void SD_init(int *argc, char **argv) {
   sd_global->recyclable_route = NULL;
   sd_global->watch_point_reached = 0;
 
-  s_SD_task_t task;
   sd_global->not_scheduled_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->ready_task_set = xbt_swag_new(xbt_swag_offset(task, state_hookup));

diff --git a/src/simdag/sd_link.c b/src/simdag/sd_link.c
index 68bfefc..1742d7f 100644 (file)
--- a/src/simdag/sd_link.c
+++ b/src/simdag/sd_link.c
@@ -7,14 +7,18 @@
 /* Creates a link and registers it in SD.
  */
 SD_link_t __SD_link_create(void *surf_link, void *data) {
+
+  SD_link_t link;
+  const char *name;
+
   SD_CHECK_INIT_DONE();
   xbt_assert0(surf_link != NULL, "surf_link is NULL !");
 
-  SD_link_t link = xbt_new(s_SD_link_t, 1);
+  link = xbt_new(s_SD_link_t, 1);
   link->surf_link = surf_link;
   link->data = data; /* user data */
 
-  const char *name = SD_link_get_name(link);
+  name = SD_link_get_name(link);
   xbt_dict_set(sd_global->links, name, link, __SD_link_destroy); /* add the link to the dictionary */
   sd_global->link_count++;
 
@@ -29,13 +33,14 @@ SD_link_t __SD_link_create(void *surf_link, void *data) {
  * \see SD_link_get_number()
  */
 const SD_link_t*  SD_link_get_list(void) {
-  SD_CHECK_INIT_DONE();
-  xbt_assert0(SD_link_get_number() > 0, "There is no link!");
 
   xbt_dict_cursor_t cursor;
   char *key;
   void *data;
   int i;
+  
+  SD_CHECK_INIT_DONE();
+  xbt_assert0(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, sd_global->link_count);

diff --git a/src/simdag/sd_task.c b/src/simdag/sd_task.c
index 416ee2e..f2aa7bd 100644 (file)
--- a/src/simdag/sd_task.c
+++ b/src/simdag/sd_task.c
@@ -19,9 +19,11 @@ static void __SD_task_destroy_scheduling_data(SD_task_t task);
  * \see SD_task_destroy()
  */
 SD_task_t SD_task_create(const char *name, void *data, double amount) {
+
+  SD_task_t task;
   SD_CHECK_INIT_DONE();
 
-  SD_task_t task = xbt_new(s_SD_task_t, 1);
+  task = xbt_new(s_SD_task_t, 1);
 
   /* general information */
   task->data = data; /* user data */
@@ -191,11 +193,16 @@ double SD_task_get_remaining_amount(SD_task_t task) {
 
 /* temporary function for debbuging */
 static void __SD_print_dependencies(SD_task_t task) {
-  INFO1("The following tasks must be executed before %s:", SD_task_get_name(task));
-  xbt_dynar_t dynar = task->tasks_before;
-  int length = xbt_dynar_length(dynar);
+  xbt_dynar_t dynar;
+  int length;
   int i;
   SD_dependency_t dependency;
+
+  INFO1("The following tasks must be executed before %s:", SD_task_get_name(task));
+  dynar = task->tasks_before;
+  length = xbt_dynar_length(dynar);
+
+
   for (i = 0; i < length; i++) {
     xbt_dynar_get_cpy(dynar, i, &dependency);
     INFO1(" %s", SD_task_get_name(dependency->src));
@@ -233,15 +240,20 @@ static void __SD_task_dependency_destroy(void *dependency) {
  * \see SD_task_dependency_remove()
  */
 void SD_task_dependency_add(const char *name, void *data, SD_task_t src, SD_task_t dst) {
-  SD_CHECK_INIT_DONE();
-  xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
-
-  xbt_dynar_t dynar = src->tasks_after;
-  int length = xbt_dynar_length(dynar);
+  xbt_dynar_t dynar;
+  int length;
   int found = 0;
   int i;
   SD_dependency_t dependency;
 
+  SD_CHECK_INIT_DONE();
+  xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
+
+  dynar = src->tasks_after;
+  length = xbt_dynar_length(dynar);
+
+
+
   if (src == dst) 
     THROW1(arg_error, 0, "Cannot add a dependency between task '%s' and itself",
           SD_task_get_name(src));
@@ -297,15 +309,20 @@ void SD_task_dependency_add(const char *name, void *data, SD_task_t src, SD_task
  * \see SD_task_dependency_add()
  */
 void SD_task_dependency_remove(SD_task_t src, SD_task_t dst) {
-  SD_CHECK_INIT_DONE();
-  xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
 
-  /* remove the dependency from src->tasks_after */
-  xbt_dynar_t dynar = src->tasks_after;
-  int length = xbt_dynar_length(dynar);
+  xbt_dynar_t dynar;
+  int length;
   int found = 0;
   int i;
   SD_dependency_t dependency;
+
+  SD_CHECK_INIT_DONE();
+  xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
+
+  /* remove the dependency from src->tasks_after */
+  dynar = src->tasks_after;
+  length = xbt_dynar_length(dynar);
+
   for (i = 0; i < length && !found; i++) {
     xbt_dynar_get_cpy(dynar, i, &dependency);
     if (dependency->dst == dst) {
@@ -352,14 +369,20 @@ void SD_task_dependency_remove(SD_task_t src, SD_task_t dst) {
  * \see SD_task_dependency_add()
  */
 void *SD_task_dependency_get_data(SD_task_t src, SD_task_t dst) {
-  SD_CHECK_INIT_DONE();
-  xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
 
-  xbt_dynar_t dynar = src->tasks_after;
-  int length = xbt_dynar_length(dynar);
+  xbt_dynar_t dynar;
+  int length;
   int found = 0;
   int i;
   SD_dependency_t dependency;
+
+
+  SD_CHECK_INIT_DONE();
+  xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
+
+  dynar = src->tasks_after;
+  length = xbt_dynar_length(dynar);
+
   for (i = 0; i < length && !found; i++) {
     xbt_dynar_get_cpy(dynar, i, &dependency);
     found = (dependency->dst == dst);
@@ -373,10 +396,11 @@ void *SD_task_dependency_get_data(SD_task_t src, SD_task_t dst) {
 static void __SD_print_watch_points(SD_task_t task) {
   static const int state_masks[] = {SD_SCHEDULED, SD_RUNNING, SD_READY, SD_DONE, SD_FAILED};
   static const char* state_names[] = {"scheduled", "running", "ready", "done", "failed"};
+  int i;
 
   INFO2("Task '%s' watch points (%x): ", SD_task_get_name(task), task->watch_points);
 
-  int i;
+
   for (i = 0; i < 5; i++) {
     if (task->watch_points & state_masks[i])
       INFO1("%s ", state_names[i]);
@@ -443,14 +467,15 @@ double SD_task_get_execution_time(SD_task_t task,
                                  const double *computation_amount,
                                  const double *communication_amount,
                                  double rate) {
+  double time, max_time = 0.0;
+  int i, j;
   SD_CHECK_INIT_DONE();
   xbt_assert0(task != NULL && workstation_nb > 0 && workstation_list != NULL &&
              computation_amount != NULL && communication_amount != NULL,
              "Invalid parameter");
 
   /* the task execution time is the maximum execution time of the parallel tasks */
-  double time, max_time = 0.0;
-  int i, j;
+
   for (i = 0; i < workstation_nb; i++) {
     time = SD_workstation_get_computation_time(workstation_list[i], computation_amount[i]);
     
@@ -484,6 +509,9 @@ double SD_task_get_execution_time(SD_task_t task,
 void SD_task_schedule(SD_task_t task, int workstation_nb,
                     const SD_workstation_t *workstation_list, const double *computation_amount,
                     const double *communication_amount, double rate) {
+
+  int communication_nb;
+  
   SD_CHECK_INIT_DONE();
   xbt_assert0(task != NULL, "Invalid parameter");
   xbt_assert0(workstation_nb > 0, "workstation_nb must be positive");
@@ -497,7 +525,7 @@ void SD_task_schedule(SD_task_t task, int workstation_nb,
   task->computation_amount = xbt_new(double, workstation_nb);
   memcpy(task->computation_amount, computation_amount, sizeof(double) * workstation_nb);
 
-  int communication_nb = workstation_nb * workstation_nb;
+  communication_nb = workstation_nb * workstation_nb;
   task->communication_amount = xbt_new(double, communication_nb);
   memcpy(task->communication_amount, communication_amount, sizeof(double) * communication_nb);
 
@@ -559,14 +587,17 @@ static void __SD_task_destroy_scheduling_data(SD_task_t task) {
  * the task gets out of its fifos.
  */
 void __SD_task_really_run(SD_task_t task) {
+
+  int i;
+  void **surf_workstations;
+
   SD_CHECK_INIT_DONE();
   xbt_assert0(task != NULL, "Invalid parameter");
   xbt_assert2(__SD_task_is_ready_or_in_fifo(task), "Task '%s' is not ready or in a fifo! Task state: %d",
           SD_task_get_name(task), SD_task_get_state(task));
   xbt_assert1(task->workstation_list != NULL, "Task '%s': workstation_list is NULL!", SD_task_get_name(task));
 
-  int i;
-  void **surf_workstations;
+
 
   DEBUG1("Really running task '%s'", SD_task_get_name(task));
 
@@ -616,14 +647,16 @@ void __SD_task_really_run(SD_task_t task) {
  * Returns whether the task has started.
  */
 int __SD_task_try_to_run(SD_task_t task) {
+
+  int can_start = 1;
+  int i;
+  SD_workstation_t workstation;
+
   SD_CHECK_INIT_DONE();
   xbt_assert0(task != NULL, "Invalid parameter");
   xbt_assert2(__SD_task_is_ready(task), "Task '%s' is not ready! Task state: %d",
           SD_task_get_name(task), SD_task_get_state(task));
 
-  int can_start = 1;
-  int i;
-  SD_workstation_t workstation;
 
   for (i = 0; i < task->workstation_nb; i++) {
     can_start = !__SD_workstation_is_busy(task->workstation_list[i]);
@@ -657,20 +690,23 @@ int __SD_task_try_to_run(SD_task_t task) {
  * which were waiting in fifos for the end of `task'
  */
 void __SD_task_just_done(SD_task_t task) {
-  SD_CHECK_INIT_DONE();
-  xbt_assert0(task != NULL, "Invalid parameter");
-  xbt_assert1(__SD_task_is_running(task), "The task must be running! Task state: %d", SD_task_get_state(task));
-  xbt_assert1(task->workstation_list != NULL, "Task '%s': workstation_list is NULL!", SD_task_get_name(task));
-
-  int i, j;
+   int i, j;
   SD_workstation_t workstation;
 
   SD_task_t candidate;
   int candidate_nb = 0;
   int candidate_capacity = 8;
-  SD_task_t *candidates = xbt_new(SD_task_t, 8);
+  SD_task_t *candidates;
   int can_start = 1;
 
+  SD_CHECK_INIT_DONE();
+  xbt_assert0(task != NULL, "Invalid parameter");
+  xbt_assert1(__SD_task_is_running(task), "The task must be running! Task state: %d", SD_task_get_state(task));
+  xbt_assert1(task->workstation_list != NULL, "Task '%s': workstation_list is NULL!", SD_task_get_name(task));
+
+
+  candidates = xbt_new(SD_task_t, 8);
+
   __SD_task_set_state(task, SD_DONE);
   surf_workstation_resource->common_public->action_free(task->surf_action);
   task->surf_action = NULL;

diff --git a/src/simdag/sd_workstation.c b/src/simdag/sd_workstation.c
index 8e41d73..5472a60 100644 (file)
--- a/src/simdag/sd_workstation.c
+++ b/src/simdag/sd_workstation.c
@@ -10,17 +10,20 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(sd_workstation, sd,
 /* Creates a workstation and registers it in SD.
  */
 SD_workstation_t __SD_workstation_create(void *surf_workstation, void *data) {
+
+  SD_workstation_t workstation;
+  const char *name;
   SD_CHECK_INIT_DONE();
   xbt_assert0(surf_workstation != NULL, "surf_workstation is NULL !");
 
-  SD_workstation_t workstation = xbt_new(s_SD_workstation_t, 1);
+  workstation = xbt_new(s_SD_workstation_t, 1);
   workstation->surf_workstation = surf_workstation;
   workstation->data = data; /* user data */
   workstation->access_mode = SD_WORKSTATION_SHARED_ACCESS; /* default mode is shared */
   workstation->task_fifo = NULL;
   workstation->current_task = NULL;
   
-  const char *name = SD_workstation_get_name(workstation);
+  name = SD_workstation_get_name(workstation);
   xbt_dict_set(sd_global->workstations, name, workstation, __SD_workstation_destroy); /* add the workstation to the dictionary */
   sd_global->workstation_count++;
 
@@ -52,14 +55,17 @@ SD_workstation_t SD_workstation_get_by_name(const char *name) {
  * \see SD_workstation_get_number()
  */
 const SD_workstation_t* SD_workstation_get_list(void) {
-  SD_CHECK_INIT_DONE();
-  xbt_assert0(SD_workstation_get_number() > 0, "There is no workstation!");
 
   xbt_dict_cursor_t cursor;
   char *key;
   void *data;
   int i;
 
+  SD_CHECK_INIT_DONE();
+  xbt_assert0(SD_workstation_get_number() > 0, "There is no workstation!");
+
+
+
   if (sd_global->workstation_list == NULL) { /* this is the first time the function is called */
     sd_global->workstation_list = xbt_new(SD_workstation_t, sd_global->workstation_count);
   
@@ -134,6 +140,13 @@ const char* SD_workstation_get_name(SD_workstation_t workstation) {
  * \see SD_route_get_size(), SD_link_t
  */
 const SD_link_t* SD_route_get_list(SD_workstation_t src, SD_workstation_t dst) {
+  void *surf_src;
+  void *surf_dst;
+  const void **surf_route;
+  int route_size;
+  const char *link_name;
+  int i;
+  
   SD_CHECK_INIT_DONE();
 
   if (sd_global->recyclable_route == NULL) {
@@ -141,14 +154,13 @@ const SD_link_t* SD_route_get_list(SD_workstation_t src, SD_workstation_t dst) {
     sd_global->recyclable_route = xbt_new(SD_link_t, SD_link_get_number());
   }
 
-  void *surf_src = src->surf_workstation;
-  void *surf_dst = dst->surf_workstation;
+  surf_src = src->surf_workstation;
+  surf_dst = dst->surf_workstation;
+
+  surf_route = surf_workstation_resource->extension_public->get_route(surf_src, surf_dst);
+  route_size = surf_workstation_resource->extension_public->get_route_size(surf_src, surf_dst);
 
-  const void **surf_route = surf_workstation_resource->extension_public->get_route(surf_src, surf_dst);
-  int route_size = surf_workstation_resource->extension_public->get_route_size(surf_src, surf_dst);
 
-  const char *link_name;
-  int i;
   for (i = 0; i < route_size; i++) {
     link_name = surf_workstation_resource->extension_public->get_link_name(surf_route[i]);
     sd_global->recyclable_route[i] = xbt_dict_get(sd_global->links, link_name);
@@ -221,12 +233,17 @@ double SD_workstation_get_computation_time(SD_workstation_t workstation, double
  * \see SD_route_get_current_bandwidth()
  */
 double SD_route_get_current_latency(SD_workstation_t src, SD_workstation_t dst) {
+
+  const SD_link_t *links;
+  int nb_links;
+  double latency ;
+  int i;
+
   SD_CHECK_INIT_DONE();
   xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
-  const SD_link_t *links = SD_route_get_list(src, dst);
-  int nb_links = SD_route_get_size(src, dst);
-  double latency = 0.0;
-  int i;
+  links = SD_route_get_list(src, dst);
+  nb_links = SD_route_get_size(src, dst);
+  latency = 0.0;
   
   for (i = 0; i < nb_links; i++) {
     latency += SD_link_get_current_latency(links[i]);
@@ -245,12 +262,20 @@ double SD_route_get_current_latency(SD_workstation_t src, SD_workstation_t dst)
  * \see SD_route_get_current_latency()
  */
 double SD_route_get_current_bandwidth(SD_workstation_t src, SD_workstation_t dst) {
+
+  const SD_link_t *links;
+  int nb_links;
+  double bandwidth;
+  double min_bandwidth;
+  int i;
+
   SD_CHECK_INIT_DONE();
   xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
-  const SD_link_t *links = SD_route_get_list(src, dst);
-  int nb_links = SD_route_get_size(src, dst);
-  double bandwidth, min_bandwidth = -1.0;
-  int i;
+
+  links = SD_route_get_list(src, dst);
+  nb_links = SD_route_get_size(src, dst);
+  bandwidth = min_bandwidth = -1.0;
+
   
   for (i = 0; i < nb_links; i++) {
     bandwidth = SD_link_get_current_bandwidth(links[i]);
@@ -273,17 +298,22 @@ double SD_route_get_current_bandwidth(SD_workstation_t src, SD_workstation_t dst
  */
 double SD_route_get_communication_time(SD_workstation_t src, SD_workstation_t dst,
                                                   double communication_amount) {
+
+
   /* total time = latency + transmission time of the slowest link
      transmission time of a link = communication amount / link bandwidth */
-  SD_CHECK_INIT_DONE();
-  xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
-  xbt_assert0(communication_amount >= 0, "communication_amount must be greater than or equal to zero");
 
   const SD_link_t *links;
   int nb_links;
   double bandwidth, min_bandwidth;
   double latency;
   int i;
+
+  SD_CHECK_INIT_DONE();
+  xbt_assert0(src != NULL && dst != NULL, "Invalid parameter");
+  xbt_assert0(communication_amount >= 0, "communication_amount must be greater than or equal to zero");
+
+
   
   if (communication_amount == 0.0)
     return 0.0;
@@ -383,11 +413,14 @@ int __SD_workstation_is_busy(SD_workstation_t workstation) {
 /* Destroys a workstation.
  */
 void __SD_workstation_destroy(void *workstation) {
+
+  SD_workstation_t w;
+
   SD_CHECK_INIT_DONE();
   xbt_assert0(workstation != NULL, "Invalid parameter");
   /* workstation->surf_workstation is freed by surf_exit and workstation->data is freed by the user */
 
-  SD_workstation_t w = (SD_workstation_t) workstation;
+  w = (SD_workstation_t) workstation;
 
   if (w->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) {
     xbt_fifo_free(w->task_fifo);