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/dict.h"
   9 #include "workstation_private.h"
  10 #include "cpu_private.h"
  11 #include "network_private.h"
  12
  13 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(workstation, surf,
  14                                 "Logging specific to the SURF workstation module");
  15
  16 surf_workstation_resource_t surf_workstation_resource = NULL;
  17
  18 xbt_dict_t workstation_set = NULL;
  19
  20 static workstation_t workstation_new(const char *name,
  21                                      void *cpu, void *card)
  22 {
  23   workstation_t workstation = xbt_new0(s_workstation_t, 1);
  24
  25   workstation->resource = (surf_resource_t) surf_workstation_resource;
  26   workstation->name = xbt_strdup(name);
  27   workstation->cpu = cpu;
  28   workstation->network_card = card;
  29
  30   return workstation;
  31 }
  32
  33 static void create_workstations(void)
  34 {
  35   xbt_dict_cursor_t cursor = NULL;
  36   char *name = NULL;
  37   void *cpu = NULL;
  38   void *nw_card = NULL;
  39
  40   xbt_dict_foreach(cpu_set, cursor, name, cpu) {
  41     nw_card = NULL;
  42     xbt_dict_get(network_card_set, name, (void *) &nw_card);
  43     xbt_assert0(nw_card, "No corresponding card found");
  44     xbt_dict_set(workstation_set, name,
  45                  workstation_new(name, cpu, nw_card), NULL);
  46   }
  47 }
  48
  49 static void *name_service(const char *name)
  50 {
  51   void *workstation = NULL;
  52
  53   xbt_dict_get(workstation_set, name, &workstation);
  54
  55   return workstation;
  56 }
  57
  58 static const char *get_resource_name(void *resource_id)
  59 {
  60   return ((workstation_t) resource_id)->name;
  61 }
  62
  63 static int resource_used(void *resource_id)
  64 {
  65   xbt_assert0(0,
  66               "Workstation is a virtual resource. I should not be there!");
  67   return 0;
  68 }
  69
  70 static void action_free(surf_action_t action)
  71 {
  72   return;
  73 }
  74
  75 static void action_cancel(surf_action_t action)
  76 {
  77   return;
  78 }
  79
  80 static void action_recycle(surf_action_t action)
  81 {
  82   return;
  83 }
  84
  85 static void action_change_state(surf_action_t action,
  86                                 e_surf_action_state_t state)
  87 {
  88   surf_action_change_state(action, state);
  89   return;
  90 }
  91
  92 static double share_resources(double now)
  93 {
  94   return -1.0;
  95 }
  96
  97
  98 static void update_actions_state(double now, double delta)
  99 {
 100   return;
 101 }
 102
 103 static void update_resource_state(void *id,
 104                                   tmgr_trace_event_t event_type,
 105                                   double value)
 106 {
 107   return;
 108 }
 109
 110 static surf_action_t execute(void *workstation, double size)
 111 {
 112   return surf_cpu_resource->extension_public->
 113       execute(((workstation_t) workstation)->cpu, size);
 114 }
 115
 116 static surf_action_t action_sleep(void *workstation, double duration)
 117 {
 118   return surf_cpu_resource->extension_public->
 119       sleep(((workstation_t) workstation)->cpu, duration);
 120 }
 121
 122 static void action_suspend(surf_action_t action)
 123 {
 124   xbt_assert0(action->resource_type ==
 125               ((surf_resource_t) surf_cpu_resource),
 126               "Resource type mismatch");
 127   surf_cpu_resource->extension_public->suspend(action);
 128 }
 129
 130 static void action_resume(surf_action_t action)
 131 {
 132   xbt_assert0(action->resource_type ==
 133               ((surf_resource_t) surf_cpu_resource),
 134               "Resource type mismatch");
 135   surf_cpu_resource->extension_public->resume(action);
 136 }
 137
 138 static int action_is_suspended(surf_action_t action)
 139 {
 140   xbt_assert0(action->resource_type ==
 141               ((surf_resource_t) surf_cpu_resource),
 142               "Resource type mismatch");
 143   return surf_cpu_resource->extension_public->is_suspended(action);
 144 }
 145
 146 static surf_action_t communicate(void *workstation_src,
 147                                  void *workstation_dst, double size)
 148 {
 149   return surf_network_resource->extension_public->
 150       communicate(((workstation_t) workstation_src)->network_card,
 151                   ((workstation_t) workstation_dst)->network_card, size);
 152 }
 153
 154 static e_surf_cpu_state_t get_state(void *workstation)
 155 {
 156   return surf_cpu_resource->extension_public->
 157       get_state(((workstation_t) workstation)->cpu);
 158 }
 159
 160 static void finalize(void)
 161 {
 162 }
 163
 164 static void surf_workstation_resource_init_internal(void)
 165 {
 166   s_surf_action_t action;
 167
 168   surf_workstation_resource = xbt_new0(s_surf_workstation_resource_t, 1);
 169
 170   surf_workstation_resource->common_private =
 171       xbt_new0(s_surf_resource_private_t, 1);
 172   surf_workstation_resource->common_public =
 173       xbt_new0(s_surf_resource_public_t, 1);
 174 /*   surf_workstation_resource->extension_private = xbt_new0(s_surf_workstation_resource_extension_private_t,1); */
 175   surf_workstation_resource->extension_public =
 176       xbt_new0(s_surf_workstation_resource_extension_public_t, 1);
 177
 178   surf_workstation_resource->common_public->states.ready_action_set =
 179       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 180   surf_workstation_resource->common_public->states.running_action_set =
 181       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 182   surf_workstation_resource->common_public->states.failed_action_set =
 183       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 184   surf_workstation_resource->common_public->states.done_action_set =
 185       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 186
 187   surf_workstation_resource->common_public->name_service = name_service;
 188   surf_workstation_resource->common_public->get_resource_name =
 189       get_resource_name;
 190   surf_workstation_resource->common_public->action_get_state =
 191       surf_action_get_state;
 192   surf_workstation_resource->common_public->action_free = action_free;
 193   surf_workstation_resource->common_public->action_cancel = action_cancel;
 194   surf_workstation_resource->common_public->action_recycle =
 195       action_recycle;
 196   surf_workstation_resource->common_public->action_change_state =
 197       action_change_state;
 198   surf_workstation_resource->common_public->name = "Workstation";
 199
 200   surf_workstation_resource->common_private->resource_used = resource_used;
 201   surf_workstation_resource->common_private->share_resources =
 202       share_resources;
 203   surf_workstation_resource->common_private->update_actions_state =
 204       update_actions_state;
 205   surf_workstation_resource->common_private->update_resource_state =
 206       update_resource_state;
 207   surf_workstation_resource->common_private->finalize = finalize;
 208
 209   surf_workstation_resource->extension_public->execute = execute;
 210   surf_workstation_resource->extension_public->sleep = action_sleep;
 211   surf_workstation_resource->extension_public->suspend = action_suspend;
 212   surf_workstation_resource->extension_public->resume = action_resume;
 213   surf_workstation_resource->extension_public->is_suspended = action_is_suspended;
 214   surf_workstation_resource->extension_public->get_state = get_state;
 215   surf_workstation_resource->extension_public->communicate = communicate;
 216
 217   workstation_set = xbt_dict_new();
 218
 219   xbt_assert0(maxmin_system, "surf_init has to be called first!");
 220 }
 221
 222 void surf_workstation_resource_init(const char *filename)
 223 {
 224 /*   int i ; */
 225 /*   surf_resource_t resource =  NULL; */
 226
 227   surf_workstation_resource_init_internal();
 228   surf_cpu_resource_init(filename);
 229   surf_network_resource_init(filename);
 230   create_workstations();
 231   xbt_dynar_push(resource_list, &surf_workstation_resource);
 232 /*   xbt_dynar_foreach(resource_list, i, resource) { */
 233 /*     if(resource==surf_cpu_resource) { */
 234 /*       xbt_dynar_remove_at(resource_list, i, NULL); */
 235 /*       i--;  */
 236 /*       continue; */
 237 /*     } */
 238 /*     if(resource==surf_network_resource) { */
 239 /*       xbt_dynar_remove_at(resource_list, i, NULL); */
 240 /*       i--;  */
 241 /*       continue; */
 242 /*     } */
 243 /*   } */
 244 }