From 6604439f3437486f84c0e239f28b162662631127 Mon Sep 17 00:00:00 2001 From: thiery Date: Fri, 16 Jun 2006 13:32:52 +0000 Subject: [PATCH 1/1] Update workstation handling in SimDag. Change the prefix of SimDag functions with SD_* instead of the old SG_*. git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/simgrid/simgrid/trunk@2384 48e7efb5-ca39-0410-a469-dd3cf9ba447f --- include/simdag/datatypes.h | 36 +++++++-------- include/simdag/simdag.h | 90 ++++++++++++++++++------------------- src/simdag/private.h | 24 +++++----- src/simdag/sd_global.c | 59 +++++++++++------------- src/simdag/sd_link.c | 28 ++++++------ src/simdag/sd_task.c | 38 ++++++++-------- src/simdag/sd_workstation.c | 84 ++++++++++++++++++---------------- 7 files changed, 178 insertions(+), 181 deletions(-) diff --git a/include/simdag/datatypes.h b/include/simdag/datatypes.h index 1b1ad0beb0..78b64b67db 100644 --- a/include/simdag/datatypes.h +++ b/include/simdag/datatypes.h @@ -2,46 +2,42 @@ #define SIMDAG_DATATYPES_H /* Link */ -typedef struct SG_link_data *SG_link_data_t; +typedef struct SD_link_data *SD_link_data_t; -typedef struct SG_link { - SG_link_data_t sgdata; /* SG internal data */ +typedef struct SD_link { + SD_link_data_t sd_data; /* SD internal data */ void *data; /* user data */ char *name; /*double capacity;*/ /*double current_bandwidth; double current_latency;*/ -} s_SG_link_t, *SG_link_t; +} s_SD_link_t, *SD_link_t; /* Workstation */ -typedef struct SG_workstation_data *SG_workstation_data_t; +typedef struct SD_workstation_data *SD_workstation_data_t; -typedef struct SG_workstation { - SG_workstation_data_t sgdata; /* SG internal data */ +typedef struct SD_workstation { + SD_workstation_data_t sd_data; /* SD internal data */ void *data; /* user data */ - char *name; - - /* double power; - double available_power;*/ -} s_SG_workstation_t, *SG_workstation_t; +} s_SD_workstation_t, *SD_workstation_t; /* Task state */ typedef enum { - SG_SCHEDULED, - SG_RUNNING, - SG_DONE, - SG_FAILED -} SG_task_state_t; + SD_SCHEDULED, + SD_RUNNING, + SD_DONE, + SD_FAILED +} SD_task_state_t; /* Task */ -typedef struct SG_task { +typedef struct SD_task { void *data; char *name; /*double amount; double remaining_amount;*/ - SG_task_state_t state; + SD_task_state_t state; /* TODO: dependencies + watch */ -} s_SG_task_t, *SG_task_t; +} s_SD_task_t, *SD_task_t; #endif diff --git a/include/simdag/simdag.h b/include/simdag/simdag.h index 609f689d1e..f32f330285 100644 --- a/include/simdag/simdag.h +++ b/include/simdag/simdag.h @@ -8,69 +8,69 @@ SG_BEGIN_DECL() /************************** Link handling ***********************************/ -/* private (called by SG_environment_create) -SG_link_t SG_link_create(void *data, const char *name, +/* private (called by SD_environment_create) +SD_link_t SD_link_create(void *data, const char *name, double bandwidth, double latency);*/ -void* SG_link_get_data(SG_link_t link); -void SG_link_set_data(SG_link_t link, void *data); -const char* SG_link_get_name(SG_link_t link); -double SG_link_get_capacity(SG_link_t link); -double SG_link_get_current_bandwidth(SG_link_t link); -double SG_link_get_current_latency(SG_link_t link); -/* private (called by SG_clean) -void SG_link_destroy(SG_link_t link); +void* SD_link_get_data(SD_link_t link); +void SD_link_set_data(SD_link_t link, void *data); +const char* SD_link_get_name(SD_link_t link); +double SD_link_get_capacity(SD_link_t link); +double SD_link_get_current_bandwidth(SD_link_t link); +double SD_link_get_current_latency(SD_link_t link); +/* private (called by SD_clean) +void SD_link_destroy(SD_link_t link); */ /************************** Workstation handling ****************************/ -/* private (called by SG_environment_create) -SG_workstation_t SG_workstation_create(void *data, const char *name, double power, +/* private (called by SD_environment_create) +SD_workstation_t SD_workstation_create(void *data, const char *name, double power, double available_power);*/ -SG_workstation_t SG_workstation_get_by_name(const char *name); -SG_workstation_t* SG_workstation_get_list(void); -int SG_workstation_get_number(void); -void SG_workstation_set_data(SG_workstation_t workstation, void *data); -void* SG_workstation_get_data(SG_workstation_t workstation); -const char* SG_workstation_get_name(SG_workstation_t workstation); -SG_link_t* SG_workstation_route_get_list(SG_workstation_t src, SG_workstation_t dst); -int SG_workstation_route_get_size(SG_workstation_t src, SG_workstation_t dst); -double SG_workstation_get_power(SG_workstation_t workstation); -double SG_workstation_get_available_power(SG_workstation_t workstation); -/* private (called by SG_clean) -void SG_workstation_destroy(SG_workstation_t workstation); +SD_workstation_t SD_workstation_get_by_name(const char *name); +SD_workstation_t* SD_workstation_get_list(void); +int SD_workstation_get_number(void); +void SD_workstation_set_data(SD_workstation_t workstation, void *data); +void* SD_workstation_get_data(SD_workstation_t workstation); +const char* SD_workstation_get_name(SD_workstation_t workstation); +SD_link_t* SD_workstation_route_get_list(SD_workstation_t src, SD_workstation_t dst); +int SD_workstation_route_get_size(SD_workstation_t src, SD_workstation_t dst); +double SD_workstation_get_power(SD_workstation_t workstation); +double SD_workstation_get_available_power(SD_workstation_t workstation); +/* private (called by SD_clean) +void SD_workstation_destroy(SD_workstation_t workstation); */ /************************** Task handling ************************************/ -SG_task_t SG_task_create(const char *name, void *data, double amount); -int SG_task_schedule(SG_task_t task, int workstation_nb, - SG_workstation_t **workstation_list, double *computation_amount, +SD_task_t SD_task_create(const char *name, void *data, double amount); +int SD_task_schedule(SD_task_t task, int workstation_nb, + SD_workstation_t **workstation_list, double *computation_amount, double *communication_amount, double rate); -void* SG_task_get_data(SG_task_t task); -void SG_task_set_data(SG_task_t task, void *data); -const char* SG_task_get_name(SG_task_t task); -double SG_task_get_amount(SG_task_t task); -double SG_task_get_remaining_amount(SG_task_t task); -void SG_task_dependency_add(const char *name, void *data, SG_task_t src, SG_task_t dst); -void SG_task_dependency_remove(SG_task_t src, SG_task_t dst); -SG_task_state_t SG_task_get_state(SG_task_t task); -/* SG_task_state_t can be either SG_SCHEDULED, SG_RUNNING, SG_DONE, or SG_FAILED */ +void* SD_task_get_data(SD_task_t task); +void SD_task_set_data(SD_task_t task, void *data); +const char* SD_task_get_name(SD_task_t task); +double SD_task_get_amount(SD_task_t task); +double SD_task_get_remaining_amount(SD_task_t task); +void SD_task_dependency_add(const char *name, void *data, SD_task_t src, SD_task_t dst); +void SD_task_dependency_remove(SD_task_t src, SD_task_t dst); +SD_task_state_t SD_task_get_state(SD_task_t task); +/* SD_task_state_t can be either SD_SCHEDULED, SD_RUNNING, SD_DONE, or SD_FAILED */ -void SG_task_watch(SG_task_t task, SG_task_state_t state); -/* SG_simulate will stop as soon as the state of this task is the one given in argument. +void SD_task_watch(SD_task_t task, SD_task_state_t state); +/* SD_simulate will stop as soon as the state of this task is the one given in argument. Watch-point is then automatically removed */ -void SG_task_unwatch(SG_task_t task, SG_task_state_t state); -void SG_task_unschedule(SG_task_t task); /* change state and rerun */ -void SG_task_destroy(SG_task_t task); +void SD_task_unwatch(SD_task_t task, SD_task_state_t state); +void SD_task_unschedule(SD_task_t task); /* change state and rerun */ +void SD_task_destroy(SD_task_t task); /************************** Global *******************************************/ -void SG_init(int *argc, char **argv); -void SG_create_environment(const char *platform_file); -SG_task_t *SG_simulate(double how_long); /* returns a NULL-terminated array of SG_task_t whose state has changed */ -void SG_clean(); /* cleans everything */ +void SD_init(int *argc, char **argv); +void SD_create_environment(const char *platform_file); +SD_task_t *SD_simulate(double how_long); /* returns a NULL-terminated array of SD_task_t whose state has changed */ +void SD_clean(); /* cleans everything */ SG_END_DECL() diff --git a/src/simdag/private.h b/src/simdag/private.h index c86ff69b8d..cd71a5aec0 100644 --- a/src/simdag/private.h +++ b/src/simdag/private.h @@ -5,33 +5,35 @@ #include "simdag/simdag.h" #include "simdag/datatypes.h" +#define CHECK_INIT_DONE() xbt_assert0(sd_global != NULL, "SD_init not called yet") + /* Global variables */ -typedef struct SG_global { +typedef struct SD_global { xbt_dict_t workstations; /* workstation list */ int workstation_count; /* number of workstations */ -} s_SG_global_t, *SG_global_t; +} s_SD_global_t, *SD_global_t; -extern SG_global_t sg_global; +extern SD_global_t sd_global; /* Link private data */ -typedef struct SG_link_data { +typedef struct SD_link_data { void* surf_link; /* surf object */ -} s_SG_link_data_t; +} s_SD_link_data_t; /* Workstation private data */ -typedef struct SG_workstation_data { +typedef struct SD_workstation_data { void* surf_workstation; /* surf object */ /* TODO: route */ -} s_SG_workstation_data_t; +} s_SD_workstation_data_t; /* Private functions */ -SG_link_t __SG_link_create(const char *name, void *surf_link, void *data); -void __SG_link_destroy(SG_link_t link); +SD_link_t __SD_link_create(const char *name, void *surf_link, void *data); +void __SD_link_destroy(SD_link_t link); -SG_workstation_t __SG_workstation_create(const char *name, void *surf_workstation, void *data); -void __SG_workstation_destroy(SG_workstation_t workstation); +SD_workstation_t __SD_workstation_create(void *surf_workstation, void *data); +void __SD_workstation_destroy(SD_workstation_t workstation); #endif diff --git a/src/simdag/sd_global.c b/src/simdag/sd_global.c index 89edfedbce..afc5da5e38 100644 --- a/src/simdag/sd_global.c +++ b/src/simdag/sd_global.c @@ -4,71 +4,64 @@ #include "xbt/sysdep.h" #include "surf/surf.h" -#define CHECK_INIT_DONE() xbt_assert0(init_done, "SG_init not called yet") +SD_global_t sd_global = NULL; -SG_global_t sg_global = NULL; - -static int init_done = 0; - -/* Initialises SG internal data. This function should be called before any other SG function. +/* Initialises SD internal data. This function should be called before any other SD function. */ -void SG_init(int *argc, char **argv) { - xbt_assert0(!init_done, "SG_init already called"); +void SD_init(int *argc, char **argv) { + xbt_assert0(sd_global == NULL, "SD_init already called"); - sg_global = xbt_new0(s_SG_global_t, 1); - sg_global->workstations = xbt_dict_new(); - sg_global->workstation_count = 0; + sd_global = xbt_new0(s_SD_global_t, 1); + sd_global->workstations = xbt_dict_new(); + sd_global->workstation_count = 0; surf_init(argc, argv); - - init_done = 1; } /* Creates the environnement described in a xml file of a platform descriptions. */ -void SG_create_environment(const char *platform_file) { +void SD_create_environment(const char *platform_file) { xbt_dict_cursor_t cursor = NULL; char *name = NULL; - void *workstation = NULL; + void *surf_workstation = NULL; CHECK_INIT_DONE(); surf_timer_resource_init(platform_file); surf_workstation_resource_init_KCCFLN05(platform_file); /* tell Surf to create the environnement */ - /* now let's create the SG wrappers */ - xbt_dict_foreach(workstation_set, cursor, name, workstation) { - __SG_workstation_create(name, workstation, NULL); + /* now let's create the SD wrappers */ + xbt_dict_foreach(workstation_set, cursor, name, surf_workstation) { + __SD_workstation_create(surf_workstation, NULL); } } -/* Launches the simulation. Returns a NULL-terminated array of SG_task_t whose state has changed. +/* Launches the simulation. Returns a NULL-terminated array of SD_task_t whose state has changed. */ -SG_task_t* SG_simulate(double how_long) +SD_task_t* SD_simulate(double how_long) { /* TODO */ - /* temporary test to access to the surf workstation structure */ + /* temporary test to explore the workstations */ xbt_dict_cursor_t cursor = NULL; char *name = NULL; - void *workstation = NULL; - const char *surf_name; - int speed; + SD_workstation_t workstation = NULL; + double power; - xbt_dict_foreach(workstation_set, cursor, name, workstation) { - surf_name = surf_workstation_resource->common_public->get_resource_name(workstation); - speed = surf_workstation_resource->extension_public->get_speed(workstation, 1.0); - printf("Workstation name: %s, Surf name: %s, speed: %d\n", name, surf_name, speed); + xbt_dict_foreach(sd_global->workstations, cursor, name, workstation) { + power = SD_workstation_get_power(workstation); + printf("Workstation name: %s, power: %f Mflop/s\n", name, power); } + /* TODO: remove name from SD workstation structure */ return NULL; } -/* Destroys all SG data. This function should be called when the simulation is over. +/* Destroys all SD data. This function should be called when the simulation is over. */ -void SG_clean() { - if (init_done) { - xbt_dict_free(&sg_global->workstations); - xbt_free(sg_global); +void SD_clean() { + if (sd_global != NULL) { + xbt_dict_free(&sd_global->workstations); + xbt_free(sd_global); surf_exit(); /* TODO: destroy the workstations, the links and the tasks */ } diff --git a/src/simdag/sd_link.c b/src/simdag/sd_link.c index e130213202..424ebc3488 100644 --- a/src/simdag/sd_link.c +++ b/src/simdag/sd_link.c @@ -4,15 +4,15 @@ /* Creates a link. */ -SG_link_t __SG_link_create(const char *name, void *surf_link, void *data) { +SD_link_t __SD_link_create(const char *name, void *surf_link, void *data) { xbt_assert0(surf_link != NULL, "surf_link is NULL !"); - SG_link_data_t sgdata = xbt_new0(s_SG_link_data_t, 1); /* link private data */ - sgdata->surf_link = surf_link; + SD_link_data_t sd_data = xbt_new0(s_SD_link_data_t, 1); /* link private data */ + sd_data->surf_link = surf_link; - SG_link_t link = xbt_new0(s_SG_link_t, 1); + SD_link_t link = xbt_new0(s_SD_link_t, 1); link->name = xbt_strdup(name); link->data = data; - link->sgdata = sgdata; + link->sd_data = sd_data; /*link->capacity = capacity;*/ /* link->current_bandwidth = bandwidth; @@ -23,21 +23,21 @@ SG_link_t __SG_link_create(const char *name, void *surf_link, void *data) { /* Returns the user data of a link. The user data can be NULL. */ -void* SG_link_get_data(SG_link_t link) { +void* SD_link_get_data(SD_link_t link) { xbt_assert0(link, "Invalid parameter"); return link->data; } /* Sets the user data of a link. The new data can be NULL. The old data should have been freed first if it was not NULL. */ -void SG_link_set_data(SG_link_t link, void *data) { +void SD_link_set_data(SD_link_t link, void *data) { xbt_assert0(link, "Invalid parameter"); link->data = data; } /* Returns the name of a link. The name can be NULL. */ -const char* SG_link_get_name(SG_link_t link) { +const char* SD_link_get_name(SD_link_t link) { xbt_assert0(link, "Invalid parameter"); return link->name; } @@ -45,14 +45,14 @@ const char* SG_link_get_name(SG_link_t link) { /* Returns the capacity of a link. */ /* -double SG_link_get_capacity(SG_link_t link) { +double SD_link_get_capacity(SD_link_t link) { xbt_assert0(link, "Invalid parameter"); return link->capacity; }*/ /* Return the current bandwidth of a link. */ -double SG_link_get_current_bandwidth(SG_link_t link) { +double SD_link_get_current_bandwidth(SD_link_t link) { xbt_assert0(link, "Invalid parameter"); /* TODO */ @@ -62,7 +62,7 @@ double SG_link_get_current_bandwidth(SG_link_t link) { /* Return the current latency of a link. */ -double SG_link_get_current_latency(SG_link_t link) { +double SD_link_get_current_latency(SD_link_t link) { xbt_assert0(link, "Invalid parameter"); /* TODO */ @@ -72,11 +72,11 @@ double SG_link_get_current_latency(SG_link_t link) { /* Destroys a link. The user data (if any) should have been destroyed first. */ -void __SG_link_destroy(SG_link_t link) { +void __SD_link_destroy(SD_link_t link) { xbt_assert0(link, "Invalid parameter"); - if (link->sgdata != NULL) - xbt_free(link->sgdata); + if (link->sd_data != NULL) + xbt_free(link->sd_data); if (link->name != NULL) xbt_free(link->name); diff --git a/src/simdag/sd_task.c b/src/simdag/sd_task.c index 3a22af598f..2a8dac0f59 100644 --- a/src/simdag/sd_task.c +++ b/src/simdag/sd_task.c @@ -3,17 +3,17 @@ /* Creates a task. */ -SG_task_t SG_task_create(const char *name, void *data, double amount) { +SD_task_t SD_task_create(const char *name, void *data, double amount) { xbt_assert0(amount >= 0, "Invalid parameter"); /* or amount > 0 ? */ - SG_task_t task = xbt_new0(s_SG_task_t, 1); + SD_task_t task = xbt_new0(s_SD_task_t, 1); task->data = data; task->name = xbt_strdup(name); /*task->amount = amount; task->remaining_amount = amount;*/ - task->state = SG_SCHEDULED; /* not sure... should we add a state SG_NOT_SCHEDULED? */ + task->state = SD_SCHEDULED; /* not sure... should we add a state SD_NOT_SCHEDULED? */ /* TODO: dependencies + watch */ return task; @@ -21,8 +21,8 @@ SG_task_t SG_task_create(const char *name, void *data, double amount) { /* Schedules a task. */ -int SG_task_schedule(SG_task_t task, int workstation_nb, - SG_workstation_t **workstation_list, double *computation_amount, +int SD_task_schedule(SD_task_t task, int workstation_nb, + SD_workstation_t **workstation_list, double *computation_amount, double *communication_amount, double rate) { xbt_assert0(task, "Invalid parameter"); /* TODO */ @@ -32,28 +32,28 @@ int SG_task_schedule(SG_task_t task, int workstation_nb, /* Returns the data of a task. */ -void* SG_task_get_data(SG_task_t task) { +void* SD_task_get_data(SD_task_t task) { xbt_assert0(task, "Invalid parameter"); return task->data; } /* Sets the data of a task. */ -void SG_task_set_data(SG_task_t task, void *data) { +void SD_task_set_data(SD_task_t task, void *data) { xbt_assert0(task, "Invalid parameter"); task->data = data; } /* Returns the name of a task. */ -const char* SG_task_get_name(SG_task_t task) { +const char* SD_task_get_name(SD_task_t task) { xbt_assert0(task, "Invalid parameter"); return task->name; } /* Returns the computing amount of a task. */ -double SG_task_get_amount(SG_task_t task) { +double SD_task_get_amount(SD_task_t task) { xbt_assert0(task, "Invalid parameter"); /* TODO */ @@ -63,7 +63,7 @@ double SG_task_get_amount(SG_task_t task) { /* Returns the remaining computing amount of a task. */ -double SG_task_get_remaining_amount(SG_task_t task) { +double SD_task_get_remaining_amount(SD_task_t task) { xbt_assert0(task, "Invalid parameter") /* TODO (surf encapsulation) */; @@ -72,37 +72,37 @@ double SG_task_get_remaining_amount(SG_task_t task) { /* Adds a dependency between two tasks. */ -void SG_task_dependency_add(const char *name, void *data, SG_task_t src, SG_task_t dst) { +void SD_task_dependency_add(const char *name, void *data, SD_task_t src, SD_task_t dst) { xbt_assert0(src != NULL && dst != NULL, "Invalid parameter"); /* TODO */ } /* Removes a dependency between two tasks. */ -void SG_task_dependency_remove(SG_task_t src, SG_task_t dst) { +void SD_task_dependency_remove(SD_task_t src, SD_task_t dst) { xbt_assert0(src != NULL && dst != NULL, "Invalid parameter"); /* TODO */ } -/* Returns the state of a task: SG_SCHEDULED, SG_RUNNING, SG_DONE or SG_FAILED. +/* Returns the state of a task: SD_SCHEDULED, SD_RUNNING, SD_DONE or SD_FAILED. */ -SG_task_state_t SG_task_get_state(SG_task_t task) { +SD_task_state_t SD_task_get_state(SD_task_t task) { xbt_assert0(task, "Invalid parameter"); return task->state; } /* Adds a watch point to a task. - SG_simulate will stop as soon as the state of this task is the one given in argument. + SD_simulate will stop as soon as the state of this task is the one given in argument. Watch point is then automatically removed. */ -void SG_task_watch(SG_task_t task, SG_task_state_t state) { +void SD_task_watch(SD_task_t task, SD_task_state_t state) { xbt_assert0(task, "Invalid parameter"); /* TODO */ } /* Removes a watch point from a task. */ -void SG_task_unwatch(SG_task_t task, SG_task_state_t state) { +void SD_task_unwatch(SD_task_t task, SD_task_state_t state) { xbt_assert0(task, "Invalid parameter"); /* TODO */ } @@ -110,14 +110,14 @@ void SG_task_unwatch(SG_task_t task, SG_task_state_t state) { /* Unschedules a task. Change state and rerun */ -void SG_task_unschedule(SG_task_t task) { +void SD_task_unschedule(SD_task_t task) { xbt_assert0(task, "Invalid parameter"); /* TODO */ } /* Destroys a task. The user data (if any) should have been destroyed first. */ -void SG_task_destroy(SG_task_t task) { +void SD_task_destroy(SD_task_t task) { if (task->name) xbt_free(task->name); diff --git a/src/simdag/sd_workstation.c b/src/simdag/sd_workstation.c index 0c3ab6ead7..f2c7afee09 100644 --- a/src/simdag/sd_workstation.c +++ b/src/simdag/sd_workstation.c @@ -2,47 +2,51 @@ #include "simdag/simdag.h" #include "xbt/dict.h" #include "xbt/sysdep.h" +#include "surf/surf.h" -/* Creates a workstation and registers it in SG. +/* Creates a workstation and registers it in SD. */ -SG_workstation_t __SG_workstation_create(const char *name, void *surf_workstation, void *data) { - SG_workstation_data_t sgdata = xbt_new0(s_SG_workstation_data_t, 1); /* workstation private data */ - sgdata->surf_workstation = surf_workstation; +SD_workstation_t __SD_workstation_create(void *surf_workstation, void *data) { + CHECK_INIT_DONE(); + + SD_workstation_data_t sd_data = xbt_new0(s_SD_workstation_data_t, 1); /* workstation private data */ + sd_data->surf_workstation = surf_workstation; - SG_workstation_t workstation = xbt_new0(s_SG_workstation_t, 1); - workstation->name = xbt_strdup(name); + SD_workstation_t workstation = xbt_new0(s_SD_workstation_t, 1); workstation->data = data; /* user data */ - workstation->sgdata = sgdata; /* private data */ + workstation->sd_data = sd_data; /* private data */ - xbt_dict_set(sg_global->workstations, name, workstation, free); /* add the workstation to the dictionary */ + const char *name = SD_workstation_get_name(workstation); + xbt_dict_set(sd_global->workstations, name, workstation, free); /* add the workstation to the dictionary */ /* TODO: route */ - return workstation; } /* Returns a workstation given its name, or NULL if there is no such workstation. */ -SG_workstation_t SG_workstation_get_by_name(const char *name) { - xbt_assert0(sg_global != NULL, "SG_init not called yet"); +SD_workstation_t SD_workstation_get_by_name(const char *name) { + CHECK_INIT_DONE(); + xbt_assert0(name != NULL, "Invalid parameter"); - return xbt_dict_get_or_null(sg_global->workstations, name); + return xbt_dict_get_or_null(sd_global->workstations, name); } /* Returns a NULL-terminated array of existing workstations. */ -SG_workstation_t* SG_workstation_get_list(void) { - xbt_assert0(sg_global != NULL, "SG_init not called yet"); - SG_workstation_t* array = xbt_new0(SG_workstation_t, sg_global->workstation_count + 1); +SD_workstation_t* SD_workstation_get_list(void) { + CHECK_INIT_DONE(); + + SD_workstation_t* array = xbt_new0(SD_workstation_t, sd_global->workstation_count + 1); xbt_dict_cursor_t cursor; char *key; void *data; int i=0; - xbt_dict_foreach(sg_global->workstations,cursor,key,data) { - array[i++] = (SG_workstation_t) data; + xbt_dict_foreach(sd_global->workstations,cursor,key,data) { + array[i++] = (SD_workstation_t) data; } array[i] = NULL; @@ -51,54 +55,59 @@ SG_workstation_t* SG_workstation_get_list(void) { /* Returns the number or workstations. */ -int SG_workstation_get_number(void) { - xbt_assert0(sg_global != NULL, "SG_init not called yet"); - return sg_global->workstation_count; +int SD_workstation_get_number(void) { + CHECK_INIT_DONE(); + return sd_global->workstation_count; } /* Sets the data of a workstation. The new data can be NULL. The old data should have been freed first if it was not NULL. */ -void SG_workstation_set_data(SG_workstation_t workstation, void *data) { +void SD_workstation_set_data(SD_workstation_t workstation, void *data) { + CHECK_INIT_DONE(); xbt_assert0(workstation != NULL, "Invalid parameter"); workstation->data = data; } /* Returns the data of a workstation. The user data can be NULL. */ -void* SG_workstation_get_data(SG_workstation_t workstation) { +void* SD_workstation_get_data(SD_workstation_t workstation) { + CHECK_INIT_DONE(); xbt_assert0(workstation != NULL, "Invalid parameter"); return workstation->data; } /* Returns the name of a workstation. */ -const char* SG_workstation_get_name(SG_workstation_t workstation) { +const char* SD_workstation_get_name(SD_workstation_t workstation) { + CHECK_INIT_DONE(); xbt_assert0(workstation != NULL, "Invalid parameter"); - return workstation->name; + return surf_workstation_resource->common_public->get_resource_name(workstation->sd_data->surf_workstation); } -SG_link_t* SG_workstation_route_get_list(SG_workstation_t src, SG_workstation_t dst) { +SD_link_t* SD_workstation_route_get_list(SD_workstation_t src, SD_workstation_t dst) { + CHECK_INIT_DONE(); /* TODO */ return NULL; } -int SG_workstation_route_get_size(SG_workstation_t src, SG_workstation_t dst) { +int SD_workstation_route_get_size(SD_workstation_t src, SD_workstation_t dst) { + CHECK_INIT_DONE(); /* TODO */ return 0; } /* Returns the total power of a workstation. */ -double SG_workstation_get_power(SG_workstation_t workstation) { +double SD_workstation_get_power(SD_workstation_t workstation) { + CHECK_INIT_DONE(); xbt_assert0(workstation != NULL, "Invalid parameter"); - /* TODO */ - return 0; - /* return workstation->power;*/ + return surf_workstation_resource->extension_public->get_speed(workstation->sd_data->surf_workstation, 1.0); } -/* Return the available power of a workstation. +/* Returns the proportion of available power in a workstation (normally a number between 0 and 1). */ -double SG_workstation_get_available_power(SG_workstation_t workstation) { +double SD_workstation_get_available_power(SD_workstation_t workstation) { + CHECK_INIT_DONE(); xbt_assert0(workstation != NULL, "Invalid parameter"); /* TODO */ return 0; @@ -107,15 +116,12 @@ double SG_workstation_get_available_power(SG_workstation_t workstation) { /* Destroys a workstation. The user data (if any) should have been destroyed first. */ -void __SG_workstation_destroy(SG_workstation_t workstation) { +void __SD_workstation_destroy(SD_workstation_t workstation) { + CHECK_INIT_DONE(); xbt_assert0(workstation != NULL, "Invalid parameter"); - if (workstation->sgdata != NULL) { - xbt_free(workstation->sgdata); - } - - if (workstation->name != NULL) { - xbt_free(workstation->name); + if (workstation->sd_data != NULL) { + xbt_free(workstation->sd_data); } /* TODO: route */ -- 2.20.1