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 static 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 surf_action_t communicate(void *workstation_src,
 139                                  void *workstation_dst, double size)
 140 {
 141   return surf_network_resource->extension_public->
 142       communicate(((workstation_t) workstation_src)->network_card,
 143                   ((workstation_t) workstation_dst)->network_card, size);
 144 }
 145
 146 static e_surf_cpu_state_t get_state(void *workstation)
 147 {
 148   return surf_cpu_resource->extension_public->
 149       get_state(((workstation_t) workstation)->cpu);
 150 }
 151
 152 static void finalize(void)
 153 {
 154 }
 155
 156 static void surf_workstation_resource_init_internal(void)
 157 {
 158   s_surf_action_t action;
 159
 160   surf_workstation_resource = xbt_new0(s_surf_workstation_resource_t, 1);
 161
 162   surf_workstation_resource->common_private =
 163       xbt_new0(s_surf_resource_private_t, 1);
 164   surf_workstation_resource->common_public =
 165       xbt_new0(s_surf_resource_public_t, 1);
 166 /*   surf_workstation_resource->extension_private = xbt_new0(s_surf_workstation_resource_extension_private_t,1); */
 167   surf_workstation_resource->extension_public =
 168       xbt_new0(s_surf_workstation_resource_extension_public_t, 1);
 169
 170   surf_workstation_resource->common_public->states.ready_action_set =
 171       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 172   surf_workstation_resource->common_public->states.running_action_set =
 173       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 174   surf_workstation_resource->common_public->states.failed_action_set =
 175       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 176   surf_workstation_resource->common_public->states.done_action_set =
 177       xbt_swag_new(xbt_swag_offset(action, state_hookup));
 178
 179   surf_workstation_resource->common_public->name_service = name_service;
 180   surf_workstation_resource->common_public->get_resource_name =
 181       get_resource_name;
 182   surf_workstation_resource->common_public->action_get_state =
 183       surf_action_get_state;
 184   surf_workstation_resource->common_public->action_free = action_free;
 185   surf_workstation_resource->common_public->action_cancel = action_cancel;
 186   surf_workstation_resource->common_public->action_recycle =
 187       action_recycle;
 188   surf_workstation_resource->common_public->action_change_state =
 189       action_change_state;
 190   surf_workstation_resource->common_public->name = "Workstation";
 191
 192   surf_workstation_resource->common_private->resource_used = resource_used;
 193   surf_workstation_resource->common_private->share_resources =
 194       share_resources;
 195   surf_workstation_resource->common_private->update_actions_state =
 196       update_actions_state;
 197   surf_workstation_resource->common_private->update_resource_state =
 198       update_resource_state;
 199   surf_workstation_resource->common_private->finalize = finalize;
 200
 201   surf_workstation_resource->extension_public->execute = execute;
 202   surf_workstation_resource->extension_public->sleep = action_sleep;
 203   surf_workstation_resource->extension_public->suspend = action_suspend;
 204   surf_workstation_resource->extension_public->resume = action_resume;
 205   surf_workstation_resource->extension_public->get_state = get_state;
 206   surf_workstation_resource->extension_public->communicate = communicate;
 207
 208   workstation_set = xbt_dict_new();
 209
 210   xbt_assert0(maxmin_system, "surf_init has to be called first!");
 211 }
 212
 213 void surf_workstation_resource_init(const char *filename)
 214 {
 215 /*   int i ; */
 216 /*   surf_resource_t resource =  NULL; */
 217
 218   surf_workstation_resource_init_internal();
 219   surf_cpu_resource_init(filename);
 220   surf_network_resource_init(filename);
 221   create_workstations();
 222   xbt_dynar_push(resource_list, &surf_workstation_resource);
 223 /*   xbt_dynar_foreach(resource_list, i, resource) { */
 224 /*     if(resource==surf_cpu_resource) { */
 225 /*       xbt_dynar_remove_at(resource_list, i, NULL); */
 226 /*       i--;  */
 227 /*       continue; */
 228 /*     } */
 229 /*     if(resource==surf_network_resource) { */
 230 /*       xbt_dynar_remove_at(resource_list, i, NULL); */
 231 /*       i--;  */
 232 /*       continue; */
 233 /*     } */
 234 /*   } */
 235 }