X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/9a79cc226e6e4235c695bce5c063e46c5db17239..4e6447f0964c8b85284e3bc28e5176474530db21:/src/surf/workstation_ptask_L07.c

diff --git a/src/surf/workstation_ptask_L07.c b/src/surf/workstation_ptask_L07.c
index efd2ef53e2..3e88b40f73 100644
--- a/src/surf/workstation_ptask_L07.c
+++ b/src/surf/workstation_ptask_L07.c
@@ -8,18 +8,19 @@
 #include "xbt/ex.h"
 #include "xbt/dict.h"
 #include "surf_private.h"
+/* extern lmm_system_t maxmin_system; */
 
 typedef enum {
   SURF_WORKSTATION_RESOURCE_CPU,
   SURF_WORKSTATION_RESOURCE_LINK,
-} e_surf_workstation_resource_type_t;
+} e_surf_workstation_model_type_t;
 
 /**************************************/
 /********* cpu object *****************/
 /**************************************/
 typedef struct cpu_L07 {
-  surf_resource_t resource;	/* Do not move this field */
-  e_surf_workstation_resource_type_t type;	/* Do not move this field */
+  surf_model_t model;	/* Do not move this field */
+  e_surf_workstation_model_type_t type;	/* Do not move this field */
   char *name;			/* Do not move this field */
   lmm_constraint_t constraint;	/* Do not move this field */
   double power_scale;
@@ -35,10 +36,12 @@ typedef struct cpu_L07 {
 /**************************************/
 
 typedef struct network_link_L07 {
-  surf_resource_t resource;	/* Do not move this field */
-  e_surf_workstation_resource_type_t type;	/* Do not move this field */
+  surf_model_t model;	/* Do not move this field */
+  e_surf_workstation_model_type_t type;	/* Do not move this field */
   char *name;			/* Do not move this field */
   lmm_constraint_t constraint;	/* Do not move this field */
+  double lat_current;
+  tmgr_trace_event_t lat_event;
   double bw_current;
   tmgr_trace_event_t bw_event;
   e_surf_network_link_state_t state_current;
@@ -57,6 +60,11 @@ typedef struct s_route_L07 {
 typedef struct surf_action_workstation_L07 {
   s_surf_action_t generic_action;
   lmm_variable_t variable;
+  int workstation_nb;
+  cpu_L07_t *workstation_list;
+  double *computation_amount;
+  double *communication_amount;
+  double latency;
   double rate;
   int suspended;
 } s_surf_action_workstation_L07_t, *surf_action_workstation_L07_t;
@@ -71,6 +79,42 @@ static network_link_L07_t loopback = NULL;
 static xbt_dict_t parallel_task_network_link_set = NULL;
 lmm_system_t ptask_maxmin_system = NULL;
 
+
+static void update_action_bound(surf_action_workstation_L07_t action)
+{
+  int workstation_nb = action->workstation_nb;
+  double lat_current = 0.0;
+  double lat_bound = -1.0;
+  int i, j, k;
+  
+  for (i = 0; i < workstation_nb; i++) {
+    for (j = 0; j < workstation_nb; j++) {
+      cpu_L07_t card_src = action->workstation_list[i];
+      cpu_L07_t card_dst = action->workstation_list[j];
+      int route_size = ROUTE(card_src->id, card_dst->id).size;
+      network_link_L07_t *route = ROUTE(card_src->id, card_dst->id).links;
+      double lat = 0.0;
+      
+      if (action->communication_amount[i * workstation_nb + j] > 0) {
+	for (k = 0; k < route_size; k++) {
+	  lat += route[k]->lat_current;
+	}
+	lat_current=MAX(lat_current,lat/action->communication_amount[i * workstation_nb + j]);
+      }
+    }
+  }
+  lat_bound = SG_TCP_CTE_GAMMA / (2.0 * lat_current);
+  DEBUG2("action (%p) : lat_bound = %g", action, lat_bound);
+  if ((action->latency == 0.0) && (action->suspended == 0)) {
+    if (action->rate < 0)
+      lmm_update_variable_bound(ptask_maxmin_system, action->variable,
+				lat_bound);
+    else
+      lmm_update_variable_bound(ptask_maxmin_system, action->variable,
+				min(action->rate,lat_bound));
+  }
+}
+
 /**************************************/
 /******* Resource Public     **********/
 /**************************************/
@@ -106,6 +150,9 @@ static int action_free(surf_action_t action)
       lmm_variable_free(ptask_maxmin_system,
 			((surf_action_workstation_L07_t) action)->
 			variable);
+    free(((surf_action_workstation_L07_t)action)->workstation_list);
+    free(((surf_action_workstation_L07_t)action)->communication_amount);
+    free(((surf_action_workstation_L07_t)action)->computation_amount);
     free(action);
     return 1;
   }
@@ -141,12 +188,12 @@ static void action_suspend(surf_action_t action)
 
 static void action_resume(surf_action_t action)
 {
-  XBT_IN1("(%p)", action);
-  if (((surf_action_workstation_L07_t) action)->suspended != 2) {
-    lmm_update_variable_weight(ptask_maxmin_system,
-			       ((surf_action_workstation_L07_t)
-				action)->variable, 1.0);
-    ((surf_action_workstation_L07_t) action)->suspended = 0;
+  surf_action_workstation_L07_t act = (surf_action_workstation_L07_t) action;
+
+  XBT_IN1("(%p)", act);
+  if (act->suspended != 2) {
+    lmm_update_variable_weight(ptask_maxmin_system,act->variable, 1.0);
+    act->suspended = 0;
   }
   XBT_OUT;
 }
@@ -188,14 +235,29 @@ static int resource_used(void *resource_id)
 static double share_resources(double now)
 {
   s_surf_action_workstation_L07_t s_action;
+  surf_action_workstation_L07_t action = NULL;
 
   xbt_swag_t running_actions =
-      surf_workstation_resource->common_public->states.running_action_set;
-  double min = generic_maxmin_share_resources2(running_actions,
-					       xbt_swag_offset(s_action,
-							       variable),
-					       ptask_maxmin_system,
-					       bottleneck_solve);
+      surf_workstation_model->common_public->states.running_action_set;
+  double min = generic_maxmin_share_resources(running_actions,
+					      xbt_swag_offset(s_action,
+							      variable),
+					      ptask_maxmin_system,
+					      bottleneck_solve);
+
+  xbt_swag_foreach(action, running_actions) {
+    if (action->latency > 0) {
+      if (min < 0) {
+	min = action->latency;
+	DEBUG3("Updating min (value) with %p (start %f): %f", action,
+	       action->generic_action.start, min);
+      } else if (action->latency < min) {
+	min = action->latency;
+	DEBUG3("Updating min (latency) with %p (start %f): %f", action,
+	       action->generic_action.start, min);
+      }
+    }
+  }
 
   DEBUG1("min value : %f", min);
 
@@ -204,12 +266,27 @@ static double share_resources(double now)
 
 static void update_actions_state(double now, double delta)
 {
+  double deltap = 0.0;
   surf_action_workstation_L07_t action = NULL;
   surf_action_workstation_L07_t next_action = NULL;
   xbt_swag_t running_actions =
-      surf_workstation_resource->common_public->states.running_action_set;
+      surf_workstation_model->common_public->states.running_action_set;
 
   xbt_swag_foreach_safe(action, next_action, running_actions) {
+    deltap = delta;
+    if (action->latency > 0) {
+      if (action->latency > deltap) {
+	double_update(&(action->latency), deltap);
+	deltap = 0.0;
+      } else {
+	double_update(&(deltap), action->latency);
+	action->latency = 0.0;
+      }
+      if ((action->latency == 0.0) && (action->suspended == 0)) {
+	update_action_bound(action);
+	lmm_update_variable_weight(ptask_maxmin_system,action->variable, 1.0);
+      }
+    }
     DEBUG3("Action (%p) : remains (%g) updated by %g.",
 	   action, action->generic_action.remains,
 	   lmm_variable_getvalue(action->variable) * delta);
@@ -230,7 +307,7 @@ static void update_actions_state(double now, double delta)
       action->generic_action.finish = surf_get_clock();
       surf_action_change_state((surf_action_t) action, SURF_ACTION_DONE);
     } else {
-      /* Need to check that none of the resource has failed */
+      /* Need to check that none of the model has failed */
       lmm_constraint_t cnst = NULL;
       int i = 0;
       void *constraint_id = NULL;
@@ -287,6 +364,19 @@ static void update_resource_state(void *id,
       nw_link->bw_current = value;
       lmm_update_constraint_bound(ptask_maxmin_system, nw_link->constraint,
 				  nw_link->bw_current);
+    } else if (event_type == nw_link->lat_event) {
+      lmm_variable_t var = NULL;
+      surf_action_workstation_L07_t action = NULL;
+
+      nw_link->lat_current = value;
+      while (lmm_get_var_from_cnst
+	     (ptask_maxmin_system, nw_link->constraint, &var)) {
+	
+
+	action = lmm_variable_id(var);
+	update_action_bound(action);
+      }
+
     } else if (event_type == nw_link->state_event) {
       if (value > 0)
 	nw_link->state_current = SURF_NETWORK_LINK_ON;
@@ -328,21 +418,21 @@ static void finalize(void)
   if (parallel_task_network_link_set != NULL) {
     xbt_dict_free(&parallel_task_network_link_set);
   }
-  xbt_swag_free(surf_workstation_resource->common_public->states.
+  xbt_swag_free(surf_workstation_model->common_public->states.
 		ready_action_set);
-  xbt_swag_free(surf_workstation_resource->common_public->states.
+  xbt_swag_free(surf_workstation_model->common_public->states.
 		running_action_set);
-  xbt_swag_free(surf_workstation_resource->common_public->states.
+  xbt_swag_free(surf_workstation_model->common_public->states.
 		failed_action_set);
-  xbt_swag_free(surf_workstation_resource->common_public->states.
+  xbt_swag_free(surf_workstation_model->common_public->states.
 		done_action_set);
 
-  free(surf_workstation_resource->common_public);
-  free(surf_workstation_resource->common_private);
-  free(surf_workstation_resource->extension_public);
+  free(surf_workstation_model->common_public);
+  free(surf_workstation_model->common_private);
+  free(surf_workstation_model->extension_public);
 
-  free(surf_workstation_resource);
-  surf_workstation_resource = NULL;
+  free(surf_workstation_model);
+  surf_workstation_model = NULL;
 
   for (i = 0; i < nb_workstation; i++)
     for (j = 0; j < nb_workstation; j++)
@@ -386,12 +476,15 @@ static surf_action_t execute_parallel_task(int workstation_nb,
   int i, j, k;
   int nb_link = 0;
   int nb_host = 0;
+  double latency = 0.0;
 
   if (parallel_task_network_link_set == NULL) {
     parallel_task_network_link_set =
 	xbt_dict_new_ext(workstation_nb * workstation_nb * 10);
   }
 
+  xbt_dict_reset(parallel_task_network_link_set);
+
   /* Compute the number of affected resources... */
   for (i = 0; i < workstation_nb; i++) {
     for (j = 0; j < workstation_nb; j++) {
@@ -399,14 +492,18 @@ static surf_action_t execute_parallel_task(int workstation_nb,
       cpu_L07_t card_dst = workstation_list[j];
       int route_size = ROUTE(card_src->id, card_dst->id).size;
       network_link_L07_t *route = ROUTE(card_src->id, card_dst->id).links;
+      double lat = 0.0;
 
       if (communication_amount[i * workstation_nb + j] > 0)
 	for (k = 0; k < route_size; k++) {
+	  lat += route[k]->lat_current;
 	  xbt_dict_set(parallel_task_network_link_set, route[k]->name,
 		       route[k], NULL);
 	}
+      latency=MAX(latency,lat);
     }
   }
+
   nb_link = xbt_dict_length(parallel_task_network_link_set);
   xbt_dict_reset(parallel_task_network_link_set);
 
@@ -421,14 +518,19 @@ static surf_action_t execute_parallel_task(int workstation_nb,
   action->generic_action.cost = amount;
   action->generic_action.remains = amount;
   action->generic_action.max_duration = NO_MAX_DURATION;
-  action->generic_action.start = -1.0;
+  action->generic_action.start = surf_get_clock();
   action->generic_action.finish = -1.0;
-  action->generic_action.resource_type =
-      (surf_resource_t) surf_workstation_resource;
+  action->generic_action.model_type =
+      (surf_model_t) surf_workstation_model;
   action->suspended = 0;	/* Should be useless because of the
 				   calloc but it seems to help valgrind... */
+  action->workstation_nb = workstation_nb;
+  action->workstation_list = (cpu_L07_t *)workstation_list;
+  action->computation_amount = computation_amount;
+  action->communication_amount = communication_amount;
+  action->latency = latency;
   action->generic_action.state_set =
-      surf_workstation_resource->common_public->states.running_action_set;
+      surf_workstation_model->common_public->states.running_action_set;
 
   xbt_swag_insert(action, action->generic_action.state_set);
   action->rate = rate;
@@ -442,6 +544,9 @@ static surf_action_t execute_parallel_task(int workstation_nb,
 	lmm_variable_new(ptask_maxmin_system, action, 1.0, action->rate,
 			 workstation_nb + nb_link);
 
+  if (action->latency > 0) 
+    lmm_update_variable_weight(ptask_maxmin_system,action->variable,0.0);
+
   for (i = 0; i < workstation_nb; i++)
     lmm_expand(ptask_maxmin_system,
 	       ((cpu_L07_t) workstation_list[i])->constraint,
@@ -474,9 +579,16 @@ static surf_action_t execute_parallel_task(int workstation_nb,
 
 static surf_action_t execute(void *cpu, double size)
 {
-  double val = 0.0;
+  void **workstation_list = xbt_new0(void *, 1);
+  double *computation_amount = xbt_new0(double, 1);
+  double *communication_amount = xbt_new0(double, 1);
+
+  workstation_list[0] = cpu;
+  communication_amount[0] = 0.0;
+  computation_amount[0] = size;
 
-  return execute_parallel_task(1, &cpu, &size, &val, 1, -1);
+  return execute_parallel_task(1, workstation_list, computation_amount,
+			       communication_amount, 1, -1);
 }
 
 static surf_action_t communicate(void *src, void *dst, double size,
@@ -495,10 +607,6 @@ static surf_action_t communicate(void *src, void *dst, double size,
 			      computation_amount, communication_amount,
 			      1, rate);
 
-  free(computation_amount);
-  free(communication_amount);
-  free(workstation_list);
-
   return res;
 }
 
@@ -547,13 +655,7 @@ static double get_link_bandwidth(const void *link)
 
 static double get_link_latency(const void *link)
 {
-  static int warned = 0;
-
-  if(!warned) {
-    WARN0("This model does not take latency into account.");
-    warned = 1;
-  }
-  return 0.0;
+  return ((network_link_L07_t) link)->lat_current;
 }
 
 /**************************************/
@@ -574,7 +676,7 @@ static cpu_L07_t cpu_new(const char *name, double power_scale,
 {
   cpu_L07_t cpu = xbt_new0(s_cpu_L07_t, 1);
 
-  cpu->resource = (surf_resource_t) surf_workstation_resource;
+  cpu->model = (surf_model_t) surf_workstation_model;
   cpu->type = SURF_WORKSTATION_RESOURCE_CPU;
   cpu->name = xbt_strdup(name);
   cpu->id = nb_workstation++;
@@ -640,6 +742,8 @@ static void network_link_free(void *nw_link)
 static network_link_L07_t network_link_new(char *name,
 					   double bw_initial,
 					   tmgr_trace_t bw_trace,
+					   double lat_initial,
+					   tmgr_trace_t lat_trace,
 					   e_surf_network_link_state_t
 					   state_initial,
 					   tmgr_trace_t state_trace,
@@ -649,7 +753,7 @@ static network_link_L07_t network_link_new(char *name,
   network_link_L07_t nw_link = xbt_new0(s_network_link_L07_t, 1);
 
 
-  nw_link->resource = (surf_resource_t) surf_workstation_resource;
+  nw_link->model = (surf_model_t) surf_workstation_model;
   nw_link->type = SURF_WORKSTATION_RESOURCE_LINK;
   nw_link->name = name;
   nw_link->bw_current = bw_initial;
@@ -657,6 +761,10 @@ static network_link_L07_t network_link_new(char *name,
     nw_link->bw_event =
 	tmgr_history_add_trace(history, bw_trace, 0.0, 0, nw_link);
   nw_link->state_current = state_initial;
+  nw_link->lat_current = lat_initial;
+  if (lat_trace)
+    nw_link->lat_event =
+	tmgr_history_add_trace(history, lat_trace, 0.0, 0, nw_link);
   if (state_trace)
     nw_link->state_event =
 	tmgr_history_add_trace(history, state_trace, 0.0, 0, nw_link);
@@ -678,6 +786,8 @@ static void parse_network_link(void)
   char *name;
   double bw_initial;
   tmgr_trace_t bw_trace;
+  double lat_initial;
+  tmgr_trace_t lat_trace;
   e_surf_network_link_state_t state_initial = SURF_NETWORK_LINK_ON;
   e_surf_network_link_sharing_policy_t policy_initial =
       SURF_NETWORK_LINK_SHARED;
@@ -686,6 +796,8 @@ static void parse_network_link(void)
   name = xbt_strdup(A_surfxml_network_link_name);
   surf_parse_get_double(&bw_initial, A_surfxml_network_link_bandwidth);
   surf_parse_get_trace(&bw_trace, A_surfxml_network_link_bandwidth_file);
+  surf_parse_get_double(&lat_initial, A_surfxml_network_link_latency);
+  surf_parse_get_trace(&lat_trace, A_surfxml_network_link_latency_file);
 
   xbt_assert0((A_surfxml_network_link_state ==
 	       A_surfxml_network_link_state_ON)
@@ -706,8 +818,8 @@ static void parse_network_link(void)
 
   surf_parse_get_trace(&state_trace, A_surfxml_network_link_state_file);
 
-  network_link_new(name, bw_initial, bw_trace, state_initial, state_trace,
-		   policy_initial);
+  network_link_new(name, bw_initial, bw_trace, lat_initial, lat_trace,
+		   state_initial, state_trace, policy_initial);
 }
 
 static void route_new(int src_id, int dst_id,
@@ -804,7 +916,7 @@ static void parse_file(const char *file)
     if (!ROUTE(i, i).size) {
       if (!loopback)
 	loopback = network_link_new(xbt_strdup("__MSG_loopback__"),
-				    498000000, NULL,
+				    498000000, NULL, 0.000015, NULL,
 				    SURF_NETWORK_LINK_ON, NULL,
 				    SURF_NETWORK_LINK_FATPIPE);
 
@@ -818,83 +930,83 @@ static void parse_file(const char *file)
 /********* Module  creation ***********/
 /**************************************/
 
-static void resource_init_internal(void)
+static void model_init_internal(void)
 {
   s_surf_action_t action;
 
-  surf_workstation_resource = xbt_new0(s_surf_workstation_resource_t, 1);
+  surf_workstation_model = xbt_new0(s_surf_workstation_model_t, 1);
 
-  surf_workstation_resource->common_private =
-      xbt_new0(s_surf_resource_private_t, 1);
-  surf_workstation_resource->common_public =
-      xbt_new0(s_surf_resource_public_t, 1);
-  surf_workstation_resource->extension_public =
-      xbt_new0(s_surf_workstation_resource_extension_public_t, 1);
+  surf_workstation_model->common_private =
+      xbt_new0(s_surf_model_private_t, 1);
+  surf_workstation_model->common_public =
+      xbt_new0(s_surf_model_public_t, 1);
+  surf_workstation_model->extension_public =
+      xbt_new0(s_surf_workstation_model_extension_public_t, 1);
 
-  surf_workstation_resource->common_public->states.ready_action_set =
+  surf_workstation_model->common_public->states.ready_action_set =
       xbt_swag_new(xbt_swag_offset(action, state_hookup));
-  surf_workstation_resource->common_public->states.running_action_set =
+  surf_workstation_model->common_public->states.running_action_set =
       xbt_swag_new(xbt_swag_offset(action, state_hookup));
-  surf_workstation_resource->common_public->states.failed_action_set =
+  surf_workstation_model->common_public->states.failed_action_set =
       xbt_swag_new(xbt_swag_offset(action, state_hookup));
-  surf_workstation_resource->common_public->states.done_action_set =
+  surf_workstation_model->common_public->states.done_action_set =
       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 
-  surf_workstation_resource->common_public->name_service = name_service;
-  surf_workstation_resource->common_public->get_resource_name =
+  surf_workstation_model->common_public->name_service = name_service;
+  surf_workstation_model->common_public->get_resource_name =
       get_resource_name;
-  surf_workstation_resource->common_public->action_get_state =
+  surf_workstation_model->common_public->action_get_state =
       surf_action_get_state;
-  surf_workstation_resource->common_public->action_get_start_time =
+  surf_workstation_model->common_public->action_get_start_time =
       surf_action_get_start_time;
-  surf_workstation_resource->common_public->action_get_finish_time =
+  surf_workstation_model->common_public->action_get_finish_time =
       surf_action_get_finish_time;
-  surf_workstation_resource->common_public->action_use = action_use;
-  surf_workstation_resource->common_public->action_free = action_free;
-  surf_workstation_resource->common_public->action_cancel = action_cancel;
-  surf_workstation_resource->common_public->action_recycle =
+  surf_workstation_model->common_public->action_use = action_use;
+  surf_workstation_model->common_public->action_free = action_free;
+  surf_workstation_model->common_public->action_cancel = action_cancel;
+  surf_workstation_model->common_public->action_recycle =
       action_recycle;
-  surf_workstation_resource->common_public->action_change_state =
+  surf_workstation_model->common_public->action_change_state =
       surf_action_change_state;
-  surf_workstation_resource->common_public->action_set_data =
+  surf_workstation_model->common_public->action_set_data =
       surf_action_set_data;
-  surf_workstation_resource->common_public->suspend = action_suspend;
-  surf_workstation_resource->common_public->resume = action_resume;
-  surf_workstation_resource->common_public->is_suspended =
+  surf_workstation_model->common_public->suspend = action_suspend;
+  surf_workstation_model->common_public->resume = action_resume;
+  surf_workstation_model->common_public->is_suspended =
       action_is_suspended;
-  surf_workstation_resource->common_public->set_max_duration =
+  surf_workstation_model->common_public->set_max_duration =
       action_set_max_duration;
-  surf_workstation_resource->common_public->set_priority =
+  surf_workstation_model->common_public->set_priority =
       action_set_priority;
-  surf_workstation_resource->common_public->name = "Workstation ptask_L07";
+  surf_workstation_model->common_public->name = "Workstation ptask_L07";
 
-  surf_workstation_resource->common_private->resource_used = resource_used;
-  surf_workstation_resource->common_private->share_resources =
+  surf_workstation_model->common_private->resource_used = resource_used;
+  surf_workstation_model->common_private->share_resources =
       share_resources;
-  surf_workstation_resource->common_private->update_actions_state =
+  surf_workstation_model->common_private->update_actions_state =
       update_actions_state;
-  surf_workstation_resource->common_private->update_resource_state =
+  surf_workstation_model->common_private->update_resource_state =
       update_resource_state;
-  surf_workstation_resource->common_private->finalize = finalize;
+  surf_workstation_model->common_private->finalize = finalize;
 
-  surf_workstation_resource->extension_public->execute = execute;
-  surf_workstation_resource->extension_public->sleep = action_sleep;
-  surf_workstation_resource->extension_public->get_state =
+  surf_workstation_model->extension_public->execute = execute;
+  surf_workstation_model->extension_public->sleep = action_sleep;
+  surf_workstation_model->extension_public->get_state =
       resource_get_state;
-  surf_workstation_resource->extension_public->get_speed = get_speed;
-  surf_workstation_resource->extension_public->get_available_speed =
+  surf_workstation_model->extension_public->get_speed = get_speed;
+  surf_workstation_model->extension_public->get_available_speed =
       get_available_speed;
-  surf_workstation_resource->extension_public->communicate = communicate;
-  surf_workstation_resource->extension_public->execute_parallel_task =
+  surf_workstation_model->extension_public->communicate = communicate;
+  surf_workstation_model->extension_public->execute_parallel_task =
       execute_parallel_task;
-  surf_workstation_resource->extension_public->get_route = get_route;
-  surf_workstation_resource->extension_public->get_route_size =
+  surf_workstation_model->extension_public->get_route = get_route;
+  surf_workstation_model->extension_public->get_route_size =
       get_route_size;
-  surf_workstation_resource->extension_public->get_link_name =
+  surf_workstation_model->extension_public->get_link_name =
       get_link_name;
-  surf_workstation_resource->extension_public->get_link_bandwidth =
+  surf_workstation_model->extension_public->get_link_bandwidth =
       get_link_bandwidth;
-  surf_workstation_resource->extension_public->get_link_latency =
+  surf_workstation_model->extension_public->get_link_latency =
       get_link_latency;
 
   workstation_set = xbt_dict_new();
@@ -907,18 +1019,17 @@ static void resource_init_internal(void)
 /**************************************/
 /*************** Generic **************/
 /**************************************/
-void surf_workstation_resource_init_ptask_L07(const char *filename)
+void surf_workstation_model_init_ptask_L07(const char *filename)
 {
-  xbt_assert0(!surf_cpu_resource, "CPU resource type already defined");
-  xbt_assert0(!surf_network_resource,
-	      "network resource type already defined");
-  resource_init_internal();
+  xbt_assert0(!surf_cpu_model, "CPU model type already defined");
+  xbt_assert0(!surf_network_model,
+	      "network model type already defined");
+  model_init_internal();
   parse_file(filename);
-  WARN0("This model does not take latency into account.");
 
-  update_resource_description(surf_workstation_resource_description,
-			      surf_workstation_resource_description_size,
+  update_model_description(surf_workstation_model_description,
+			      surf_workstation_model_description_size,
 			      "ptask_L07",
-			      (surf_resource_t) surf_workstation_resource);
-  xbt_dynar_push(resource_list, &surf_workstation_resource);
+			      (surf_model_t) surf_workstation_model);
+  xbt_dynar_push(model_list, &surf_workstation_model);
 }