src/surf/workstation.c

   1 /*      $Id$     */
   2
   3 /* Copyright (c) 2004 Arnaud Legrand. All rights reserved.                  */
   4
   5 /* This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the license (GNU LGPL) which comes with this package. */
   7
   8 #include "xbt/ex.h"
   9 #include "xbt/dict.h"
  10 #include "portable.h"
  11 #include "workstation_private.h"
  12 #include "cpu_private.h"
  13 #include "network_common.h"
  14
  15 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_workstation, surf,
  16                                 "Logging specific to the SURF workstation module");
  17
  18 surf_workstation_model_t surf_workstation_model = NULL;
  19
  20 static void workstation_free(void *workstation)
  21 {
  22   free(((workstation_CLM03_t) workstation)->name);
  23   free(workstation);
  24 }
  25
  26 static workstation_CLM03_t workstation_new(const char *name,
  27                                            void *cpu, void *card)
  28 {
  29   workstation_CLM03_t workstation = xbt_new0(s_workstation_CLM03_t, 1);
  30
  31   workstation->model = (surf_model_t) surf_workstation_model;
  32   workstation->name = xbt_strdup(name);
  33   workstation->cpu = cpu;
  34   workstation->network_card = card;
  35
  36   xbt_dict_set(surf_model_resource_set(surf_workstation_model),name,workstation,workstation_free);
  37
  38   return workstation;
  39 }
  40
  41 void create_workstations(void)
  42 {
  43   xbt_dict_cursor_t cursor = NULL;
  44   char *name = NULL;
  45   void *cpu = NULL;
  46   void *nw_card = NULL;
  47
  48   xbt_dict_foreach(surf_model_resource_set(surf_cpu_model), cursor, name, cpu) {
  49         nw_card = surf_model_resource_by_name(surf_network_model, name);
  50     xbt_assert1(nw_card, "No corresponding card found for %s", name);
  51
  52     workstation_new(name,cpu,nw_card);
  53   }
  54 }
  55
  56 static const char *get_resource_name(void *resource_id)
  57 {
  58   return ((workstation_CLM03_t) resource_id)->name;
  59 }
  60
  61 static int resource_used(void *resource_id)
  62 {
  63   THROW_IMPOSSIBLE;             /* This model does not implement parallel tasks */
  64 }
  65
  66 static void parallel_action_cancel(surf_action_t action)
  67 {
  68   THROW_UNIMPLEMENTED;          /* This model does not implement parallel tasks */
  69 }
  70
  71 static int parallel_action_free(surf_action_t action)
  72 {
  73   THROW_UNIMPLEMENTED;          /* This model does not implement parallel tasks */
  74 }
  75
  76 static void parallel_action_use(surf_action_t action)
  77 {
  78   THROW_UNIMPLEMENTED;          /* This model does not implement parallel tasks */
  79 }
  80
  81 static int action_free(surf_action_t action)
  82 {
  83   if (action->model_type == (surf_model_t) surf_network_model)
  84     return surf_network_model->common_public.action_free(action);
  85   else if (action->model_type == (surf_model_t) surf_cpu_model)
  86     return surf_cpu_model->common_public.action_free(action);
  87   else if (action->model_type == (surf_model_t) surf_workstation_model)
  88     return parallel_action_free(action);
  89   else
  90     DIE_IMPOSSIBLE;
  91   return 0;
  92 }
  93
  94 static void action_use(surf_action_t action)
  95 {
  96   if (action->model_type == (surf_model_t) surf_network_model)
  97     surf_network_model->common_public.action_use(action);
  98   else if (action->model_type == (surf_model_t) surf_cpu_model)
  99     surf_cpu_model->common_public.action_use(action);
 100   else if (action->model_type == (surf_model_t) surf_workstation_model)
 101     parallel_action_use(action);
 102   else
 103     DIE_IMPOSSIBLE;
 104   return;
 105 }
 106
 107 static void action_cancel(surf_action_t action)
 108 {
 109   if (action->model_type == (surf_model_t) surf_network_model)
 110     surf_network_model->common_public.action_cancel(action);
 111   else if (action->model_type == (surf_model_t) surf_cpu_model)
 112     surf_cpu_model->common_public.action_cancel(action);
 113   else if (action->model_type == (surf_model_t) surf_workstation_model)
 114     parallel_action_cancel(action);
 115   else
 116     DIE_IMPOSSIBLE;
 117   return;
 118 }
 119
 120 static void action_change_state(surf_action_t action,
 121                                 e_surf_action_state_t state)
 122 {
 123   if (action->model_type == (surf_model_t) surf_network_model)
 124     surf_network_model->common_public.action_change_state(action, state);
 125   else if (action->model_type == (surf_model_t) surf_cpu_model)
 126     surf_cpu_model->common_public.action_change_state(action, state);
 127   else if (action->model_type == (surf_model_t) surf_workstation_model)
 128     surf_action_change_state(action, state);
 129   else
 130     DIE_IMPOSSIBLE;
 131   return;
 132 }
 133
 134 static double share_resources(double now)
 135 {
 136   return -1.0;
 137 }
 138
 139 static void update_actions_state(double now, double delta)
 140 {
 141   return;
 142 }
 143
 144 static void update_resource_state(void *id,
 145                                   tmgr_trace_event_t event_type,
 146                                   double value, double date)
 147 {
 148   THROW_IMPOSSIBLE;             /* This model does not implement parallel tasks */
 149 }
 150
 151 static surf_action_t execute(void *workstation, double size)
 152 {
 153   return surf_cpu_model->
 154     extension_public->execute(((workstation_CLM03_t) workstation)->cpu, size);
 155 }
 156
 157 static surf_action_t action_sleep(void *workstation, double duration)
 158 {
 159   return surf_cpu_model->
 160     extension_public->sleep(((workstation_CLM03_t) workstation)->cpu,
 161                             duration);
 162 }
 163
 164 static void action_suspend(surf_action_t action)
 165 {
 166   if (action->model_type == (surf_model_t) surf_network_model)
 167     surf_network_model->common_public.suspend(action);
 168   else if (action->model_type == (surf_model_t) surf_cpu_model)
 169     surf_cpu_model->common_public.suspend(action);
 170   else
 171     DIE_IMPOSSIBLE;
 172 }
 173
 174 static void action_resume(surf_action_t action)
 175 {
 176   if (action->model_type == (surf_model_t) surf_network_model)
 177     surf_network_model->common_public.resume(action);
 178   else if (action->model_type == (surf_model_t) surf_cpu_model)
 179     surf_cpu_model->common_public.resume(action);
 180   else
 181     DIE_IMPOSSIBLE;
 182 }
 183
 184 static int action_is_suspended(surf_action_t action)
 185 {
 186   if (action->model_type == (surf_model_t) surf_network_model)
 187     return surf_network_model->common_public.is_suspended(action);
 188   if (action->model_type == (surf_model_t) surf_cpu_model)
 189     return surf_cpu_model->common_public.is_suspended(action);
 190   DIE_IMPOSSIBLE;
 191 }
 192
 193 static void action_set_max_duration(surf_action_t action, double duration)
 194 {
 195   if (action->model_type == (surf_model_t) surf_network_model)
 196     surf_network_model->common_public.set_max_duration(action, duration);
 197   else if (action->model_type == (surf_model_t) surf_cpu_model)
 198     surf_cpu_model->common_public.set_max_duration(action, duration);
 199   else
 200     DIE_IMPOSSIBLE;
 201 }
 202
 203 static void action_set_priority(surf_action_t action, double priority)
 204 {
 205   if (action->model_type == (surf_model_t) surf_network_model)
 206     surf_network_model->common_public.set_priority(action, priority);
 207   else if (action->model_type == (surf_model_t) surf_cpu_model)
 208     surf_cpu_model->common_public.set_priority(action, priority);
 209   else
 210     DIE_IMPOSSIBLE;
 211 }
 212
 213 static surf_action_t communicate(void *workstation_src,
 214                                  void *workstation_dst, double size,
 215                                  double rate)
 216 {
 217   return surf_network_model->
 218     extension_public->communicate(((workstation_CLM03_t) workstation_src)->
 219                                   network_card,
 220                                   ((workstation_CLM03_t) workstation_dst)->
 221                                   network_card, size, rate);
 222 }
 223
 224 static e_surf_cpu_state_t get_state(void *workstation)
 225 {
 226   return surf_cpu_model->
 227     extension_public->get_state(((workstation_CLM03_t) workstation)->cpu);
 228 }
 229
 230 static double get_speed(void *workstation, double load)
 231 {
 232   return surf_cpu_model->
 233     extension_public->get_speed(((workstation_CLM03_t) workstation)->cpu,
 234                                 load);
 235 }
 236
 237 static double get_available_speed(void *workstation)
 238 {
 239   return surf_cpu_model->
 240     extension_public->get_available_speed(((workstation_CLM03_t)
 241                                            workstation)->cpu);
 242 }
 243
 244 static xbt_dict_t get_properties(void *workstation)
 245 {
 246   return surf_cpu_model->
 247     common_public.get_properties(((workstation_CLM03_t) workstation)->cpu);
 248 }
 249
 250 static surf_action_t execute_parallel_task(int workstation_nb,
 251                                            void **workstation_list,
 252                                            double *computation_amount,
 253                                            double *communication_amount,
 254                                            double amount, double rate)
 255 {
 256   THROW_UNIMPLEMENTED;          /* This model does not implement parallel tasks */
 257 }
 258
 259
 260 /* returns an array of network_link_CM02_t */
 261 static const void **get_route(void *src, void *dst)
 262 {
 263   workstation_CLM03_t workstation_src = (workstation_CLM03_t) src;
 264   workstation_CLM03_t workstation_dst = (workstation_CLM03_t) dst;
 265   return surf_network_model->extension_public->get_route(workstation_src->
 266                                                          network_card,
 267                                                          workstation_dst->
 268                                                          network_card);
 269 }
 270
 271 static int get_route_size(void *src, void *dst)
 272 {
 273   workstation_CLM03_t workstation_src = (workstation_CLM03_t) src;
 274   workstation_CLM03_t workstation_dst = (workstation_CLM03_t) dst;
 275   return surf_network_model->
 276     extension_public->get_route_size(workstation_src->network_card,
 277                                      workstation_dst->network_card);
 278 }
 279
 280 static const char *get_link_name(const void *link)
 281 {
 282   return surf_network_model->extension_public->get_link_name(link);
 283 }
 284
 285 static double get_link_bandwidth(const void *link)
 286 {
 287   return surf_network_model->extension_public->get_link_bandwidth(link);
 288 }
 289
 290 static double get_link_latency(const void *link)
 291 {
 292   return surf_network_model->extension_public->get_link_latency(link);
 293 }
 294
 295 static int link_shared(const void *link)
 296 {
 297   return surf_network_model->extension_public->get_link_latency(link);
 298 }
 299
 300 static void finalize(void)
 301 {
 302   surf_model_exit((surf_model_t)surf_workstation_model);
 303
 304   free(surf_workstation_model->extension_public);
 305
 306   free(surf_workstation_model);
 307   surf_workstation_model = NULL;
 308 }
 309
 310 static void surf_workstation_model_init_internal(void)
 311 {
 312   surf_workstation_model = xbt_new0(s_surf_workstation_model_t, 1);
 313
 314   surf_model_init((surf_model_t)surf_workstation_model);
 315 /*   surf_workstation_model->extension_private = xbt_new0(s_surf_workstation_model_extension_private_t,1); */
 316   surf_workstation_model->extension_public =
 317     xbt_new0(s_surf_workstation_model_extension_public_t, 1);
 318
 319   surf_workstation_model->common_public.get_resource_name =
 320     get_resource_name;
 321   surf_workstation_model->common_public.action_get_state =
 322     surf_action_get_state;
 323   surf_workstation_model->common_public.action_get_start_time =
 324     surf_action_get_start_time;
 325   surf_workstation_model->common_public.action_get_finish_time =
 326     surf_action_get_finish_time;
 327   surf_workstation_model->common_public.action_free = action_free;
 328   surf_workstation_model->common_public.action_use = action_use;
 329   surf_workstation_model->common_public.action_cancel = action_cancel;
 330   surf_workstation_model->common_public.action_change_state =
 331     action_change_state;
 332   surf_workstation_model->common_public.action_set_data =
 333     surf_action_set_data;
 334   surf_workstation_model->common_public.name = "Workstation";
 335
 336   surf_workstation_model->common_private->resource_used = resource_used;
 337   surf_workstation_model->common_private->share_resources = share_resources;
 338   surf_workstation_model->common_private->update_actions_state =
 339     update_actions_state;
 340   surf_workstation_model->common_private->update_resource_state =
 341     update_resource_state;
 342   surf_workstation_model->common_private->finalize = finalize;
 343
 344   surf_workstation_model->common_public.suspend = action_suspend;
 345   surf_workstation_model->common_public.resume = action_resume;
 346   surf_workstation_model->common_public.is_suspended = action_is_suspended;
 347   surf_workstation_model->common_public.set_max_duration =
 348     action_set_max_duration;
 349   surf_workstation_model->common_public.set_priority = action_set_priority;
 350
 351   surf_workstation_model->extension_public->execute = execute;
 352   surf_workstation_model->extension_public->sleep = action_sleep;
 353   surf_workstation_model->extension_public->get_state = get_state;
 354   surf_workstation_model->extension_public->get_speed = get_speed;
 355   surf_workstation_model->extension_public->get_available_speed =
 356     get_available_speed;
 357
 358   /*manage the properties of the workstation */
 359   surf_workstation_model->common_public.get_properties = get_properties;
 360
 361   surf_workstation_model->extension_public->communicate = communicate;
 362   surf_workstation_model->extension_public->execute_parallel_task =
 363     execute_parallel_task;
 364   surf_workstation_model->extension_public->get_route = get_route;
 365   surf_workstation_model->extension_public->get_route_size = get_route_size;
 366   surf_workstation_model->extension_public->get_link_name = get_link_name;
 367   surf_workstation_model->extension_public->get_link_bandwidth =
 368     get_link_bandwidth;
 369   surf_workstation_model->extension_public->get_link_latency =
 370     get_link_latency;
 371   surf_workstation_model->extension_public->link_shared = link_shared;
 372 }
 373
 374 /********************************************************************/
 375 /* The model used in MSG and presented at CCGrid03                  */
 376 /********************************************************************/
 377 /* @InProceedings{Casanova.CLM_03, */
 378 /*   author = {Henri Casanova and Arnaud Legrand and Loris Marchal}, */
 379 /*   title = {Scheduling Distributed Applications: the SimGrid Simulation Framework}, */
 380 /*   booktitle = {Proceedings of the third IEEE International Symposium on Cluster Computing and the Grid (CCGrid'03)}, */
 381 /*   publisher = {"IEEE Computer Society Press"}, */
 382 /*   month = {may}, */
 383 /*   year = {2003} */
 384 /* } */
 385 void surf_workstation_model_init_CLM03(const char *filename)
 386 {
 387   surf_workstation_model_init_internal();
 388   surf_cpu_model_init_Cas01(filename);
 389   surf_network_model_init_CM02(filename);
 390   update_model_description(surf_workstation_model_description,
 391                            "CLM03", (surf_model_t) surf_workstation_model);
 392   xbt_dynar_push(model_list, &surf_workstation_model);
 393 }
 394
 395 void surf_workstation_model_init_compound(const char *filename)
 396 {
 397
 398   xbt_assert0(surf_cpu_model, "No CPU model defined yet!");
 399   xbt_assert0(surf_network_model, "No network model defined yet!");
 400   surf_workstation_model_init_internal();
 401
 402   update_model_description(surf_workstation_model_description,
 403                            "compound", (surf_model_t) surf_workstation_model);
 404
 405   xbt_dynar_push(model_list, &surf_workstation_model);
 406 }