X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/242fde5e8077f8193db4df5f262a9672085c8d8a..75a88b4f25678374e458f4b8875cd72273e8b8fb:/include/simgrid/simdag.h diff --git a/include/simgrid/simdag.h b/include/simgrid/simdag.h index 68d696355a..7d2ac9ec2a 100644 --- a/include/simgrid/simdag.h +++ b/include/simgrid/simdag.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2006-2010, 2012-2014. The SimGrid Team. +/* Copyright (c) 2006-2010, 2012-2016. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it @@ -14,30 +14,6 @@ #include "simgrid/link.h" SG_BEGIN_DECL() -/** @brief Workstation datatype - @ingroup SD_datatypes_management - - A workstation is a place where a task can be executed. - A workstation is represented as a physical - resource with computing capabilities and has a name. - - @see SD_workstation_management */ -typedef xbt_dictelm_t SD_workstation_t; - -/** @brief Workstation access mode - @ingroup SD_datatypes_management - - By default, a workstation resource 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 - tasks wait in a FIFO. - - @see SD_workstation_get_access_mode(), SD_workstation_set_access_mode() */ -typedef enum { - SD_WORKSTATION_SHARED_ACCESS, /**< @brief Several tasks can be executed at the same time */ - SD_WORKSTATION_SEQUENTIAL_ACCESS /**< @brief Only one task can be executed, the others wait in a FIFO. */ -} e_SD_workstation_access_mode_t; /** @brief Link datatype @ingroup SD_datatypes_management @@ -67,14 +43,13 @@ typedef struct SD_task *SD_task_t; @see SD_task_management */ typedef enum { SD_NOT_SCHEDULED = 0, /**< @brief Initial state (not valid for SD_watch and SD_unwatch). */ - SD_SCHEDULABLE = 0x0001, /**< @brief A task becomes SD_SCHEDULABLE as soon as its dependencies are satisfied */ + SD_SCHEDULABLE = 0x0001, /**< @brief A task becomes SD_SCHEDULABLE as soon as its dependencies are satisfied */ SD_SCHEDULED = 0x0002, /**< @brief A task becomes SD_SCHEDULED when you call function SD_task_schedule. SD_simulate will execute it when it becomes SD_RUNNABLE. */ SD_RUNNABLE = 0x0004, /**< @brief A scheduled task becomes runnable is SD_simulate as soon as its dependencies are satisfied. */ - SD_IN_FIFO = 0x0008, /**< @brief A runnable task can have to wait in a workstation fifo if the workstation is sequential */ - SD_RUNNING = 0x0010, /**< @brief An SD_RUNNABLE or SD_IN_FIFO becomes SD_RUNNING when it is launched. */ - SD_DONE = 0x0020, /**< @brief The task is successfully finished. */ - SD_FAILED = 0x0040 /**< @brief A problem occurred during the execution of the task. */ + SD_RUNNING = 0x0008, /**< @brief An SD_RUNNABLE task becomes SD_RUNNING when it is launched. */ + SD_DONE = 0x0010, /**< @brief The task is successfully finished. */ + SD_FAILED = 0x0020 /**< @brief A problem occurred during the execution of the task. */ } e_SD_task_state_t; /** @brief Task kinds @@ -98,125 +73,32 @@ typedef enum { @see SD_storage_management */ typedef xbt_dictelm_t SD_storage_t; -/************************** AS handling *************************************/ -XBT_PUBLIC(xbt_dict_t) SD_as_router_get_properties(const char *as); -XBT_PUBLIC(const char*) SD_as_router_get_property_value(const char * as, - const char *name); - -/************************** Link handling ***********************************/ -/** @defgroup SD_link_management Links - * @brief Functions for managing the network links - * - * This section describes the functions for managing the network links. - * - * A link is a network node represented as a name, a current - * bandwidth and a current latency. The links are created - * when you call the function SD_create_environment. - * - * @see SD_link_t - * @{ - */ -XBT_PUBLIC(const SD_link_t *) SD_link_get_list(void); -/** @brief Returns the number of links in the whole platform */ -static inline int SD_link_get_number(void) { - return sg_link_amount(); -} - -/** @brief Returns the user data of a link */ -static inline void *SD_link_get_data(SD_link_t link) { - return sg_link_data(link); -} - -/** @brief Sets the user data of a link - * - * The new data can be \c NULL. The old data should have been freed first - * if it was not \c NULL. - */ -static inline void SD_link_set_data(SD_link_t link, void *data) { - sg_link_data_set(link, data); -} -/** @brief Returns the name of a link */ -static inline const char *SD_link_get_name(SD_link_t link) { - return sg_link_name(link); -} -/** @brief Returns the current bandwidth of a link (in bytes per second) */ -static inline double SD_link_get_current_bandwidth(SD_link_t link) { - return sg_link_bandwidth(link); -} -/** @brief Returns the current latency of a link (in seconds) */ -static inline double SD_link_get_current_latency(SD_link_t link){ - return sg_link_latency(link); -} -/** @brief Returns the sharing policy of this workstation. - * @return true if the link is shared, and false if it's a fatpipe - */ -static inline int SD_link_is_shared(SD_link_t link) { - return sg_link_is_shared(link); -} -/** @} */ - /************************** Workstation handling ****************************/ -/** @defgroup SD_workstation_management Workstations - * @brief Functions for managing the workstations +/** @defgroup sg_host_management Hosts + * @brief Functions for managing the Hosts * - * This section describes the functions for managing the workstations. + * This section describes the functions for managing the hosts. * - * A workstation is a place where a task can be executed. - * A workstation is represented as a physical - * resource with computing capabilities and has a name. + * A host is a place where a task can be executed. + * A host is represented as a physical resource with computing + * capabilities and has a name. * - * The workstations are created when you call the function SD_create_environment. + * The hosts are created when you call the function SD_create_environment. * - * @see SD_workstation_t + * @see sg_host_t * @{ */ -XBT_PUBLIC(SD_workstation_t) SD_workstation_get_by_name(const char *name); -XBT_PUBLIC(const SD_workstation_t *) SD_workstation_get_list(void); -XBT_PUBLIC(int) SD_workstation_get_number(void); -XBT_PUBLIC(void) SD_workstation_set_data(SD_workstation_t workstation, - void *data); -XBT_PUBLIC(void *) SD_workstation_get_data(SD_workstation_t workstation); -XBT_PUBLIC(const char *) SD_workstation_get_name(SD_workstation_t - workstation); -/*property handling functions*/ -XBT_PUBLIC(xbt_dict_t) SD_workstation_get_properties(SD_workstation_t - workstation); -XBT_PUBLIC(const char *) SD_workstation_get_property_value(SD_workstation_t - workstation, - const char - *name); -XBT_PUBLIC(void) SD_workstation_dump(SD_workstation_t ws); -XBT_PUBLIC(const SD_link_t *) SD_route_get_list(SD_workstation_t src, - SD_workstation_t dst); -XBT_PUBLIC(int) SD_route_get_size(SD_workstation_t src, - SD_workstation_t dst); -XBT_PUBLIC(double) SD_workstation_get_power(SD_workstation_t workstation); -XBT_PUBLIC(double) SD_workstation_get_available_power(SD_workstation_t - workstation); -XBT_PUBLIC(int) SD_workstation_get_cores(SD_workstation_t workstation); -XBT_PUBLIC(e_SD_workstation_access_mode_t) - SD_workstation_get_access_mode(SD_workstation_t workstation); -XBT_PUBLIC(void) SD_workstation_set_access_mode(SD_workstation_t - workstation, - e_SD_workstation_access_mode_t - access_mode); - -XBT_PUBLIC(double) SD_workstation_get_computation_time(SD_workstation_t workstation, - double flops_amount); -XBT_PUBLIC(double) SD_route_get_current_latency(SD_workstation_t src, - SD_workstation_t dst); -XBT_PUBLIC(double) SD_route_get_current_bandwidth(SD_workstation_t src, - SD_workstation_t dst); -XBT_PUBLIC(double) SD_route_get_communication_time(SD_workstation_t src, - SD_workstation_t dst, +XBT_PUBLIC(const SD_link_t *) SD_route_get_list(sg_host_t src, + sg_host_t dst); +XBT_PUBLIC(int) SD_route_get_size(sg_host_t src, sg_host_t dst); + +XBT_PUBLIC(double) SD_route_get_latency(sg_host_t src, sg_host_t dst); +XBT_PUBLIC(double) SD_route_get_bandwidth(sg_host_t src, sg_host_t dst); +XBT_PUBLIC(double) SD_route_get_communication_time(sg_host_t src, + sg_host_t dst, double bytes_amount); -XBT_PUBLIC(SD_task_t) SD_workstation_get_current_task(SD_workstation_t workstation); -XBT_PUBLIC(xbt_dict_t) - SD_workstation_get_mounted_storage_list(SD_workstation_t workstation); -XBT_PUBLIC(xbt_dynar_t) - SD_workstation_get_attached_storage_list(SD_workstation_t workstation); XBT_PUBLIC(const char*) SD_storage_get_host(SD_storage_t storage); /** @} */ @@ -253,13 +135,13 @@ XBT_PUBLIC(double) SD_task_get_alpha(SD_task_t task); XBT_PUBLIC(double) SD_task_get_remaining_amount(SD_task_t task); XBT_PUBLIC(double) SD_task_get_execution_time(SD_task_t task, int workstation_nb, - const SD_workstation_t * + const sg_host_t * workstation_list, const double *flops_amount, - const double *bytes_amount); -XBT_PUBLIC(int) SD_task_get_kind(SD_task_t task); + const double *bytes_amount); +XBT_PUBLIC(e_SD_task_kind_t) SD_task_get_kind(SD_task_t task); XBT_PUBLIC(void) SD_task_schedule(SD_task_t task, int workstation_nb, - const SD_workstation_t * + const sg_host_t * workstation_list, const double *flops_amount, const double *bytes_amount, @@ -270,7 +152,7 @@ XBT_PUBLIC(double) SD_task_get_finish_time(SD_task_t task); XBT_PUBLIC(xbt_dynar_t) SD_task_get_parents(SD_task_t task); XBT_PUBLIC(xbt_dynar_t) SD_task_get_children(SD_task_t task); XBT_PUBLIC(int) SD_task_get_workstation_count(SD_task_t task); -XBT_PUBLIC(SD_workstation_t *) SD_task_get_workstation_list(SD_task_t +XBT_PUBLIC(sg_host_t *) SD_task_get_workstation_list(SD_task_t task); XBT_PUBLIC(void) SD_task_destroy(SD_task_t task); XBT_PUBLIC(void) SD_task_dump(SD_task_t task); @@ -290,7 +172,7 @@ XBT_PUBLIC(SD_task_t) SD_task_create_comm_par_mxn_1d_block(const char *name, XBT_PUBLIC(void) SD_task_distribute_comp_amdahl(SD_task_t task, int ws_count); XBT_PUBLIC(void) SD_task_schedulev(SD_task_t task, int count, - const SD_workstation_t * list); + const sg_host_t * list); XBT_PUBLIC(void) SD_task_schedulel(SD_task_t task, int count, ...); @@ -332,7 +214,7 @@ XBT_PUBLIC(int) SD_task_dependency_exists(SD_task_t src, SD_task_t dst); /** @defgroup SD_simulation Simulation * @brief Functions for creating the environment and launching the simulation * - * This section describes the functions for initialising SimDag, launching + * This section describes the functions for initializing SimDag, launching * the simulation and exiting SimDag. * * @{ @@ -348,11 +230,11 @@ XBT_PUBLIC(xbt_dynar_t) SD_daxload(const char *filename); XBT_PUBLIC(xbt_dynar_t) SD_dotload(const char *filename); XBT_PUBLIC(xbt_dynar_t) SD_PTG_dotload(const char *filename); XBT_PUBLIC(xbt_dynar_t) SD_dotload_with_sched(const char *filename); -XBT_PUBLIC(void) uniq_transfer_task_name(SD_task_t task); /** @} */ +SG_END_DECL() + #include "simgrid/instr.h" -SG_END_DECL() #endif