X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/fdd8518c8e9ae4e42c5a8f4c465960832d85eeb2..6cf57242a375fb0186c9eefcf46fcff848d54b19:/include/simgrid/msg.h diff --git a/include/simgrid/msg.h b/include/simgrid/msg.h index 97087ae715..49026aca72 100644 --- a/include/simgrid/msg.h +++ b/include/simgrid/msg.h @@ -33,11 +33,21 @@ namespace simgrid { namespace msg { class Comm; +class Task; } } typedef simgrid::msg::Comm sg_msg_Comm; +/** @brief Task datatype. + * + * Since most scheduling algorithms rely on a concept of task that can be either computed locally or + * transferred on another processor, it seems to be the right level of abstraction for our purposes. + * A task may then be defined by a computing amount, a message size and + * some private data. + */ +typedef simgrid::msg::Task* msg_task_t; #else typedef struct msg_Comm sg_msg_Comm; +typedef struct msg_Task* msg_task_t; #endif #ifdef __cplusplus @@ -110,18 +120,18 @@ XBT_PUBLIC int MSG_host_get_pstate(sg_host_t host); XBT_PUBLIC void MSG_host_set_pstate(sg_host_t host, int pstate); /** @brief Start the host if it is off * - * See also #MSG_host_is_on() and #MSG_host_is_off() to test the current state of the host and @ref SURF_plugin_energy + * See also #MSG_host_is_on() to test the current state of the host and @ref SURF_plugin_energy * for more info on DVFS. */ XBT_PUBLIC void MSG_host_on(sg_host_t h); /** @brief Stop the host if it is on * - * See also MSG_host_is_on() and MSG_host_is_off() to test the current state of the host and @ref SURF_plugin_energy + * See also MSG_host_is_on() to test the current state of the host and @ref SURF_plugin_energy * for more info on DVFS. */ XBT_PUBLIC void MSG_host_off(sg_host_t h); XBT_PUBLIC int MSG_host_is_on(sg_host_t h); -XBT_PUBLIC int MSG_host_is_off(sg_host_t h); +XBT_ATTRIB_DEPRECATED_v325("Please use !MSG_host_is_on()") XBT_PUBLIC int MSG_host_is_off(sg_host_t h); XBT_PUBLIC xbt_dict_t MSG_host_get_properties(sg_host_t host); XBT_PUBLIC const char* MSG_host_get_property_value(sg_host_t host, const char* name); XBT_PUBLIC void MSG_host_set_property_value(sg_host_t host, const char* name, const char* value); @@ -236,25 +246,6 @@ typedef sg_msg_Comm* msg_comm_t; /* ******************************** Task ************************************ */ -typedef struct s_simdata_task_t* simdata_task_t; - -typedef struct msg_task { - char* name; /**< @brief task name if any */ - simdata_task_t simdata; /**< @brief simulator data */ - void* data; /**< @brief user data */ - long long int counter; /* task unique identifier for instrumentation */ - char* category; /* task category for instrumentation */ -} s_msg_task_t; - -/** @brief Task datatype. - * - * Since most scheduling algorithms rely on a concept of task that can be either computed locally or - * transferred on another processor, it seems to be the right level of abstraction for our purposes. - * A task may then be defined by a computing amount, a message size and - * some private data. - */ - -typedef struct msg_task* msg_task_t; /** @brief Default value for an uninitialized #msg_task_t. */ #define MSG_TASK_UNINITIALIZED NULL @@ -317,6 +308,7 @@ XBT_PUBLIC double MSG_get_clock(); XBT_PUBLIC unsigned long int MSG_get_sent_msg(); /************************** Process handling *********************************/ +XBT_PUBLIC void MSG_process_userdata_init(); XBT_PUBLIC msg_process_t MSG_process_create(const char* name, xbt_main_func_t code, void* data, msg_host_t host); XBT_PUBLIC msg_process_t MSG_process_create_with_arguments(const char* name, xbt_main_func_t code, void* data, msg_host_t host, int argc, char** argv); @@ -338,7 +330,7 @@ XBT_PUBLIC int MSG_process_get_number(); XBT_PUBLIC void* MSG_process_get_data(msg_process_t process); XBT_PUBLIC msg_error_t MSG_process_set_data(msg_process_t process, void* data); -XBT_PUBLIC void MSG_process_on_exit(int_f_pvoid_pvoid_t fun, void* data); +XBT_PUBLIC void MSG_process_on_exit(int_f_int_pvoid_t fun, void* data); XBT_PUBLIC void MSG_process_ref(msg_process_t process); XBT_PUBLIC void MSG_process_unref(msg_process_t process); @@ -349,7 +341,6 @@ XBT_PUBLIC msg_task_t MSG_parallel_task_create(const char* name, int host_nb, co double* flops_amount, double* bytes_amount, void* data); XBT_PUBLIC void* MSG_task_get_data(msg_task_t task); XBT_PUBLIC void MSG_task_set_data(msg_task_t task, void* data); -XBT_PUBLIC void MSG_task_set_copy_callback(void (*callback)(msg_task_t task, msg_process_t src, msg_process_t dst)); XBT_PUBLIC msg_process_t MSG_task_get_sender(msg_task_t task); XBT_PUBLIC msg_host_t MSG_task_get_source(msg_task_t task); XBT_PUBLIC const char* MSG_task_get_name(msg_task_t task); @@ -371,7 +362,9 @@ XBT_PUBLIC void MSG_task_set_bytes_amount(msg_task_t task, double bytes_amount); XBT_PUBLIC double MSG_task_get_remaining_communication(msg_task_t task); XBT_PUBLIC double MSG_task_get_bytes_amount(msg_task_t task); -XBT_PUBLIC msg_error_t MSG_task_receive_ext(msg_task_t* task, const char* alias, double timeout, msg_host_t host); +XBT_ATTRIB_DEPRECATED_v325("Getting a task from a specific host is no longer supported." + " Use MSG_task_receive_with_timeout instead.") XBT_PUBLIC msg_error_t + MSG_task_receive_ext(msg_task_t* task, const char* alias, double timeout, msg_host_t host); XBT_PUBLIC msg_error_t MSG_task_receive_with_timeout(msg_task_t* task, const char* alias, double timeout); @@ -450,9 +443,8 @@ XBT_PUBLIC int MSG_barrier_wait(msg_bar_t bar); /* ****************************************************************************************** */ /* DO NOT USE this nasty pimple (unless if you're writing a binding) */ -XBT_PUBLIC smx_context_t -XBT_ATTRIB_DEPRECATED_v323("MSG_process_get_smx_ctx is deprecated. Please contact us if you need it.") -MSG_process_get_smx_ctx(msg_process_t process); +XBT_ATTRIB_DEPRECATED_v325("MSG_process_set_copy_callback is deprecated. Please contact us if you need it.") XBT_PUBLIC + void MSG_task_set_copy_callback(void (*callback)(msg_task_t task, msg_process_t src, msg_process_t dst)); #ifdef __cplusplus }