X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/178d9ca3560ec4b1e756970b888b4e36212ce670..a28a695108f7e9ae7dafc83a2d39d17778f5fc98:/src/simdag/sd_workstation.c diff --git a/src/simdag/sd_workstation.c b/src/simdag/sd_workstation.c index 48d24796f1..1f15df9603 100644 --- a/src/simdag/sd_workstation.c +++ b/src/simdag/sd_workstation.c @@ -1,25 +1,39 @@ +/* Copyright (c) 2006-2011. The SimGrid Team. + * All rights reserved. */ + +/* This program is free software; you can redistribute it and/or modify it + * under the terms of the license (GNU LGPL) which comes with this package. */ + #include "private.h" #include "simdag/simdag.h" #include "xbt/dict.h" #include "xbt/sysdep.h" #include "surf/surf.h" +#include "surf/surf_resource.h" + + + +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(sd_workstation, sd, + "Logging specific to SimDag (workstation)"); /* Creates a workstation and registers it in SD. */ -SD_workstation_t __SD_workstation_create(void *surf_workstation, void *data) { - SD_CHECK_INIT_DONE(); - xbt_assert0(surf_workstation != NULL, "surf_workstation is NULL !"); +SD_workstation_t __SD_workstation_create(void *surf_workstation, + void *data) +{ + + SD_workstation_t workstation; + const char *name; - SD_workstation_t workstation = xbt_new(s_SD_workstation_t, 1); + workstation = xbt_new(s_SD_workstation_t, 1); workstation->surf_workstation = surf_workstation; - workstation->data = data; /* user data */ - SD_workstation_set_access_mode(workstation, SD_WORKSTATION_SHARED_ACCESS); /* default mode is shared */ + workstation->data = data; /* user data */ + workstation->access_mode = SD_WORKSTATION_SHARED_ACCESS; /* default mode is shared */ workstation->task_fifo = NULL; - - const char *name = SD_workstation_get_name(workstation); - xbt_dict_set(sd_global->workstations, name, workstation, __SD_workstation_destroy); /* add the workstation to the dictionary */ - sd_global->workstation_count++; + workstation->current_task = NULL; + name = SD_workstation_get_name(workstation); + xbt_lib_set(host_lib,name,SD_HOST_LEVEL,workstation); return workstation; } @@ -31,12 +45,9 @@ SD_workstation_t __SD_workstation_create(void *surf_workstation, void *data) { * \param name workstation name * \return the workstation, or \c NULL if there is no such workstation */ -SD_workstation_t SD_workstation_get_by_name(const char *name) { - SD_CHECK_INIT_DONE(); - - xbt_assert0(name != NULL, "Invalid parameter"); - - return xbt_dict_get_or_null(sd_global->workstations, name); +SD_workstation_t SD_workstation_get_by_name(const char *name) +{ + return xbt_lib_get_or_null(host_lib, name, SD_HOST_LEVEL); } /** @@ -47,21 +58,24 @@ SD_workstation_t SD_workstation_get_by_name(const char *name) { * \return an array of \ref SD_workstation_t containing all workstations * \see SD_workstation_get_number() */ -const SD_workstation_t* SD_workstation_get_list(void) { - SD_CHECK_INIT_DONE(); - xbt_assert0(SD_workstation_get_number() > 0, "There is no workstation!"); +const SD_workstation_t *SD_workstation_get_list(void) +{ - xbt_dict_cursor_t cursor; + xbt_lib_cursor_t cursor; char *key; - void *data; + void **data; int i; - if (sd_global->workstation_list == NULL) { /* this is the first time the function is called */ - sd_global->workstation_list = xbt_new(SD_workstation_t, sd_global->workstation_count); - + xbt_assert(SD_workstation_get_number() > 0, "There is no workstation!"); + + if (sd_global->workstation_list == NULL) { /* this is the first time the function is called */ + sd_global->workstation_list = + xbt_new(SD_workstation_t, xbt_lib_length(host_lib)); + i = 0; - xbt_dict_foreach(sd_global->workstations, cursor, key, data) { - sd_global->workstation_list[i++] = (SD_workstation_t) data; + xbt_lib_foreach(host_lib, cursor, key, data) { + if(data[SD_HOST_LEVEL]) + sd_global->workstation_list[i++] = (SD_workstation_t) data[SD_HOST_LEVEL]; } } return sd_global->workstation_list; @@ -73,9 +87,9 @@ const SD_workstation_t* SD_workstation_get_list(void) { * \return the number of existing workstations * \see SD_workstation_get_list() */ -int SD_workstation_get_number(void) { - SD_CHECK_INIT_DONE(); - return sd_global->workstation_count; +int SD_workstation_get_number(void) +{ + return xbt_lib_length(host_lib); } /** @@ -85,9 +99,8 @@ int SD_workstation_get_number(void) { * \return the user data associated with this workstation (can be \c NULL) * \see SD_workstation_set_data() */ -void* SD_workstation_get_data(SD_workstation_t workstation) { - SD_CHECK_INIT_DONE(); - xbt_assert0(workstation != NULL, "Invalid parameter"); +void *SD_workstation_get_data(SD_workstation_t workstation) +{ return workstation->data; } @@ -101,9 +114,8 @@ void* SD_workstation_get_data(SD_workstation_t workstation) { * \param data the new data you want to associate with this workstation * \see SD_workstation_get_data() */ -void SD_workstation_set_data(SD_workstation_t workstation, void *data) { - SD_CHECK_INIT_DONE(); - xbt_assert0(workstation != NULL, "Invalid parameter"); +void SD_workstation_set_data(SD_workstation_t workstation, void *data) +{ workstation->data = data; } @@ -113,12 +125,39 @@ void SD_workstation_set_data(SD_workstation_t workstation, void *data) { * \param workstation a workstation * \return the name of this workstation (cannot be \c NULL) */ -const char* SD_workstation_get_name(SD_workstation_t workstation) { - SD_CHECK_INIT_DONE(); - xbt_assert0(workstation != NULL, "Invalid parameter"); - return surf_workstation_resource->common_public->get_resource_name(workstation->surf_workstation); +const char *SD_workstation_get_name(SD_workstation_t workstation) +{ + return surf_resource_name(workstation->surf_workstation); +} + +/** + * \brief Returns the value of a given workstation property + * + * \param ws a workstation + * \param name a property name + * \return value of a property (or NULL if property not set) + */ +const char *SD_workstation_get_property_value(SD_workstation_t ws, + const char *name) +{ + return xbt_dict_get_or_null(SD_workstation_get_properties(ws), name); } + +/** + * \brief Returns a #xbt_dict_t consisting of the list of properties assigned to this workstation + * + * \param workstation a workstation + * \return the dictionary containing the properties associated with the workstation + */ +xbt_dict_t SD_workstation_get_properties(SD_workstation_t workstation) +{ + return surf_workstation_model->extension. + workstation.get_properties(workstation->surf_workstation); + +} + + /** * \brief Returns the route between two workstations * @@ -129,27 +168,32 @@ const char* SD_workstation_get_name(SD_workstation_t workstation) { * \return a new array of \ref SD_link_t representating the route between these two workstations * \see SD_route_get_size(), SD_link_t */ -const SD_link_t* SD_route_get_list(SD_workstation_t src, SD_workstation_t dst) { - SD_CHECK_INIT_DONE(); +const SD_link_t *SD_route_get_list(SD_workstation_t src, + SD_workstation_t dst) +{ + void *surf_src; + void *surf_dst; + xbt_dynar_t surf_route; + const char *link_name; + void *surf_link; + unsigned int cpt; if (sd_global->recyclable_route == NULL) { /* first run */ sd_global->recyclable_route = xbt_new(SD_link_t, SD_link_get_number()); } - void *surf_src = src->surf_workstation; - void *surf_dst = dst->surf_workstation; + surf_src = src->surf_workstation; + surf_dst = dst->surf_workstation; + surf_route = + surf_workstation_model->extension.workstation.get_route(surf_src, + surf_dst); - const void **surf_route = surf_workstation_resource->extension_public->get_route(surf_src, surf_dst); - int route_size = surf_workstation_resource->extension_public->get_route_size(surf_src, surf_dst); - - const char *link_name; - int i; - for (i = 0; i < route_size; i++) { - link_name = surf_workstation_resource->extension_public->get_link_name(surf_route[i]); - sd_global->recyclable_route[i] = xbt_dict_get(sd_global->links, link_name); + xbt_dynar_foreach(surf_route, cpt, surf_link) { + link_name = surf_resource_name(surf_link); + sd_global->recyclable_route[cpt] = + xbt_lib_get_or_null(link_lib, link_name, SD_LINK_LEVEL); } - return sd_global->recyclable_route; } @@ -161,10 +205,11 @@ const SD_link_t* SD_route_get_list(SD_workstation_t src, SD_workstation_t dst) { * \return the number of links on the route between these two workstations * \see SD_route_get_list() */ -int SD_route_get_size(SD_workstation_t src, SD_workstation_t dst) { - SD_CHECK_INIT_DONE(); - return surf_workstation_resource->extension_public-> - get_route_size(src->surf_workstation, dst->surf_workstation); +int SD_route_get_size(SD_workstation_t src, SD_workstation_t dst) +{ + return xbt_dynar_length(surf_workstation_model->extension. + workstation.get_route(src->surf_workstation, + dst->surf_workstation)); } /** @@ -174,10 +219,10 @@ int SD_route_get_size(SD_workstation_t src, SD_workstation_t dst) { * \return the total power of this workstation * \see SD_workstation_get_available_power() */ -double SD_workstation_get_power(SD_workstation_t workstation) { - SD_CHECK_INIT_DONE(); - xbt_assert0(workstation != NULL, "Invalid parameter"); - return surf_workstation_resource->extension_public->get_speed(workstation->surf_workstation, 1.0); +double SD_workstation_get_power(SD_workstation_t workstation) +{ + return surf_workstation_model->extension.workstation. + get_speed(workstation->surf_workstation, 1.0); } /** @@ -187,10 +232,10 @@ double SD_workstation_get_power(SD_workstation_t workstation) { * \return the proportion of power currently available in this workstation (normally a number between 0 and 1) * \see SD_workstation_get_power() */ -double SD_workstation_get_available_power(SD_workstation_t workstation) { - SD_CHECK_INIT_DONE(); - xbt_assert0(workstation != NULL, "Invalid parameter"); - return surf_workstation_resource->extension_public->get_available_speed(workstation->surf_workstation); +double SD_workstation_get_available_power(SD_workstation_t workstation) +{ + return surf_workstation_model->extension. + workstation.get_available_speed(workstation->surf_workstation); } /** @@ -200,10 +245,11 @@ double SD_workstation_get_available_power(SD_workstation_t workstation) { * \param computation_amount the computation amount you want to evaluate (in flops) * \return an approximative astimated computation time for the given computation amount on this workstation (in seconds) */ -double SD_workstation_get_computation_time(SD_workstation_t workstation, double computation_amount) { - SD_CHECK_INIT_DONE(); - xbt_assert0(workstation != NULL, "Invalid parameter"); - xbt_assert0(computation_amount >= 0, "computation_amount must be greater than or equal to zero"); +double SD_workstation_get_computation_time(SD_workstation_t workstation, + double computation_amount) +{ + xbt_assert(computation_amount >= 0, + "computation_amount must be greater than or equal to zero"); return computation_amount / SD_workstation_get_power(workstation); } @@ -216,14 +262,19 @@ double SD_workstation_get_computation_time(SD_workstation_t workstation, double * \return the latency of the route between the two workstations (in seconds) * \see SD_route_get_current_bandwidth() */ -double SD_route_get_current_latency(SD_workstation_t src, SD_workstation_t dst) { - SD_CHECK_INIT_DONE(); - xbt_assert0(src != NULL && dst != NULL, "Invalid parameter"); - const SD_link_t *links = SD_route_get_list(src, dst); - int nb_links = SD_route_get_size(src, dst); - double latency = 0.0; +double SD_route_get_current_latency(SD_workstation_t src, + SD_workstation_t dst) +{ + + const SD_link_t *links; + int nb_links; + double latency; int i; - + + links = SD_route_get_list(src, dst); + nb_links = SD_route_get_size(src, dst); + latency = 0.0; + for (i = 0; i < nb_links; i++) { latency += SD_link_get_current_latency(links[i]); } @@ -240,14 +291,21 @@ double SD_route_get_current_latency(SD_workstation_t src, SD_workstation_t dst) * \return the bandwidth of the route between the two workstations (in bytes/second) * \see SD_route_get_current_latency() */ -double SD_route_get_current_bandwidth(SD_workstation_t src, SD_workstation_t dst) { - SD_CHECK_INIT_DONE(); - xbt_assert0(src != NULL && dst != NULL, "Invalid parameter"); - const SD_link_t *links = SD_route_get_list(src, dst); - int nb_links = SD_route_get_size(src, dst); - double bandwidth, min_bandwidth = -1.0; +double SD_route_get_current_bandwidth(SD_workstation_t src, + SD_workstation_t dst) +{ + + const SD_link_t *links; + int nb_links; + double bandwidth; + double min_bandwidth; int i; - + + links = SD_route_get_list(src, dst); + nb_links = SD_route_get_size(src, dst); + bandwidth = min_bandwidth = -1.0; + + for (i = 0; i < nb_links; i++) { bandwidth = SD_link_get_current_bandwidth(links[i]); if (bandwidth < min_bandwidth || min_bandwidth == -1.0) @@ -267,20 +325,26 @@ double SD_route_get_current_bandwidth(SD_workstation_t src, SD_workstation_t dst * \return an approximative astimated computation time for the given communication amount * between the workstations (in seconds) */ -double SD_route_get_communication_time(SD_workstation_t src, SD_workstation_t dst, - double communication_amount) { +double SD_route_get_communication_time(SD_workstation_t src, + SD_workstation_t dst, + double communication_amount) +{ + + /* total time = latency + transmission time of the slowest link transmission time of a link = communication amount / link bandwidth */ - SD_CHECK_INIT_DONE(); - xbt_assert0(src != NULL && dst != NULL, "Invalid parameter"); - xbt_assert0(communication_amount >= 0, "communication_amount must be greater than or equal to zero"); const SD_link_t *links; int nb_links; double bandwidth, min_bandwidth; double latency; int i; - + + xbt_assert(communication_amount >= 0, + "communication_amount must be greater than or equal to zero"); + + + if (communication_amount == 0.0) return 0.0; @@ -308,16 +372,16 @@ double SD_route_get_communication_time(SD_workstation_t src, SD_workstation_t ds * * \see SD_workstation_set_access_mode(), e_SD_workstation_access_mode_t */ - e_SD_workstation_access_mode_t SD_workstation_get_access_mode(SD_workstation_t workstation) { - SD_CHECK_INIT_DONE(); - xbt_assert0(workstation != NULL, "Invalid parameter"); +e_SD_workstation_access_mode_t +SD_workstation_get_access_mode(SD_workstation_t workstation) +{ return workstation->access_mode; } /** * \brief Sets the access mode for the tasks that will be executed on a workstation * - * By default, a workstation resource is shared, i.e. several tasks + * By default, a workstation model is shared, i.e. several tasks * can be executed at the same time on a workstation. The CPU power of * the workstation is shared between the running tasks on the workstation. * In sequential mode, only one task can use the workstation, and the other @@ -329,12 +393,12 @@ double SD_route_get_communication_time(SD_workstation_t src, SD_workstation_t ds * * \see SD_workstation_get_access_mode(), e_SD_workstation_access_mode_t */ -void SD_workstation_set_access_mode(SD_workstation_t workstation, e_SD_workstation_access_mode_t access_mode) { - SD_CHECK_INIT_DONE(); - xbt_assert0(workstation != NULL, "Invalid parameter"); - +void SD_workstation_set_access_mode(SD_workstation_t workstation, + e_SD_workstation_access_mode_t + access_mode) +{ if (access_mode == workstation->access_mode) { - return; // nothing is changed + return; // nothing is changed } workstation->access_mode = access_mode; @@ -342,45 +406,69 @@ void SD_workstation_set_access_mode(SD_workstation_t workstation, e_SD_workstati if (access_mode == SD_WORKSTATION_SHARED_ACCESS) { xbt_fifo_free(workstation->task_fifo); workstation->task_fifo = NULL; - } - else { + } else { workstation->task_fifo = xbt_fifo_new(); } } /* Returns whether a task can start now on a workstation. - *//* -int __SD_workstation_can_start(SD_workstation_t workstation, SD_task_t task) { - SD_CHECK_INIT_DONE(); - xbt_assert0(workstation != NULL && task != NULL, "Invalid parameter"); + *//* + int __SD_workstation_can_start(SD_workstation_t workstation, SD_task_t task) { + SD_CHECK_INIT_DONE(); + xbt_assert(workstation != NULL && task != NULL, "Invalid parameter"); - return !__SD_workstation_is_busy(workstation) && - (xbt_fifo_size(workstation->task_fifo) == 0) || xbt_fifo_get_first_item(workstation->task_fifo) == task); -} -*/ + return !__SD_workstation_is_busy(workstation) && + (xbt_fifo_size(workstation->task_fifo) == 0) || xbt_fifo_get_first_item(workstation->task_fifo) == task); + } + */ /* Returns whether a workstation is busy. A workstation is busy is it is * in sequential mode and a task is running on it or the fifo is not empty. */ -int __SD_workstation_is_busy(SD_workstation_t workstation) { - SD_CHECK_INIT_DONE(); - xbt_assert0(workstation != NULL, "Invalid parameter"); - +int __SD_workstation_is_busy(SD_workstation_t workstation) +{ + XBT_DEBUG + ("Workstation '%s' access mode: '%s', current task: %s, fifo size: %d", + SD_workstation_get_name(workstation), + (workstation->access_mode == + SD_WORKSTATION_SHARED_ACCESS) ? "SHARED" : "FIFO", + (workstation->current_task ? + SD_task_get_name(workstation->current_task) + : "none"), + (workstation->task_fifo ? xbt_fifo_size(workstation->task_fifo) : + 0)); + return workstation->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS && - (workstation->current_task != NULL || xbt_fifo_size(workstation->task_fifo) > 0); + (workstation->current_task != NULL + || xbt_fifo_size(workstation->task_fifo) > 0); } /* Destroys a workstation. */ -void __SD_workstation_destroy(void *workstation) { - SD_CHECK_INIT_DONE(); - xbt_assert0(workstation != NULL, "Invalid parameter"); +void __SD_workstation_destroy(void *workstation) +{ + + SD_workstation_t w; + /* workstation->surf_workstation is freed by surf_exit and workstation->data is freed by the user */ - SD_workstation_t w = (SD_workstation_t) workstation; + w = (SD_workstation_t) workstation; if (w->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS) { xbt_fifo_free(w->task_fifo); } xbt_free(w); } + +/** + * \brief Returns the kind of the task currently running on a workstation + * Only call this with sequential access mode set + * \param workstation a workstation */ +SD_task_t SD_workstation_get_current_task(SD_workstation_t workstation) +{ + xbt_assert(workstation->access_mode == SD_WORKSTATION_SEQUENTIAL_ACCESS, + "Access mode must be set to SD_WORKSTATION_SEQUENTIAL_ACCESS" + " to use this function"); + + return (workstation->current_task); +}