# undefined via #undef or recursively expanded use the := operator
# instead of the = operator.
-PREDEFINED = XBT_PUBLIC(type)="extern type" \
+PREDEFINED = XBT_PUBLIC= \
XBT_EXPORT_NO_IMPORT(type)=type \
XBT_IMPORT_NO_EXPORT(type)=type \
XBT_PUBLIC_DATA(type)="extern type" \
namespace activity {
class ActivityImpl;
using ActivityImplPtr = boost::intrusive_ptr<ActivityImpl>;
- XBT_PUBLIC(void) intrusive_ptr_add_ref(ActivityImpl* activity);
- XBT_PUBLIC(void) intrusive_ptr_release(ActivityImpl* activity);
+ XBT_PUBLIC void intrusive_ptr_add_ref(ActivityImpl* activity);
+ XBT_PUBLIC void intrusive_ptr_release(ActivityImpl* activity);
class CommImpl;
using CommImplPtr = boost::intrusive_ptr<CommImpl>;
-/* Copyright (c) 2013-2016. The SimGrid Team.
+/* Copyright (c) 2013-2018. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
SG_BEGIN_DECL()
-XBT_PUBLIC(sg_host_t *) sg_host_list();
+XBT_PUBLIC sg_host_t* sg_host_list();
/** \ingroup m_host_management
* \brief Return the current number MSG hosts.
*/
-XBT_PUBLIC(size_t) sg_host_count();
+XBT_PUBLIC size_t sg_host_count();
#define MSG_get_host_number() sg_host_count()
/** \ingroup m_host_management
* \remark The host order in the returned array is generally different from the host creation/declaration order in the
* XML platform (we use a hash table internally)
*/
-XBT_PUBLIC(xbt_dynar_t) sg_hosts_as_dynar();
+XBT_PUBLIC xbt_dynar_t sg_hosts_as_dynar();
#define MSG_hosts_as_dynar() sg_hosts_as_dynar()
-XBT_PUBLIC(size_t) sg_host_extension_create(void(*deleter)(void*));
-XBT_PUBLIC(void*) sg_host_extension_get(sg_host_t host, size_t rank);
+XBT_PUBLIC size_t sg_host_extension_create(void (*deleter)(void*));
+XBT_PUBLIC void* sg_host_extension_get(sg_host_t host, size_t rank);
/** \ingroup m_host_management
* \brief Finds a msg_host_t using its name.
* \param name the name of an host.
* \return the corresponding host
*/
-XBT_PUBLIC(sg_host_t) sg_host_by_name(const char *name);
+XBT_PUBLIC sg_host_t sg_host_by_name(const char* name);
#define MSG_host_by_name(name) sg_host_by_name(name)
#define MSG_get_host_by_name(n) sg_host_by_name(n) /* Rewrite the old name into the new one transparently */
/** \ingroup m_host_management
*
* \brief Return the name of the #msg_host_t. */
-XBT_PUBLIC(const char*) sg_host_get_name(sg_host_t host);
+XBT_PUBLIC const char* sg_host_get_name(sg_host_t host);
#define MSG_host_get_name(host) sg_host_get_name(host)
// ========== User Data ==============
*
* This functions returns the user data associated to \a host if it is possible.
*/
-XBT_PUBLIC(void*) sg_host_user(sg_host_t host);
+XBT_PUBLIC void* sg_host_user(sg_host_t host);
#define MSG_host_get_data(host) sg_host_user(host)
/** \ingroup m_host_management
*
*
* This functions attach \a data to \a host if it is possible.
*/
-XBT_PUBLIC(void) sg_host_user_set(sg_host_t host, void* userdata);
+XBT_PUBLIC void sg_host_user_set(sg_host_t host, void* userdata);
#define MSG_host_set_data(host, data) sg_host_user_set(host, data)
-XBT_PUBLIC(void) sg_host_user_destroy(sg_host_t host);
+XBT_PUBLIC void sg_host_user_destroy(sg_host_t host);
// ========= storage related functions ============
/** \ingroup m_host_management
* \param host a host
* \return a dict containing all mount point on the host (mount_name => msg_storage_t)
*/
-XBT_PUBLIC(xbt_dict_t) sg_host_get_mounted_storage_list(sg_host_t host);
+XBT_PUBLIC xbt_dict_t sg_host_get_mounted_storage_list(sg_host_t host);
#define MSG_host_get_mounted_storage_list(host) sg_host_get_mounted_storage_list(host)
/** \ingroup m_host_management
* \param host a host
* \return a dynar containing all storages (name) attached to the host
*/
-XBT_PUBLIC(xbt_dynar_t) sg_host_get_attached_storage_list(sg_host_t host);
+XBT_PUBLIC xbt_dynar_t sg_host_get_attached_storage_list(sg_host_t host);
#define MSG_host_get_attached_storage_list(host) host_get_attached_storage_list(host)
// =========== user-level functions ===============
/** \ingroup m_host_management
* \brief Return the speed of the processor (in flop/s), regardless of the current load on the machine.
*/
-XBT_PUBLIC(double) sg_host_speed(sg_host_t host);
+XBT_PUBLIC double sg_host_speed(sg_host_t host);
#define MSG_host_get_speed(host) sg_host_speed(host)
-XBT_PUBLIC(double) sg_host_get_available_speed(sg_host_t host);
+XBT_PUBLIC double sg_host_get_available_speed(sg_host_t host);
-XBT_PUBLIC(int) sg_host_core_count(sg_host_t host);
+XBT_PUBLIC int sg_host_core_count(sg_host_t host);
#define MSG_host_get_core_number(host) sg_host_core_count(host)
/** \ingroup m_process_management
* \param process a process (nullptr means the current one)
* \return the msg_host_t corresponding to the location on which \a process is running.
*/
-XBT_PUBLIC(sg_host_t) sg_host_self();
+XBT_PUBLIC sg_host_t sg_host_self();
#define MSG_host_self() sg_host_self()
-XBT_PUBLIC(const char*) sg_host_self_get_name();
+XBT_PUBLIC const char* sg_host_self_get_name();
/** \ingroup m_host_management
* \brief Return the total count of pstates defined for a host. See also @ref plugin_energy.
*
* \param host host to test
*/
-XBT_PUBLIC(int) sg_host_get_nb_pstates(sg_host_t host);
+XBT_PUBLIC int sg_host_get_nb_pstates(sg_host_t host);
#define MSG_host_get_nb_pstates(host) sg_host_get_nb_pstates(host)
-XBT_PUBLIC(int) sg_host_get_pstate(sg_host_t host);
+XBT_PUBLIC int sg_host_get_pstate(sg_host_t host);
#define MSG_host_get_pstate(h) sg_host_get_pstate(h) /* users don't know that MSG is the C version of SimGrid */
-XBT_PUBLIC(void) sg_host_set_pstate(sg_host_t host,int pstate);
+XBT_PUBLIC void sg_host_set_pstate(sg_host_t host, int pstate);
#define MSG_host_set_pstate(h, pstate) sg_host_set_pstate(h, pstate) /* (same here) */
-XBT_PUBLIC(void) sg_host_turn_on(sg_host_t host);
+XBT_PUBLIC void sg_host_turn_on(sg_host_t host);
#define MSG_host_on(h) sg_host_turn_on(h)
-XBT_PUBLIC(void) sg_host_turn_off(sg_host_t host);
+XBT_PUBLIC void sg_host_turn_off(sg_host_t host);
#define MSG_host_off(h) sg_host_turn_off(h)
-XBT_PUBLIC(int) sg_host_is_on(sg_host_t host);
+XBT_PUBLIC int sg_host_is_on(sg_host_t host);
#define MSG_host_is_on(h) sg_host_is_on(h)
-XBT_PUBLIC(int) sg_host_is_off(sg_host_t host);
+XBT_PUBLIC int sg_host_is_off(sg_host_t host);
#define MSG_host_is_off(h) sg_host_is_off(h)
/** \ingroup m_host_management
* \param host a host
* \return a dict containing the properties
*/
-XBT_PUBLIC(xbt_dict_t) sg_host_get_properties(sg_host_t host);
+XBT_PUBLIC xbt_dict_t sg_host_get_properties(sg_host_t host);
#define MSG_host_get_properties(host) sg_host_get_properties(host)
/** \ingroup m_host_management
* \param name a property name
* \return value of a property (or nullptr if property not set)
*/
-XBT_PUBLIC(const char*) sg_host_get_property_value(sg_host_t host, const char* name);
+XBT_PUBLIC const char* sg_host_get_property_value(sg_host_t host, const char* name);
#define MSG_host_get_property_value(host, name) sg_host_get_property_value(host, name)
/** \ingroup m_host_management
* \param name a property name
* \param value what to change the property to
*/
-XBT_PUBLIC(void) sg_host_set_property_value(sg_host_t host, const char* name, const char* value);
+XBT_PUBLIC void sg_host_set_property_value(sg_host_t host, const char* name, const char* value);
#define MSG_host_set_property_value(host, name, value) sg_host_set_property_value(host, name, value)
-XBT_PUBLIC(void) sg_host_route(sg_host_t from, sg_host_t to, xbt_dynar_t links);
-XBT_PUBLIC(double) sg_host_route_latency(sg_host_t from, sg_host_t to);
-XBT_PUBLIC(double) sg_host_route_bandwidth(sg_host_t from, sg_host_t to);
-XBT_PUBLIC(void) sg_host_dump(sg_host_t ws);
+XBT_PUBLIC void sg_host_route(sg_host_t from, sg_host_t to, xbt_dynar_t links);
+XBT_PUBLIC double sg_host_route_latency(sg_host_t from, sg_host_t to);
+XBT_PUBLIC double sg_host_route_bandwidth(sg_host_t from, sg_host_t to);
+XBT_PUBLIC void sg_host_dump(sg_host_t ws);
SG_END_DECL()
#endif /* SIMGRID_HOST_H_ */
-/* Copyright (c) 2010-2015. The SimGrid Team.
+/* Copyright (c) 2010-2018. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
SG_BEGIN_DECL()
/* Functions to manage tracing categories */
-XBT_PUBLIC(void) TRACE_category(const char *category);
-XBT_PUBLIC(void) TRACE_category_with_color (const char *category, const char *color);
-XBT_PUBLIC(xbt_dynar_t) TRACE_get_categories ();
-XBT_PUBLIC(void) TRACE_smpi_set_category(const char *category);
+XBT_PUBLIC void TRACE_category(const char* category);
+XBT_PUBLIC void TRACE_category_with_color(const char* category, const char* color);
+XBT_PUBLIC xbt_dynar_t TRACE_get_categories();
+XBT_PUBLIC void TRACE_smpi_set_category(const char* category);
/* Functions to manage tracing marks (used for trace comparison experiments) */
-XBT_PUBLIC(void) TRACE_declare_mark(const char *mark_type);
-XBT_PUBLIC(void) TRACE_declare_mark_value_with_color (const char *mark_type, const char *mark_value, const char *mark_color);
-XBT_PUBLIC(void) TRACE_declare_mark_value (const char *mark_type, const char *mark_value);
-XBT_PUBLIC(void) TRACE_mark(const char *mark_type, const char *mark_value);
-XBT_PUBLIC(xbt_dynar_t) TRACE_get_marks ();
+XBT_PUBLIC void TRACE_declare_mark(const char* mark_type);
+XBT_PUBLIC void TRACE_declare_mark_value_with_color(const char* mark_type, const char* mark_value,
+ const char* mark_color);
+XBT_PUBLIC void TRACE_declare_mark_value(const char* mark_type, const char* mark_value);
+XBT_PUBLIC void TRACE_mark(const char* mark_type, const char* mark_value);
+XBT_PUBLIC xbt_dynar_t TRACE_get_marks();
/* Function used by graphicator (transform a SimGrid platform file in a graphviz dot file with the network topology) */
-XBT_PUBLIC(int) TRACE_platform_graph_export_graphviz (const char *filename);
+XBT_PUBLIC int TRACE_platform_graph_export_graphviz(const char* filename);
/* User-variables related functions*/
/* for VM variables */
-XBT_PUBLIC(void) TRACE_vm_variable_declare (const char *variable);
-XBT_PUBLIC(void) TRACE_vm_variable_declare_with_color (const char *variable, const char *color);
-XBT_PUBLIC(void) TRACE_vm_variable_set (const char *vm, const char *variable, double value);
-XBT_PUBLIC(void) TRACE_vm_variable_add (const char *vm, const char *variable, double value);
-XBT_PUBLIC(void) TRACE_vm_variable_sub (const char *vm, const char *variable, double value);
-XBT_PUBLIC(void) TRACE_vm_variable_set_with_time (double time, const char *vm, const char *variable, double value);
-XBT_PUBLIC(void) TRACE_vm_variable_add_with_time (double time, const char *vm, const char *variable, double value);
-XBT_PUBLIC(void) TRACE_vm_variable_sub_with_time (double time, const char *vm, const char *variable, double value);
+XBT_PUBLIC void TRACE_vm_variable_declare(const char* variable);
+XBT_PUBLIC void TRACE_vm_variable_declare_with_color(const char* variable, const char* color);
+XBT_PUBLIC void TRACE_vm_variable_set(const char* vm, const char* variable, double value);
+XBT_PUBLIC void TRACE_vm_variable_add(const char* vm, const char* variable, double value);
+XBT_PUBLIC void TRACE_vm_variable_sub(const char* vm, const char* variable, double value);
+XBT_PUBLIC void TRACE_vm_variable_set_with_time(double time, const char* vm, const char* variable, double value);
+XBT_PUBLIC void TRACE_vm_variable_add_with_time(double time, const char* vm, const char* variable, double value);
+XBT_PUBLIC void TRACE_vm_variable_sub_with_time(double time, const char* vm, const char* variable, double value);
/* for host variables */
-XBT_PUBLIC(void) TRACE_host_variable_declare (const char *variable);
-XBT_PUBLIC(void) TRACE_host_variable_declare_with_color (const char *variable, const char *color);
-XBT_PUBLIC(void) TRACE_host_variable_set (const char *host, const char *variable, double value);
-XBT_PUBLIC(void) TRACE_host_variable_add (const char *host, const char *variable, double value);
-XBT_PUBLIC(void) TRACE_host_variable_sub (const char *host, const char *variable, double value);
-XBT_PUBLIC(void) TRACE_host_variable_set_with_time (double time, const char *host, const char *variable, double value);
-XBT_PUBLIC(void) TRACE_host_variable_add_with_time (double time, const char *host, const char *variable, double value);
-XBT_PUBLIC(void) TRACE_host_variable_sub_with_time (double time, const char *host, const char *variable, double value);
-XBT_PUBLIC(xbt_dynar_t) TRACE_get_host_variables ();
+XBT_PUBLIC void TRACE_host_variable_declare(const char* variable);
+XBT_PUBLIC void TRACE_host_variable_declare_with_color(const char* variable, const char* color);
+XBT_PUBLIC void TRACE_host_variable_set(const char* host, const char* variable, double value);
+XBT_PUBLIC void TRACE_host_variable_add(const char* host, const char* variable, double value);
+XBT_PUBLIC void TRACE_host_variable_sub(const char* host, const char* variable, double value);
+XBT_PUBLIC void TRACE_host_variable_set_with_time(double time, const char* host, const char* variable, double value);
+XBT_PUBLIC void TRACE_host_variable_add_with_time(double time, const char* host, const char* variable, double value);
+XBT_PUBLIC void TRACE_host_variable_sub_with_time(double time, const char* host, const char* variable, double value);
+XBT_PUBLIC xbt_dynar_t TRACE_get_host_variables();
/* for link variables */
-XBT_PUBLIC(void) TRACE_link_variable_declare (const char *var);
-XBT_PUBLIC(void) TRACE_link_variable_declare_with_color (const char *var, const char *color);
-XBT_PUBLIC(void) TRACE_link_variable_set (const char *link, const char *variable, double value);
-XBT_PUBLIC(void) TRACE_link_variable_add (const char *link, const char *variable, double value);
-XBT_PUBLIC(void) TRACE_link_variable_sub (const char *link, const char *variable, double value);
-XBT_PUBLIC(void) TRACE_link_variable_set_with_time (double time, const char *link, const char *variable, double value);
-XBT_PUBLIC(void) TRACE_link_variable_add_with_time (double time, const char *link, const char *variable, double value);
-XBT_PUBLIC(void) TRACE_link_variable_sub_with_time (double time, const char *link, const char *variable, double value);
+XBT_PUBLIC void TRACE_link_variable_declare(const char* var);
+XBT_PUBLIC void TRACE_link_variable_declare_with_color(const char* var, const char* color);
+XBT_PUBLIC void TRACE_link_variable_set(const char* link, const char* variable, double value);
+XBT_PUBLIC void TRACE_link_variable_add(const char* link, const char* variable, double value);
+XBT_PUBLIC void TRACE_link_variable_sub(const char* link, const char* variable, double value);
+XBT_PUBLIC void TRACE_link_variable_set_with_time(double time, const char* link, const char* variable, double value);
+XBT_PUBLIC void TRACE_link_variable_add_with_time(double time, const char* link, const char* variable, double value);
+XBT_PUBLIC void TRACE_link_variable_sub_with_time(double time, const char* link, const char* variable, double value);
/* for link variables, but with src and dst used for get_route */
-XBT_PUBLIC(void) TRACE_link_srcdst_variable_set (const char *src, const char *dst, const char *variable, double value);
-XBT_PUBLIC(void) TRACE_link_srcdst_variable_add (const char *src, const char *dst, const char *variable, double value);
-XBT_PUBLIC(void) TRACE_link_srcdst_variable_sub (const char *src, const char *dst, const char *variable, double value);
-XBT_PUBLIC(void) TRACE_link_srcdst_variable_set_with_time (double time, const char *src, const char *dst, const char *variable, double value);
-XBT_PUBLIC(void) TRACE_link_srcdst_variable_add_with_time (double time, const char *src, const char *dst, const char *variable, double value);
-XBT_PUBLIC(void) TRACE_link_srcdst_variable_sub_with_time (double time, const char *src, const char *dst, const char *variable, double value);
-XBT_PUBLIC(xbt_dynar_t) TRACE_get_link_variables ();
-XBT_PUBLIC(void) TRACE_host_state_declare (const char *state);
-XBT_PUBLIC(void) TRACE_host_state_declare_value (const char *state, const char *value, const char *color);
-XBT_PUBLIC(void) TRACE_host_set_state (const char *host, const char *state, const char *value);
-XBT_PUBLIC(void) TRACE_host_push_state (const char *host, const char *state, const char *value);
-XBT_PUBLIC(void) TRACE_host_pop_state (const char *host, const char *state);
+XBT_PUBLIC void TRACE_link_srcdst_variable_set(const char* src, const char* dst, const char* variable, double value);
+XBT_PUBLIC void TRACE_link_srcdst_variable_add(const char* src, const char* dst, const char* variable, double value);
+XBT_PUBLIC void TRACE_link_srcdst_variable_sub(const char* src, const char* dst, const char* variable, double value);
+XBT_PUBLIC void TRACE_link_srcdst_variable_set_with_time(double time, const char* src, const char* dst,
+ const char* variable, double value);
+XBT_PUBLIC void TRACE_link_srcdst_variable_add_with_time(double time, const char* src, const char* dst,
+ const char* variable, double value);
+XBT_PUBLIC void TRACE_link_srcdst_variable_sub_with_time(double time, const char* src, const char* dst,
+ const char* variable, double value);
+XBT_PUBLIC xbt_dynar_t TRACE_get_link_variables();
+XBT_PUBLIC void TRACE_host_state_declare(const char* state);
+XBT_PUBLIC void TRACE_host_state_declare_value(const char* state, const char* value, const char* color);
+XBT_PUBLIC void TRACE_host_set_state(const char* host, const char* state, const char* value);
+XBT_PUBLIC void TRACE_host_push_state(const char* host, const char* state, const char* value);
+XBT_PUBLIC void TRACE_host_pop_state(const char* host, const char* state);
/* for creating graph configuration files for Viva by hand */
-XBT_PUBLIC(xbt_dynar_t) TRACE_get_node_types ();
-XBT_PUBLIC(xbt_dynar_t) TRACE_get_edge_types ();
+XBT_PUBLIC xbt_dynar_t TRACE_get_node_types();
+XBT_PUBLIC xbt_dynar_t TRACE_get_edge_types();
SG_END_DECL()
-/* Copyright (c) 2010-2011, 2013-2015. The SimGrid Team.
+/* Copyright (c) 2010-2011, 2013-2018. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
#if SIMGRID_HAVE_JEDULE
SG_BEGIN_DECL()
-XBT_PUBLIC(void) jedule_log_sd_event(SD_task_t task);
-XBT_PUBLIC(void) jedule_sd_init(void);
-XBT_PUBLIC(void) jedule_sd_exit(void);
-XBT_PUBLIC(void) jedule_sd_dump(const char* filename);
+XBT_PUBLIC void jedule_log_sd_event(SD_task_t task);
+XBT_PUBLIC void jedule_sd_init(void);
+XBT_PUBLIC void jedule_sd_exit(void);
+XBT_PUBLIC void jedule_sd_dump(const char* filename);
SG_END_DECL()
#endif /* JEDULE_SD_BINDING_H_ */
-/* Copyright (c) 2016-2017. The SimGrid Team.
+/* Copyright (c) 2016-2018. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
FutureStateBase(FutureStateBase const&) = delete;
FutureStateBase& operator=(FutureStateBase const&) = delete;
- XBT_PUBLIC(void) schedule(simgrid::xbt::Task<void()>&& job);
+ XBT_PUBLIC void schedule(simgrid::xbt::Task<void()>&& job);
void set_exception(std::exception_ptr exception)
{
/* Public interface to the Link datatype */
-/* Copyright (c) 2015. The SimGrid Team.
+/* Copyright (c) 2015-2018. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
/* C interface */
SG_BEGIN_DECL()
-XBT_PUBLIC(const char*) sg_link_name(sg_link_t link);
-XBT_PUBLIC(sg_link_t) sg_link_by_name(const char* name);
-XBT_PUBLIC(int) sg_link_is_shared(sg_link_t link);
-XBT_PUBLIC(double) sg_link_bandwidth(sg_link_t link);
-XBT_PUBLIC(double) sg_link_latency(sg_link_t link);
-XBT_PUBLIC(void*) sg_link_data(sg_link_t link);
-XBT_PUBLIC(void) sg_link_data_set(sg_link_t link, void* data);
-XBT_PUBLIC(int) sg_link_count();
-XBT_PUBLIC(sg_link_t*) sg_link_list();
-XBT_PUBLIC(void) sg_link_exit();
+XBT_PUBLIC const char* sg_link_name(sg_link_t link);
+XBT_PUBLIC sg_link_t sg_link_by_name(const char* name);
+XBT_PUBLIC int sg_link_is_shared(sg_link_t link);
+XBT_PUBLIC double sg_link_bandwidth(sg_link_t link);
+XBT_PUBLIC double sg_link_latency(sg_link_t link);
+XBT_PUBLIC void* sg_link_data(sg_link_t link);
+XBT_PUBLIC void sg_link_data_set(sg_link_t link, void* data);
+XBT_PUBLIC int sg_link_count();
+XBT_PUBLIC sg_link_t* sg_link_list();
+XBT_PUBLIC void sg_link_exit();
SG_END_DECL()
#endif /* INCLUDE_SIMGRID_LINK_H_ */
SG_BEGIN_DECL()
-XBT_PUBLIC(int) MC_random(int min, int max);
+XBT_PUBLIC int MC_random(int min, int max);
#if SIMGRID_HAVE_MC
/* Internal variable used to check if we're running under the MC
*
* Please don't use directly: you should use MC_is_active. */
-extern XBT_PUBLIC(int) _sg_do_model_check;
-extern XBT_PUBLIC(int) _sg_mc_max_visited_states;
+extern XBT_PUBLIC int _sg_do_model_check;
+extern XBT_PUBLIC int _sg_mc_max_visited_states;
#define MC_is_active() _sg_do_model_check
#define MC_visited_reduction() _sg_mc_max_visited_states
*
* This function is used to define safety properties to verify.
*/
-XBT_PUBLIC(void) MC_assert(int);
+XBT_PUBLIC void MC_assert(int);
-XBT_PUBLIC(void) MC_automaton_new_propositional_symbol(const char* id, int(*fct)(void));
-XBT_PUBLIC(void) MC_automaton_new_propositional_symbol_pointer(const char *id, int* value);
+XBT_PUBLIC void MC_automaton_new_propositional_symbol(const char* id, int (*fct)(void));
+XBT_PUBLIC void MC_automaton_new_propositional_symbol_pointer(const char* id, int* value);
-XBT_PUBLIC(void) MC_cut(void);
-XBT_PUBLIC(void) MC_ignore(void *addr, size_t size);
+XBT_PUBLIC void MC_cut(void);
+XBT_PUBLIC void MC_ignore(void* addr, size_t size);
-XBT_PUBLIC(void) MC_ignore_heap(void* address, size_t size);
-XBT_PUBLIC(void) MC_unignore_heap(void* address, size_t size);
-XBT_PUBLIC(void) MC_ignore_global_variable(const char* var_name);
+XBT_PUBLIC void MC_ignore_heap(void* address, size_t size);
+XBT_PUBLIC void MC_unignore_heap(void* address, size_t size);
+XBT_PUBLIC void MC_ignore_global_variable(const char* var_name);
#else
/** @} */
/************************** Global ******************************************/
-XBT_PUBLIC(void) MSG_config(const char *key, const char *value);
+XBT_PUBLIC void MSG_config(const char* key, const char* value);
/** \ingroup msg_simulation
* \brief Initialize the MSG internal data.
* \hideinitializer
MSG_init_nocheck(argc,argv); \
} while (0)
-XBT_PUBLIC(void) MSG_init_nocheck(int *argc, char **argv);
-XBT_PUBLIC(msg_error_t) MSG_main();;
-XBT_PUBLIC(void) MSG_function_register(const char *name,
- xbt_main_func_t code);
-XBT_PUBLIC(void) MSG_function_register_default(xbt_main_func_t code);
-XBT_PUBLIC(void) MSG_launch_application(const char *file);
+XBT_PUBLIC void MSG_init_nocheck(int* argc, char** argv);
+XBT_PUBLIC msg_error_t MSG_main();
+XBT_PUBLIC void MSG_function_register(const char* name, xbt_main_func_t code);
+XBT_PUBLIC void MSG_function_register_default(xbt_main_func_t code);
+XBT_PUBLIC void MSG_launch_application(const char* file);
/*Bypass the parser */
-XBT_PUBLIC(void) MSG_set_function(const char *host_id,
- const char *function_name,
- xbt_dynar_t arguments);
+XBT_PUBLIC void MSG_set_function(const char* host_id, const char* function_name, xbt_dynar_t arguments);
-XBT_PUBLIC(double) MSG_get_clock();
-XBT_PUBLIC(unsigned long int) MSG_get_sent_msg();
+XBT_PUBLIC double MSG_get_clock();
+XBT_PUBLIC unsigned long int MSG_get_sent_msg();
/************************** Net Zones ***********************************/
-XBT_PUBLIC(msg_netzone_t) MSG_zone_get_root();
-XBT_PUBLIC(const char*) MSG_zone_get_name(msg_netzone_t zone);
-XBT_PUBLIC(msg_netzone_t) MSG_zone_get_by_name(const char* name);
-XBT_PUBLIC(void) MSG_zone_get_sons(msg_netzone_t zone, xbt_dict_t whereto);
-XBT_PUBLIC(const char*) MSG_zone_get_property_value(msg_netzone_t as, const char* name);
-XBT_PUBLIC(void) MSG_zone_set_property_value(msg_netzone_t netzone, const char* name, char* value);
-XBT_PUBLIC(void) MSG_zone_get_hosts(msg_netzone_t zone, xbt_dynar_t whereto);
+XBT_PUBLIC msg_netzone_t MSG_zone_get_root();
+XBT_PUBLIC const char* MSG_zone_get_name(msg_netzone_t zone);
+XBT_PUBLIC msg_netzone_t MSG_zone_get_by_name(const char* name);
+XBT_PUBLIC void MSG_zone_get_sons(msg_netzone_t zone, xbt_dict_t whereto);
+XBT_PUBLIC const char* MSG_zone_get_property_value(msg_netzone_t as, const char* name);
+XBT_PUBLIC void MSG_zone_set_property_value(msg_netzone_t netzone, const char* name, char* value);
+XBT_PUBLIC void MSG_zone_get_hosts(msg_netzone_t zone, xbt_dynar_t whereto);
/************************** Storage handling ***********************************/
-XBT_PUBLIC(const char*) sg_storage_get_name(sg_storage_t storage);
+XBT_PUBLIC const char* sg_storage_get_name(sg_storage_t storage);
#define MSG_storage_get_name(storage) sg_storage_get_name(storage)
-XBT_PUBLIC(sg_storage_t) sg_storage_get_by_name(const char* name);
+XBT_PUBLIC sg_storage_t sg_storage_get_by_name(const char* name);
#define MSG_storage_get_by_name(name) sg_storage_get_by_name(name)
-XBT_PUBLIC(xbt_dict_t) sg_storage_get_properties(sg_storage_t storage);
+XBT_PUBLIC xbt_dict_t sg_storage_get_properties(sg_storage_t storage);
#define MSG_storage_get_properties(storage) sg_storage_get_properties(storage)
-XBT_PUBLIC(void) sg_storage_set_property_value(sg_storage_t storage, const char* name, char* value);
+XBT_PUBLIC void sg_storage_set_property_value(sg_storage_t storage, const char* name, char* value);
#define MSG_storage_set_property_value(storage, name, value) sg_storage_set_property_value(storage, name, value)
-XBT_PUBLIC(const char*) sg_storage_get_property_value(sg_storage_t storage, const char* name);
+XBT_PUBLIC const char* sg_storage_get_property_value(sg_storage_t storage, const char* name);
#define MSG_storage_get_property_value(storage, name) sg_storage_get_property_value(storage, name)
-XBT_PUBLIC(xbt_dynar_t) sg_storages_as_dynar();
+XBT_PUBLIC xbt_dynar_t sg_storages_as_dynar();
#define MSG_storages_as_dynar() sg_storages_as_dynar()
-XBT_PUBLIC(void) sg_storage_set_data(sg_storage_t host, void* data);
+XBT_PUBLIC void sg_storage_set_data(sg_storage_t host, void* data);
#define MSG_storage_set_data(storage, data) sg_storage_set_data(storage, data)
-XBT_PUBLIC(void*) sg_storage_get_data(sg_storage_t storage);
+XBT_PUBLIC void* sg_storage_get_data(sg_storage_t storage);
#define MSG_storage_get_data(storage) sg_storage_get_data(storage)
-XBT_PUBLIC(const char*) sg_storage_get_host(sg_storage_t storage);
+XBT_PUBLIC const char* sg_storage_get_host(sg_storage_t storage);
#define MSG_storage_get_host(storage) sg_storage_get_host(storage)
-XBT_PUBLIC(sg_size_t) sg_storage_read(sg_storage_t storage, sg_size_t size);
+XBT_PUBLIC sg_size_t sg_storage_read(sg_storage_t storage, sg_size_t size);
#define MSG_storage_read(storage, size) sg_storage_read(storage, size)
-XBT_PUBLIC(sg_size_t) sg_storage_write(sg_storage_t storage, sg_size_t size);
+XBT_PUBLIC sg_size_t sg_storage_write(sg_storage_t storage, sg_size_t size);
#define MSG_storage_write(storage, size) sg_storage_write(storage, size)
/************************** Host handling ***********************************/
-XBT_PUBLIC(void) MSG_host_get_process_list(msg_host_t h, xbt_dynar_t whereto);
+XBT_PUBLIC void MSG_host_get_process_list(msg_host_t h, xbt_dynar_t whereto);
XBT_ATTRIB_DEPRECATED_v320("Use MSG_host_get_speed(): v3.20 will drop MSG_host_get_current_power_peak() "
"completely.") static inline double MSG_host_get_current_power_peak(msg_host_t host)
return MSG_host_get_speed(host);
}
-XBT_PUBLIC(double) MSG_host_get_power_peak_at(msg_host_t h, int pstate);
+XBT_PUBLIC double MSG_host_get_power_peak_at(msg_host_t h, int pstate);
-XBT_PUBLIC(void) MSG_create_environment(const char *file);
+XBT_PUBLIC void MSG_create_environment(const char* file);
/************************** Process handling *********************************/
-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);
-XBT_PUBLIC(msg_process_t)
-MSG_process_create_with_environment(const char* name, xbt_main_func_t code, void* data, msg_host_t host, int argc,
- char** argv, xbt_dict_t properties);
-
-XBT_PUBLIC(msg_process_t) MSG_process_attach(const char* name, void* data, msg_host_t host, xbt_dict_t properties);
-XBT_PUBLIC(void) MSG_process_detach();
-
-XBT_PUBLIC(void) MSG_process_kill(msg_process_t process);
-XBT_PUBLIC(int) MSG_process_killall();
-XBT_PUBLIC(msg_error_t) MSG_process_migrate(msg_process_t process, msg_host_t host);
-XBT_PUBLIC(void) MSG_process_yield();
-
-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_set_data_cleanup(void_f_pvoid_t data_cleanup);
-XBT_PUBLIC(msg_host_t) MSG_process_get_host(msg_process_t process);
-XBT_PUBLIC(msg_process_t) MSG_process_from_PID(int PID);
-XBT_PUBLIC(int) MSG_process_get_PID(msg_process_t process);
-XBT_PUBLIC(int) MSG_process_get_PPID(msg_process_t process);
-XBT_PUBLIC(const char *) MSG_process_get_name(msg_process_t process);
-XBT_PUBLIC(int) MSG_process_self_PID();
-XBT_PUBLIC(int) MSG_process_self_PPID();
-XBT_PUBLIC(const char*) MSG_process_self_name();
-XBT_PUBLIC(msg_process_t) MSG_process_self();
-XBT_PUBLIC(xbt_dynar_t) MSG_processes_as_dynar();
-XBT_PUBLIC(int) MSG_process_get_number();
-
-XBT_PUBLIC(msg_error_t) MSG_process_set_kill_time(msg_process_t process, double kill_time);
+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);
+XBT_PUBLIC msg_process_t MSG_process_create_with_environment(const char* name, xbt_main_func_t code, void* data,
+ msg_host_t host, int argc, char** argv,
+ xbt_dict_t properties);
+
+XBT_PUBLIC msg_process_t MSG_process_attach(const char* name, void* data, msg_host_t host, xbt_dict_t properties);
+XBT_PUBLIC void MSG_process_detach();
+
+XBT_PUBLIC void MSG_process_kill(msg_process_t process);
+XBT_PUBLIC int MSG_process_killall();
+XBT_PUBLIC msg_error_t MSG_process_migrate(msg_process_t process, msg_host_t host);
+XBT_PUBLIC void MSG_process_yield();
+
+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_set_data_cleanup(void_f_pvoid_t data_cleanup);
+XBT_PUBLIC msg_host_t MSG_process_get_host(msg_process_t process);
+XBT_PUBLIC msg_process_t MSG_process_from_PID(int PID);
+XBT_PUBLIC int MSG_process_get_PID(msg_process_t process);
+XBT_PUBLIC int MSG_process_get_PPID(msg_process_t process);
+XBT_PUBLIC const char* MSG_process_get_name(msg_process_t process);
+XBT_PUBLIC int MSG_process_self_PID();
+XBT_PUBLIC int MSG_process_self_PPID();
+XBT_PUBLIC const char* MSG_process_self_name();
+XBT_PUBLIC msg_process_t MSG_process_self();
+XBT_PUBLIC xbt_dynar_t MSG_processes_as_dynar();
+XBT_PUBLIC int MSG_process_get_number();
+
+XBT_PUBLIC msg_error_t MSG_process_set_kill_time(msg_process_t process, double kill_time);
/*property handlers*/
-XBT_PUBLIC(xbt_dict_t) MSG_process_get_properties(msg_process_t process);
-XBT_PUBLIC(const char*) MSG_process_get_property_value(msg_process_t process, const char* name);
+XBT_PUBLIC xbt_dict_t MSG_process_get_properties(msg_process_t process);
+XBT_PUBLIC const char* MSG_process_get_property_value(msg_process_t process, const char* name);
-XBT_PUBLIC(msg_error_t) MSG_process_suspend(msg_process_t process);
-XBT_PUBLIC(msg_error_t) MSG_process_resume(msg_process_t process);
-XBT_PUBLIC(int) MSG_process_is_suspended(msg_process_t process);
-XBT_PUBLIC(void) MSG_process_on_exit(int_f_pvoid_pvoid_t fun, void *data);
-XBT_PUBLIC(void) MSG_process_auto_restart_set(msg_process_t process, int auto_restart);
+XBT_PUBLIC msg_error_t MSG_process_suspend(msg_process_t process);
+XBT_PUBLIC msg_error_t MSG_process_resume(msg_process_t process);
+XBT_PUBLIC int MSG_process_is_suspended(msg_process_t process);
+XBT_PUBLIC void MSG_process_on_exit(int_f_pvoid_pvoid_t fun, void* data);
+XBT_PUBLIC void MSG_process_auto_restart_set(msg_process_t process, int auto_restart);
-XBT_PUBLIC(void) MSG_process_daemonize(msg_process_t process);
-XBT_PUBLIC(msg_process_t) MSG_process_restart(msg_process_t process);
-XBT_PUBLIC(void) MSG_process_ref(msg_process_t process);
-XBT_PUBLIC(void) MSG_process_unref(msg_process_t process);
+XBT_PUBLIC void MSG_process_daemonize(msg_process_t process);
+XBT_PUBLIC msg_process_t MSG_process_restart(msg_process_t process);
+XBT_PUBLIC void MSG_process_ref(msg_process_t process);
+XBT_PUBLIC void MSG_process_unref(msg_process_t process);
/************************** Task handling ************************************/
-XBT_PUBLIC(msg_task_t) MSG_task_create(const char* name, double flops_amount, double bytes_amount, void* data);
-XBT_PUBLIC(msg_task_t) MSG_parallel_task_create(const char *name,
- int host_nb,
- const msg_host_t * host_list,
- 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);
-XBT_PUBLIC(void) MSG_task_set_name(msg_task_t task, const char *name);
-XBT_PUBLIC(msg_error_t) MSG_task_cancel(msg_task_t task);
-XBT_PUBLIC(msg_error_t) MSG_task_destroy(msg_task_t task);
-
-XBT_PUBLIC(msg_error_t) MSG_task_execute(msg_task_t task);
-XBT_PUBLIC(msg_error_t) MSG_parallel_task_execute(msg_task_t task);
-XBT_PUBLIC(msg_error_t) MSG_parallel_task_execute_with_timeout(msg_task_t task, double timeout);
-XBT_PUBLIC(void) MSG_task_set_priority(msg_task_t task, double priority);
-XBT_PUBLIC(void) MSG_task_set_bound(msg_task_t task, double bound);
-
-XBT_PUBLIC(msg_error_t) MSG_process_join(msg_process_t process, double timeout);
-XBT_PUBLIC(msg_error_t) MSG_process_sleep(double nb_sec);
-
-XBT_PUBLIC(void) MSG_task_set_flops_amount(msg_task_t task, double flops_amount);
-XBT_PUBLIC(double) MSG_task_get_flops_amount(msg_task_t task);
-XBT_PUBLIC(double) MSG_task_get_remaining_work_ratio(msg_task_t task);
-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_PUBLIC(msg_error_t) MSG_task_receive_with_timeout(msg_task_t* task, const char* alias, double timeout);
-
-XBT_PUBLIC(msg_error_t) MSG_task_receive(msg_task_t* task, const char* alias);
+XBT_PUBLIC msg_task_t MSG_task_create(const char* name, double flops_amount, double bytes_amount, void* data);
+XBT_PUBLIC msg_task_t MSG_parallel_task_create(const char* name, int host_nb, const msg_host_t* host_list,
+ 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);
+XBT_PUBLIC void MSG_task_set_name(msg_task_t task, const char* name);
+XBT_PUBLIC msg_error_t MSG_task_cancel(msg_task_t task);
+XBT_PUBLIC msg_error_t MSG_task_destroy(msg_task_t task);
+
+XBT_PUBLIC msg_error_t MSG_task_execute(msg_task_t task);
+XBT_PUBLIC msg_error_t MSG_parallel_task_execute(msg_task_t task);
+XBT_PUBLIC msg_error_t MSG_parallel_task_execute_with_timeout(msg_task_t task, double timeout);
+XBT_PUBLIC void MSG_task_set_priority(msg_task_t task, double priority);
+XBT_PUBLIC void MSG_task_set_bound(msg_task_t task, double bound);
+
+XBT_PUBLIC msg_error_t MSG_process_join(msg_process_t process, double timeout);
+XBT_PUBLIC msg_error_t MSG_process_sleep(double nb_sec);
+
+XBT_PUBLIC void MSG_task_set_flops_amount(msg_task_t task, double flops_amount);
+XBT_PUBLIC double MSG_task_get_flops_amount(msg_task_t task);
+XBT_PUBLIC double MSG_task_get_remaining_work_ratio(msg_task_t task);
+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_PUBLIC msg_error_t MSG_task_receive_with_timeout(msg_task_t* task, const char* alias, double timeout);
+
+XBT_PUBLIC msg_error_t MSG_task_receive(msg_task_t* task, const char* alias);
#define MSG_task_recv(t,a) MSG_task_receive(t,a)
-XBT_PUBLIC(msg_error_t)
-MSG_task_receive_ext_bounded(msg_task_t* task, const char* alias, double timeout, msg_host_t host, double rate);
+XBT_PUBLIC msg_error_t MSG_task_receive_ext_bounded(msg_task_t* task, const char* alias, double timeout,
+ msg_host_t host, double rate);
-XBT_PUBLIC(msg_error_t)
-MSG_task_receive_with_timeout_bounded(msg_task_t* task, const char* alias, double timeout, double rate);
-XBT_PUBLIC(msg_error_t) MSG_task_receive_bounded(msg_task_t * task, const char *alias,double rate);
+XBT_PUBLIC msg_error_t MSG_task_receive_with_timeout_bounded(msg_task_t* task, const char* alias, double timeout,
+ double rate);
+XBT_PUBLIC msg_error_t MSG_task_receive_bounded(msg_task_t* task, const char* alias, double rate);
#define MSG_task_recv_bounded(t,a,r) MSG_task_receive_bounded(t,a,r)
-XBT_PUBLIC(msg_comm_t) MSG_task_isend(msg_task_t task, const char *alias);
-XBT_PUBLIC(msg_comm_t) MSG_task_isend_bounded(msg_task_t task, const char *alias, double maxrate);
+XBT_PUBLIC msg_comm_t MSG_task_isend(msg_task_t task, const char* alias);
+XBT_PUBLIC msg_comm_t MSG_task_isend_bounded(msg_task_t task, const char* alias, double maxrate);
XBT_ATTRIB_DEPRECATED_v320(
"This function will be removed from SimGrid v3.20. If you really need this function, please speak up quickly.")
- XBT_PUBLIC(msg_comm_t) MSG_task_isend_with_matching(msg_task_t task, const char* alias,
- int (*match_fun)(void*, void*, void*), void* match_data);
-
-XBT_PUBLIC(void) MSG_task_dsend(msg_task_t task, const char *alias, void_f_pvoid_t cleanup);
-XBT_PUBLIC(void) MSG_task_dsend_bounded(msg_task_t task, const char *alias, void_f_pvoid_t cleanup, double maxrate);
-XBT_PUBLIC(msg_comm_t) MSG_task_irecv(msg_task_t * task, const char *alias);
-XBT_PUBLIC(msg_comm_t) MSG_task_irecv_bounded(msg_task_t * task, const char *alias, double rate);
-XBT_PUBLIC(int) MSG_comm_test(msg_comm_t comm);
-XBT_PUBLIC(int) MSG_comm_testany(xbt_dynar_t comms);
-XBT_PUBLIC(void) MSG_comm_destroy(msg_comm_t comm);
-XBT_PUBLIC(msg_error_t) MSG_comm_wait(msg_comm_t comm, double timeout);
-XBT_PUBLIC(void) MSG_comm_waitall(msg_comm_t * comm, int nb_elem, double timeout);
-XBT_PUBLIC(int) MSG_comm_waitany(xbt_dynar_t comms);
-XBT_PUBLIC(msg_task_t) MSG_comm_get_task(msg_comm_t comm);
-XBT_PUBLIC(msg_error_t) MSG_comm_get_status(msg_comm_t comm);
-
-XBT_PUBLIC(int) MSG_task_listen(const char *alias);
-XBT_PUBLIC(msg_error_t) MSG_task_send_with_timeout(msg_task_t task, const char *alias, double timeout);
-XBT_PUBLIC(msg_error_t) MSG_task_send_with_timeout_bounded(msg_task_t task, const char *alias, double timeout, double maxrate);
-XBT_PUBLIC(msg_error_t) MSG_task_send(msg_task_t task, const char *alias);
-XBT_PUBLIC(msg_error_t) MSG_task_send_bounded(msg_task_t task, const char *alias, double rate);
-XBT_PUBLIC(int) MSG_task_listen_from(const char *alias);
-XBT_PUBLIC(void) MSG_task_set_category (msg_task_t task, const char *category);
-XBT_PUBLIC(const char *) MSG_task_get_category (msg_task_t task);
+ XBT_PUBLIC msg_comm_t MSG_task_isend_with_matching(msg_task_t task, const char* alias,
+ int (*match_fun)(void*, void*, void*), void* match_data);
+
+XBT_PUBLIC void MSG_task_dsend(msg_task_t task, const char* alias, void_f_pvoid_t cleanup);
+XBT_PUBLIC void MSG_task_dsend_bounded(msg_task_t task, const char* alias, void_f_pvoid_t cleanup, double maxrate);
+XBT_PUBLIC msg_comm_t MSG_task_irecv(msg_task_t* task, const char* alias);
+XBT_PUBLIC msg_comm_t MSG_task_irecv_bounded(msg_task_t* task, const char* alias, double rate);
+XBT_PUBLIC int MSG_comm_test(msg_comm_t comm);
+XBT_PUBLIC int MSG_comm_testany(xbt_dynar_t comms);
+XBT_PUBLIC void MSG_comm_destroy(msg_comm_t comm);
+XBT_PUBLIC msg_error_t MSG_comm_wait(msg_comm_t comm, double timeout);
+XBT_PUBLIC void MSG_comm_waitall(msg_comm_t* comm, int nb_elem, double timeout);
+XBT_PUBLIC int MSG_comm_waitany(xbt_dynar_t comms);
+XBT_PUBLIC msg_task_t MSG_comm_get_task(msg_comm_t comm);
+XBT_PUBLIC msg_error_t MSG_comm_get_status(msg_comm_t comm);
+
+XBT_PUBLIC int MSG_task_listen(const char* alias);
+XBT_PUBLIC msg_error_t MSG_task_send_with_timeout(msg_task_t task, const char* alias, double timeout);
+XBT_PUBLIC msg_error_t MSG_task_send_with_timeout_bounded(msg_task_t task, const char* alias, double timeout,
+ double maxrate);
+XBT_PUBLIC msg_error_t MSG_task_send(msg_task_t task, const char* alias);
+XBT_PUBLIC msg_error_t MSG_task_send_bounded(msg_task_t task, const char* alias, double rate);
+XBT_PUBLIC int MSG_task_listen_from(const char* alias);
+XBT_PUBLIC void MSG_task_set_category(msg_task_t task, const char* category);
+XBT_PUBLIC const char* MSG_task_get_category(msg_task_t task);
/************************** Mailbox handling ************************************/
* This call should be done before issuing any receive, and on the receiver's side only
* @param alias The alias of the mailbox to modify.
*/
-XBT_PUBLIC(void) MSG_mailbox_set_async(const char *alias);
+XBT_PUBLIC void MSG_mailbox_set_async(const char* alias);
/************************** Action handling **********************************/
-XBT_PUBLIC(msg_error_t) MSG_action_trace_run(char *path);
-XBT_PUBLIC(void) MSG_action_init();
-XBT_PUBLIC(void) MSG_action_exit();
+XBT_PUBLIC msg_error_t MSG_action_trace_run(char* path);
+XBT_PUBLIC void MSG_action_init();
+XBT_PUBLIC void MSG_action_exit();
/** @brief Opaque type representing a semaphore
* @ingroup msg_synchro
*/
typedef struct s_smx_sem_t* msg_sem_t; // Yeah that's a rename of the smx_sem_t which doesnt require smx_sem_t to be
// declared here
-XBT_PUBLIC(msg_sem_t) MSG_sem_init(int initial_value);
-XBT_PUBLIC(void) MSG_sem_acquire(msg_sem_t sem);
-XBT_PUBLIC(msg_error_t) MSG_sem_acquire_timeout(msg_sem_t sem, double timeout);
-XBT_PUBLIC(void) MSG_sem_release(msg_sem_t sem);
-XBT_PUBLIC(int) MSG_sem_get_capacity(msg_sem_t sem);
-XBT_PUBLIC(void) MSG_sem_destroy(msg_sem_t sem);
-XBT_PUBLIC(int) MSG_sem_would_block(msg_sem_t sem);
+XBT_PUBLIC msg_sem_t MSG_sem_init(int initial_value);
+XBT_PUBLIC void MSG_sem_acquire(msg_sem_t sem);
+XBT_PUBLIC msg_error_t MSG_sem_acquire_timeout(msg_sem_t sem, double timeout);
+XBT_PUBLIC void MSG_sem_release(msg_sem_t sem);
+XBT_PUBLIC int MSG_sem_get_capacity(msg_sem_t sem);
+XBT_PUBLIC void MSG_sem_destroy(msg_sem_t sem);
+XBT_PUBLIC int MSG_sem_would_block(msg_sem_t sem);
/** @brief Opaque type representing a barrier identifier
* @ingroup msg_synchro
#define MSG_BARRIER_SERIAL_PROCESS -1
typedef struct s_msg_bar_t* msg_bar_t;
-XBT_PUBLIC(msg_bar_t) MSG_barrier_init( unsigned int count);
-XBT_PUBLIC(void) MSG_barrier_destroy(msg_bar_t bar);
-XBT_PUBLIC(int) MSG_barrier_wait(msg_bar_t bar);
+XBT_PUBLIC msg_bar_t MSG_barrier_init(unsigned int count);
+XBT_PUBLIC void MSG_barrier_destroy(msg_bar_t bar);
+XBT_PUBLIC int MSG_barrier_wait(msg_bar_t bar);
/** @brief Opaque type describing a Virtual Machine.
* @ingroup msg_VMs
*
*/
-XBT_PUBLIC(int) sg_vm_is_created(sg_vm_t vm);
+XBT_PUBLIC int sg_vm_is_created(sg_vm_t vm);
#define MSG_vm_is_created(vm) sg_vm_is_created(vm)
-XBT_PUBLIC(int) sg_vm_is_running(sg_vm_t vm);
+XBT_PUBLIC int sg_vm_is_running(sg_vm_t vm);
#define MSG_vm_is_running(vm) sg_vm_is_running(vm)
-XBT_PUBLIC(int) sg_vm_is_suspended(sg_vm_t vm);
+XBT_PUBLIC int sg_vm_is_suspended(sg_vm_t vm);
#define MSG_vm_is_suspended(vm) sg_vm_is_suspended(vm)
-XBT_PUBLIC(const char*) sg_vm_get_name(sg_vm_t vm);
+XBT_PUBLIC const char* sg_vm_get_name(sg_vm_t vm);
#define MSG_vm_get_name(vm) sg_vm_get_name(vm)
-XBT_PUBLIC(void) sg_vm_set_ramsize(sg_vm_t vm, size_t size);
+XBT_PUBLIC void sg_vm_set_ramsize(sg_vm_t vm, size_t size);
#define MSG_vm_set_ramsize(vm, size) sg_vm_set_ramsize(vm, size)
-XBT_PUBLIC(size_t) sg_vm_get_ramsize(sg_vm_t vm);
+XBT_PUBLIC size_t sg_vm_get_ramsize(sg_vm_t vm);
#define MSG_vm_get_ramsize(vm) sg_vm_get_ramsize(vm)
-XBT_PUBLIC(sg_vm_t) sg_vm_create_core(sg_host_t pm, const char* name);
+XBT_PUBLIC sg_vm_t sg_vm_create_core(sg_host_t pm, const char* name);
#define MSG_vm_create_core(vm, name) sg_vm_create_core(vm, name)
-XBT_PUBLIC(sg_vm_t) sg_vm_create_multicore(sg_host_t pm, const char* name, int coreAmount);
+XBT_PUBLIC sg_vm_t sg_vm_create_multicore(sg_host_t pm, const char* name, int coreAmount);
#define MSG_vm_create_multicore(vm, name, coreAmount) sg_vm_create_multicore(vm, name, coreAmount)
XBT_ATTRIB_DEPRECATED_v322("Use sg_vm_create_migratable() from the live migration plugin: "
- "v3.22 will drop MSG_vm_create() completely.") XBT_PUBLIC(msg_vm_t)
+ "v3.22 will drop MSG_vm_create() completely.") XBT_PUBLIC msg_vm_t
MSG_vm_create(msg_host_t ind_pm, const char* name, int coreAmount, int ramsize, int mig_netspeed, int dp_intensity);
-XBT_PUBLIC(void) sg_vm_start(msg_vm_t vm);
+XBT_PUBLIC void sg_vm_start(msg_vm_t vm);
#define MSG_vm_start(vm) sg_vm_start(vm)
-XBT_PUBLIC(void) sg_vm_suspend(msg_vm_t vm);
+XBT_PUBLIC void sg_vm_suspend(msg_vm_t vm);
#define MSG_vm_suspend(vm) sg_vm_suspend(vm)
-XBT_PUBLIC(void) sg_vm_resume(msg_vm_t vm);
+XBT_PUBLIC void sg_vm_resume(msg_vm_t vm);
#define MSG_vm_resume(vm) sg_vm_resume(vm)
-XBT_PUBLIC(void) sg_vm_shutdown(msg_vm_t vm);
+XBT_PUBLIC void sg_vm_shutdown(msg_vm_t vm);
#define MSG_vm_shutdown(vm) sg_vm_shutdown(vm)
-XBT_PUBLIC(void) sg_vm_destroy(msg_vm_t vm);
+XBT_PUBLIC void sg_vm_destroy(msg_vm_t vm);
#define MSG_vm_destroy(vm) sg_vm_destroy(vm)
-XBT_PUBLIC(sg_host_t) sg_vm_get_pm(sg_vm_t vm);
+XBT_PUBLIC sg_host_t sg_vm_get_pm(sg_vm_t vm);
#define MSG_vm_get_pm(vm) sg_vm_get_pm(vm)
-XBT_PUBLIC(void) sg_vm_set_bound(sg_vm_t vm, double bound);
+XBT_PUBLIC void sg_vm_set_bound(sg_vm_t vm, double bound);
#define MSG_vm_set_bound(vm, bound) sg_vm_set_bound(vm, bound)
#include "simgrid/instr.h"
/* ****************************************************************************************** */
/* Used only by the bindings -- unclean pimple, please ignore if you're not writing a binding */
-XBT_PUBLIC(smx_context_t) MSG_process_get_smx_ctx(msg_process_t process);
+XBT_PUBLIC smx_context_t MSG_process_get_smx_ctx(msg_process_t process);
SG_END_DECL()
#ifdef __cplusplus
-XBT_PUBLIC(msg_process_t)
-MSG_process_create_from_stdfunc(const char* name, std::function<void()> code, void* data, msg_host_t host,
- std::map<std::string, std::string>* properties);
+XBT_PUBLIC msg_process_t MSG_process_create_from_stdfunc(const char* name, std::function<void()> code, void* data,
+ msg_host_t host,
+ std::map<std::string, std::string>* properties);
#endif
#endif
-/* Copyright (c) 2017. The SimGrid Team.
+/* Copyright (c) 2017-2018. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
SG_BEGIN_DECL()
-XBT_PUBLIC(void) sg_host_dvfs_plugin_init();
+XBT_PUBLIC void sg_host_dvfs_plugin_init();
#define MSG_host_dvfs_plugin_init() sg_host_dvfs_plugin_init()
-/* Copyright (c) 2016-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2016-2018. 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. */
SG_BEGIN_DECL()
-XBT_PUBLIC(void) sg_host_energy_plugin_init();
-XBT_PUBLIC(void) sg_host_energy_update_all();
-XBT_PUBLIC(double) sg_host_get_consumed_energy(sg_host_t host);
-XBT_PUBLIC(double) sg_host_get_wattmin_at(sg_host_t host, int pstate);
-XBT_PUBLIC(double) sg_host_get_wattmax_at(sg_host_t host, int pstate);
-XBT_PUBLIC(double) sg_host_get_current_consumption(sg_host_t host);
+XBT_PUBLIC void sg_host_energy_plugin_init();
+XBT_PUBLIC void sg_host_energy_update_all();
+XBT_PUBLIC double sg_host_get_consumed_energy(sg_host_t host);
+XBT_PUBLIC double sg_host_get_wattmin_at(sg_host_t host, int pstate);
+XBT_PUBLIC double sg_host_get_wattmax_at(sg_host_t host, int pstate);
+XBT_PUBLIC double sg_host_get_current_consumption(sg_host_t host);
-XBT_PUBLIC(void) sg_link_energy_plugin_init();
-XBT_PUBLIC(double) sg_link_get_consumed_energy(sg_link_t link);
+XBT_PUBLIC void sg_link_energy_plugin_init();
+XBT_PUBLIC double sg_link_get_consumed_energy(sg_link_t link);
-XBT_PUBLIC(int) sg_link_energy_is_inited();
+XBT_PUBLIC int sg_link_energy_is_inited();
#define MSG_host_energy_plugin_init() sg_host_energy_plugin_init()
#define MSG_host_get_consumed_energy(host) sg_host_get_consumed_energy(host)
SG_BEGIN_DECL()
-XBT_PUBLIC(void) sg_storage_file_system_init();
-XBT_PUBLIC(sg_file_t) sg_file_open(const char* fullpath, void* data);
-XBT_PUBLIC(sg_size_t) sg_file_read(sg_file_t fd, sg_size_t size);
-XBT_PUBLIC(sg_size_t) sg_file_write(sg_file_t fd, sg_size_t size);
-XBT_PUBLIC(void) sg_file_close(sg_file_t fd);
+XBT_PUBLIC void sg_storage_file_system_init();
+XBT_PUBLIC sg_file_t sg_file_open(const char* fullpath, void* data);
+XBT_PUBLIC sg_size_t sg_file_read(sg_file_t fd, sg_size_t size);
+XBT_PUBLIC sg_size_t sg_file_write(sg_file_t fd, sg_size_t size);
+XBT_PUBLIC void sg_file_close(sg_file_t fd);
-XBT_PUBLIC(const char*) sg_file_get_name(sg_file_t fd);
-XBT_PUBLIC(sg_size_t) sg_file_get_size(sg_file_t fd);
-XBT_PUBLIC(void) sg_file_dump(sg_file_t fd);
-XBT_PUBLIC(void*) sg_file_get_data(sg_file_t fd);
-XBT_PUBLIC(void) sg_file_set_data(sg_file_t fd, void* data);
-XBT_PUBLIC(void) sg_file_seek(sg_file_t fd, sg_offset_t offset, int origin);
-XBT_PUBLIC(sg_size_t) sg_file_tell(sg_file_t fd);
-XBT_PUBLIC(void) sg_file_move(sg_file_t fd, const char* fullpath);
-XBT_PUBLIC(void) sg_file_unlink(sg_file_t fd);
-XBT_PUBLIC(int) sg_file_rcopy(sg_file_t file, sg_host_t host, const char* fullpath);
-XBT_PUBLIC(int) sg_file_rmove(sg_file_t file, sg_host_t host, const char* fullpath);
+XBT_PUBLIC const char* sg_file_get_name(sg_file_t fd);
+XBT_PUBLIC sg_size_t sg_file_get_size(sg_file_t fd);
+XBT_PUBLIC void sg_file_dump(sg_file_t fd);
+XBT_PUBLIC void* sg_file_get_data(sg_file_t fd);
+XBT_PUBLIC void sg_file_set_data(sg_file_t fd, void* data);
+XBT_PUBLIC void sg_file_seek(sg_file_t fd, sg_offset_t offset, int origin);
+XBT_PUBLIC sg_size_t sg_file_tell(sg_file_t fd);
+XBT_PUBLIC void sg_file_move(sg_file_t fd, const char* fullpath);
+XBT_PUBLIC void sg_file_unlink(sg_file_t fd);
+XBT_PUBLIC int sg_file_rcopy(sg_file_t file, sg_host_t host, const char* fullpath);
+XBT_PUBLIC int sg_file_rmove(sg_file_t file, sg_host_t host, const char* fullpath);
-XBT_PUBLIC(sg_size_t) sg_storage_get_size_free(sg_storage_t st);
-XBT_PUBLIC(sg_size_t) sg_storage_get_size_used(sg_storage_t st);
-XBT_PUBLIC(sg_size_t) sg_storage_get_size(sg_storage_t st);
-XBT_PUBLIC(xbt_dict_t) sg_storage_get_content(sg_storage_t storage);
+XBT_PUBLIC sg_size_t sg_storage_get_size_free(sg_storage_t st);
+XBT_PUBLIC sg_size_t sg_storage_get_size_used(sg_storage_t st);
+XBT_PUBLIC sg_size_t sg_storage_get_size(sg_storage_t st);
+XBT_PUBLIC xbt_dict_t sg_storage_get_content(sg_storage_t storage);
-XBT_PUBLIC(xbt_dict_t) sg_host_get_storage_content(sg_host_t host);
+XBT_PUBLIC xbt_dict_t sg_host_get_storage_content(sg_host_t host);
#define MSG_file_open(fullpath, data) sg_file_open(fullpath, data)
#define MSG_file_read(fd, size) sg_file_read(fd, size)
SG_BEGIN_DECL()
-XBT_PUBLIC(void) sg_vm_live_migration_plugin_init();
+XBT_PUBLIC void sg_vm_live_migration_plugin_init();
XBT_PRIVATE void sg_vm_dirty_page_tracking_init();
-XBT_PUBLIC(void) sg_vm_start_dirty_page_tracking(sg_vm_t vm);
-XBT_PUBLIC(void) sg_vm_stop_dirty_page_tracking(sg_vm_t vm);
-XBT_PUBLIC(double) sg_vm_lookup_computed_flops(sg_vm_t vm);
-XBT_PUBLIC(void) sg_vm_migrate(sg_vm_t vm, sg_host_t dst_pm);
-XBT_PUBLIC(void) sg_vm_set_dirty_page_intensity(sg_vm_t vm, double intensity);
-XBT_PUBLIC(double) sg_vm_get_dirty_page_intensity(sg_vm_t vm);
-XBT_PUBLIC(void) sg_vm_set_working_set_memory(sg_vm_t vm, sg_size_t size);
-XBT_PUBLIC(sg_size_t) sg_vm_get_working_set_memory(sg_vm_t vm);
-XBT_PUBLIC(void) sg_vm_set_migration_speed(sg_vm_t vm, double speed);
-XBT_PUBLIC(double) sg_vm_get_migration_speed(sg_vm_t vm);
-XBT_PUBLIC(double) sg_vm_get_max_downtime(sg_vm_t vm);
-XBT_PUBLIC(int) sg_vm_is_migrating(sg_vm_t vm);
-XBT_PUBLIC(sg_vm_t)
-sg_vm_create_migratable(sg_host_t pm, const char* name, int coreAmount, int ramsize, int mig_netspeed,
- int dp_intensity);
+XBT_PUBLIC void sg_vm_start_dirty_page_tracking(sg_vm_t vm);
+XBT_PUBLIC void sg_vm_stop_dirty_page_tracking(sg_vm_t vm);
+XBT_PUBLIC double sg_vm_lookup_computed_flops(sg_vm_t vm);
+XBT_PUBLIC void sg_vm_migrate(sg_vm_t vm, sg_host_t dst_pm);
+XBT_PUBLIC void sg_vm_set_dirty_page_intensity(sg_vm_t vm, double intensity);
+XBT_PUBLIC double sg_vm_get_dirty_page_intensity(sg_vm_t vm);
+XBT_PUBLIC void sg_vm_set_working_set_memory(sg_vm_t vm, sg_size_t size);
+XBT_PUBLIC sg_size_t sg_vm_get_working_set_memory(sg_vm_t vm);
+XBT_PUBLIC void sg_vm_set_migration_speed(sg_vm_t vm, double speed);
+XBT_PUBLIC double sg_vm_get_migration_speed(sg_vm_t vm);
+XBT_PUBLIC double sg_vm_get_max_downtime(sg_vm_t vm);
+XBT_PUBLIC int sg_vm_is_migrating(sg_vm_t vm);
+XBT_PUBLIC sg_vm_t sg_vm_create_migratable(sg_host_t pm, const char* name, int coreAmount, int ramsize,
+ int mig_netspeed, int dp_intensity);
#define MSG_vm_live_migration_plugin_init() sg_vm_live_migration_plugin_init()
-/* Copyright (c) 2017. The SimGrid Team.
+/* Copyright (c) 2017-2018. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
SG_BEGIN_DECL()
-XBT_PUBLIC(void) sg_host_load_plugin_init();
-XBT_PUBLIC(double) sg_host_get_current_load(sg_host_t host);
-XBT_PUBLIC(double) sg_host_get_avg_load(sg_host_t host);
-XBT_PUBLIC(double) sg_host_get_idle_time(sg_host_t host);
-XBT_PUBLIC(double) sg_host_get_computed_flops(sg_host_t host);
-XBT_PUBLIC(void) sg_host_load_reset(sg_host_t host);
+XBT_PUBLIC void sg_host_load_plugin_init();
+XBT_PUBLIC double sg_host_get_current_load(sg_host_t host);
+XBT_PUBLIC double sg_host_get_avg_load(sg_host_t host);
+XBT_PUBLIC double sg_host_get_idle_time(sg_host_t host);
+XBT_PUBLIC double sg_host_get_computed_flops(sg_host_t host);
+XBT_PUBLIC void sg_host_load_reset(sg_host_t host);
#define MSG_host_load_plugin_init() sg_host_load_plugin_init()
#define MSG_host_get_current_load(host) sg_host_get_current_load(host)
-/* Copyright (c) 2006-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2006-2018. 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. */
*/
XBT_PUBLIC_CLASS Activity {
friend Comm;
- friend XBT_PUBLIC(void) intrusive_ptr_release(Comm * c);
- friend XBT_PUBLIC(void) intrusive_ptr_add_ref(Comm * c);
+ friend XBT_PUBLIC void intrusive_ptr_release(Comm * c);
+ friend XBT_PUBLIC void intrusive_ptr_add_ref(Comm * c);
friend Exec;
- friend XBT_PUBLIC(void) intrusive_ptr_release(Exec * e);
- friend XBT_PUBLIC(void) intrusive_ptr_add_ref(Exec * e);
+ friend XBT_PUBLIC void intrusive_ptr_release(Exec * e);
+ friend XBT_PUBLIC void intrusive_ptr_add_ref(Exec * e);
protected:
Activity() = default;
-/* Copyright (c) 2006-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2006-2018. 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. */
Actor& operator=(Actor const&) = delete;
// ***** Reference count *****
- friend XBT_PUBLIC(void) intrusive_ptr_add_ref(Actor * actor);
- friend XBT_PUBLIC(void) intrusive_ptr_release(Actor * actor);
+ friend XBT_PUBLIC void intrusive_ptr_add_ref(Actor * actor);
+ friend XBT_PUBLIC void intrusive_ptr_release(Actor * actor);
// ***** Actor creation *****
/** Retrieve a reference to myself */
* @brief Static methods working on the current actor (see @ref s4u::Actor) */
namespace this_actor {
-XBT_PUBLIC(bool) isMaestro();
+XBT_PUBLIC bool isMaestro();
/** Block the actor sleeping for that amount of seconds (may throws hostFailure) */
-XBT_PUBLIC(void) sleep_for(double duration);
-XBT_PUBLIC(void) sleep_until(double timeout);
+XBT_PUBLIC void sleep_for(double duration);
+XBT_PUBLIC void sleep_until(double timeout);
template <class Rep, class Period> inline void sleep_for(std::chrono::duration<Rep, Period> duration)
{
}
/** Block the actor, computing the given amount of flops */
-XBT_PUBLIC(void) execute(double flop);
+XBT_PUBLIC void execute(double flop);
/** Block the actor, computing the given amount of flops at the given priority.
* An execution of priority 2 computes twice as fast as an execution at priority 1. */
-XBT_PUBLIC(void) execute(double flop, double priority);
+XBT_PUBLIC void execute(double flop, double priority);
-XBT_PUBLIC(void) parallel_execute(int host_nb, sg_host_t* host_list, double* flops_amount, double* bytes_amount);
-XBT_PUBLIC(void)
-parallel_execute(int host_nb, sg_host_t* host_list, double* flops_amount, double* bytes_amount, double timeout);
+XBT_PUBLIC void parallel_execute(int host_nb, sg_host_t* host_list, double* flops_amount, double* bytes_amount);
+XBT_PUBLIC void parallel_execute(int host_nb, sg_host_t* host_list, double* flops_amount, double* bytes_amount,
+ double timeout);
-XBT_PUBLIC(ExecPtr) exec_init(double flops_amounts);
-XBT_PUBLIC(ExecPtr) exec_async(double flops_amounts);
+XBT_PUBLIC ExecPtr exec_init(double flops_amounts);
+XBT_PUBLIC ExecPtr exec_async(double flops_amounts);
/** Block the actor until it gets a message from the given mailbox.
*
* See \ref Comm for the full communication API (including non blocking communications).
*/
-XBT_ATTRIB_DEPRECATED_v320("Use Mailbox::get(): v3.20 will turn this warning into an error.") XBT_PUBLIC(void*)
- recv(MailboxPtr chan);
-XBT_ATTRIB_DEPRECATED_v320("Use Mailbox::get(): v3.20 will turn this warning into an error.") XBT_PUBLIC(void*)
- recv(MailboxPtr chan, double timeout);
-XBT_ATTRIB_DEPRECATED_v320("Use Mailbox::recv_async(): v3.20 will turn this warning into an error.") XBT_PUBLIC(CommPtr)
+XBT_ATTRIB_DEPRECATED_v320("Use Mailbox::get(): v3.20 will turn this warning into an error.") XBT_PUBLIC
+ void* recv(MailboxPtr chan);
+XBT_ATTRIB_DEPRECATED_v320("Use Mailbox::get(): v3.20 will turn this warning into an error.") XBT_PUBLIC
+ void* recv(MailboxPtr chan, double timeout);
+XBT_ATTRIB_DEPRECATED_v320("Use Mailbox::recv_async(): v3.20 will turn this warning into an error.") XBT_PUBLIC CommPtr
irecv(MailboxPtr chan, void** data);
/** Block the actor until it delivers a message of the given simulated size to the given mailbox
*
* See \ref Comm for the full communication API (including non blocking communications).
*/
-XBT_ATTRIB_DEPRECATED_v320("Use Mailbox::put(): v3.20 will turn this warning into an error.") XBT_PUBLIC(void)
- send(MailboxPtr chan, void* payload, double simulatedSize);
-XBT_ATTRIB_DEPRECATED_v320("Use Mailbox::put(): v3.20 will turn this warning into an error.") XBT_PUBLIC(void)
- send(MailboxPtr chan, void* payload, double simulatedSize, double timeout);
+XBT_ATTRIB_DEPRECATED_v320("Use Mailbox::put(): v3.20 will turn this warning into an error.") XBT_PUBLIC
+ void send(MailboxPtr chan, void* payload, double simulatedSize);
+XBT_ATTRIB_DEPRECATED_v320("Use Mailbox::put(): v3.20 will turn this warning into an error.") XBT_PUBLIC
+ void send(MailboxPtr chan, void* payload, double simulatedSize, double timeout);
-XBT_ATTRIB_DEPRECATED_v320("Use Mailbox::put_async(): v3.20 will turn this warning into an error.") XBT_PUBLIC(CommPtr)
+XBT_ATTRIB_DEPRECATED_v320("Use Mailbox::put_async(): v3.20 will turn this warning into an error.") XBT_PUBLIC CommPtr
isend(MailboxPtr chan, void* payload, double simulatedSize);
/** @brief Returns the actor ID of the current actor). */
-XBT_PUBLIC(aid_t) getPid();
+XBT_PUBLIC aid_t getPid();
/** @brief Returns the ancestor's actor ID of the current actor. */
-XBT_PUBLIC(aid_t) getPpid();
+XBT_PUBLIC aid_t getPpid();
/** @brief Returns the name of the current actor. */
-XBT_PUBLIC(std::string) getName();
+XBT_PUBLIC std::string getName();
/** @brief Returns the name of the current actor as a C string. */
-XBT_PUBLIC(const char*) getCname();
+XBT_PUBLIC const char* getCname();
/** @brief Returns the name of the host on which the actor is running. */
-XBT_PUBLIC(Host*) getHost();
+XBT_PUBLIC Host* getHost();
/** @brief Suspend the actor. */
-XBT_PUBLIC(void) suspend();
+XBT_PUBLIC void suspend();
/** @brief yield the actor. */
-XBT_PUBLIC(void) yield();
+XBT_PUBLIC void yield();
/** @brief Resume the actor. */
-XBT_PUBLIC(void) resume();
+XBT_PUBLIC void resume();
-XBT_PUBLIC(bool) isSuspended();
+XBT_PUBLIC bool isSuspended();
/** @brief kill the actor. */
-XBT_PUBLIC(void) kill();
+XBT_PUBLIC void kill();
/** @brief Add a function to the list of "on_exit" functions. */
-XBT_PUBLIC(void) onExit(int_f_pvoid_pvoid_t fun, void* data);
+XBT_PUBLIC void onExit(int_f_pvoid_pvoid_t fun, void* data);
/** @brief Migrate the actor to a new host. */
-XBT_PUBLIC(void) migrate(Host* new_host);
+XBT_PUBLIC void migrate(Host* new_host);
}
/** @} */
-/* Copyright (c) 2006-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2006-2018. 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. */
{
Comm() : Activity() {}
public:
- friend XBT_PUBLIC(void) intrusive_ptr_release(simgrid::s4u::Comm* c);
- friend XBT_PUBLIC(void) intrusive_ptr_add_ref(simgrid::s4u::Comm* c);
+ friend XBT_PUBLIC void intrusive_ptr_release(simgrid::s4u::Comm * c);
+ friend XBT_PUBLIC void intrusive_ptr_add_ref(simgrid::s4u::Comm * c);
friend Mailbox; // Factory of comms
virtual ~Comm();
ConditionVariable(ConditionVariable const&) = delete;
ConditionVariable& operator=(ConditionVariable const&) = delete;
- friend XBT_PUBLIC(void) intrusive_ptr_add_ref(ConditionVariable * cond);
- friend XBT_PUBLIC(void) intrusive_ptr_release(ConditionVariable * cond);
+ friend XBT_PUBLIC void intrusive_ptr_add_ref(ConditionVariable * cond);
+ friend XBT_PUBLIC void intrusive_ptr_release(ConditionVariable * cond);
using Ptr = boost::intrusive_ptr<ConditionVariable>;
static Ptr createConditionVariable();
/** Callback fired when the platform is created (ie, the xml file parsed),
* right before the actual simulation starts. */
-extern XBT_PUBLIC(xbt::signal<void()>) onPlatformCreated;
+extern XBT_PUBLIC xbt::signal<void()> onPlatformCreated;
/** Callback fired when the main simulation loop ends, just before MSG_run (or similar) ends */
-extern XBT_PUBLIC(xbt::signal<void()>) onSimulationEnd;
+extern XBT_PUBLIC xbt::signal<void()> onSimulationEnd;
/** Callback fired when the time jumps into the future */
-extern XBT_PUBLIC(xbt::signal<void(double)>) onTimeAdvance;
+extern XBT_PUBLIC xbt::signal<void(double)> onTimeAdvance;
/** Callback fired when the time cannot jump because of inter-actors deadlock */
-extern XBT_PUBLIC(xbt::signal<void(void)>) onDeadlock;
+extern XBT_PUBLIC xbt::signal<void(void)> onDeadlock;
template <class T> XBT_PRIVATE void netzoneByTypeRecursive(s4u::NetZone* current, std::vector<T*>* whereto)
{
-/* Copyright (c) 2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2017-2018. 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. */
{
Exec() : Activity() {}
public:
- friend XBT_PUBLIC(void) intrusive_ptr_release(simgrid::s4u::Exec* e);
- friend XBT_PUBLIC(void) intrusive_ptr_add_ref(simgrid::s4u::Exec* e);
- friend XBT_PUBLIC(ExecPtr) this_actor::exec_init(double flops_amount);
+ friend XBT_PUBLIC void intrusive_ptr_release(simgrid::s4u::Exec * e);
+ friend XBT_PUBLIC void intrusive_ptr_add_ref(simgrid::s4u::Exec * e);
+ friend XBT_PUBLIC ExecPtr this_actor::exec_init(double flops_amount);
~Exec() = default;
-/* Copyright (c) 2006-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2006-2018. 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. */
namespace simgrid {
namespace xbt {
-extern template class XBT_PUBLIC() Extendable<simgrid::s4u::Host>;
+extern template class XBT_PUBLIC Extendable<simgrid::s4u::Host>;
}
namespace s4u {
-/* Copyright (c) 2006-2015, 2017. The SimGrid Team.
+/* Copyright (c) 2006-2015, 2017-2018. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
namespace simgrid {
namespace xbt {
-extern template class XBT_PUBLIC() Extendable<simgrid::s4u::Storage>;
+extern template class XBT_PUBLIC Extendable<simgrid::s4u::Storage>;
}
namespace s4u {
-XBT_PUBLIC(void) getStorageList(std::map<std::string, Storage*>* whereTo);
+XBT_PUBLIC void getStorageList(std::map<std::string, Storage*>* whereTo);
XBT_PUBLIC_CLASS Storage : public simgrid::xbt::Extendable<Storage>
{
-/* Copyright (c) 2016-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2016-2018. 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. */
class Activity;
class Actor;
using ActorPtr = boost::intrusive_ptr<Actor>;
-XBT_PUBLIC(void) intrusive_ptr_release(Actor* actor);
-XBT_PUBLIC(void) intrusive_ptr_add_ref(Actor* actor);
+XBT_PUBLIC void intrusive_ptr_release(Actor* actor);
+XBT_PUBLIC void intrusive_ptr_add_ref(Actor* actor);
class Comm;
using CommPtr = boost::intrusive_ptr<Comm>;
-XBT_PUBLIC(void) intrusive_ptr_release(Comm* c);
-XBT_PUBLIC(void) intrusive_ptr_add_ref(Comm* c);
+XBT_PUBLIC void intrusive_ptr_release(Comm* c);
+XBT_PUBLIC void intrusive_ptr_add_ref(Comm* c);
class Engine;
class Exec;
using ExecPtr = boost::intrusive_ptr<Exec>;
-XBT_PUBLIC(void) intrusive_ptr_release(Exec* e);
-XBT_PUBLIC(void) intrusive_ptr_add_ref(Exec* e);
+XBT_PUBLIC void intrusive_ptr_release(Exec* e);
+XBT_PUBLIC void intrusive_ptr_add_ref(Exec* e);
class Host;
class Link;
* @see SD_task_t, @see SD_task_dependency_api
* @{
*/
-XBT_PUBLIC(SD_task_t) SD_task_create(const char *name, void *data, double amount);
-XBT_PUBLIC(void *) SD_task_get_data(SD_task_t task);
-XBT_PUBLIC(void) SD_task_set_data(SD_task_t task, void *data);
-XBT_PUBLIC(e_SD_task_state_t) SD_task_get_state(SD_task_t task);
-XBT_PUBLIC(const char *) SD_task_get_name(SD_task_t task);
-XBT_PUBLIC(void) SD_task_set_name(SD_task_t task, const char *name);
-XBT_PUBLIC(void) SD_task_set_rate(SD_task_t task, double rate);
-
-XBT_PUBLIC(void) SD_task_watch(SD_task_t task, e_SD_task_state_t state);
-XBT_PUBLIC(void) SD_task_unwatch(SD_task_t task, e_SD_task_state_t state);
-XBT_PUBLIC(double) SD_task_get_amount(SD_task_t task);
-XBT_PUBLIC(void) SD_task_set_amount(SD_task_t task, double amount);
-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 host_count, const sg_host_t *host_list,
- const double *flops_amount, 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 host_count, const sg_host_t *host_list,
- const double *flops_amount, const double *bytes_amount, double rate);
-XBT_PUBLIC(void) SD_task_unschedule(SD_task_t task);
-XBT_PUBLIC(double) SD_task_get_start_time(SD_task_t task);
-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(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);
-XBT_PUBLIC(void) SD_task_dotty(SD_task_t task, void *out_FILE);
-
-XBT_PUBLIC(SD_task_t) SD_task_create_comp_seq(const char *name, void *data, double amount);
-XBT_PUBLIC(SD_task_t) SD_task_create_comp_par_amdahl(const char *name, void *data, double amount, double alpha);
-XBT_PUBLIC(SD_task_t) SD_task_create_comm_e2e(const char *name, void *data, double amount);
-XBT_PUBLIC(SD_task_t) SD_task_create_comm_par_mxn_1d_block(const char *name, void *data, double amount);
-
-XBT_PUBLIC(void) SD_task_distribute_comp_amdahl(SD_task_t task, int ws_count);
-XBT_PUBLIC(void) SD_task_build_MxN_1D_block_matrix(SD_task_t task, int src_nb, int dst_nb);
-XBT_PUBLIC(void) SD_task_schedulev(SD_task_t task, int count, const sg_host_t * list);
-XBT_PUBLIC(void) SD_task_schedulel(SD_task_t task, int count, ...);
-
+XBT_PUBLIC SD_task_t SD_task_create(const char* name, void* data, double amount);
+XBT_PUBLIC void* SD_task_get_data(SD_task_t task);
+XBT_PUBLIC void SD_task_set_data(SD_task_t task, void* data);
+XBT_PUBLIC e_SD_task_state_t SD_task_get_state(SD_task_t task);
+XBT_PUBLIC const char* SD_task_get_name(SD_task_t task);
+XBT_PUBLIC void SD_task_set_name(SD_task_t task, const char* name);
+XBT_PUBLIC void SD_task_set_rate(SD_task_t task, double rate);
+
+XBT_PUBLIC void SD_task_watch(SD_task_t task, e_SD_task_state_t state);
+XBT_PUBLIC void SD_task_unwatch(SD_task_t task, e_SD_task_state_t state);
+XBT_PUBLIC double SD_task_get_amount(SD_task_t task);
+XBT_PUBLIC void SD_task_set_amount(SD_task_t task, double amount);
+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 host_count, const sg_host_t* host_list,
+ const double* flops_amount, 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 host_count, const sg_host_t* host_list, const double* flops_amount,
+ const double* bytes_amount, double rate);
+XBT_PUBLIC void SD_task_unschedule(SD_task_t task);
+XBT_PUBLIC double SD_task_get_start_time(SD_task_t task);
+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 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);
+XBT_PUBLIC void SD_task_dotty(SD_task_t task, void* out_FILE);
+
+XBT_PUBLIC SD_task_t SD_task_create_comp_seq(const char* name, void* data, double amount);
+XBT_PUBLIC SD_task_t SD_task_create_comp_par_amdahl(const char* name, void* data, double amount, double alpha);
+XBT_PUBLIC SD_task_t SD_task_create_comm_e2e(const char* name, void* data, double amount);
+XBT_PUBLIC SD_task_t SD_task_create_comm_par_mxn_1d_block(const char* name, void* data, double amount);
+
+XBT_PUBLIC void SD_task_distribute_comp_amdahl(SD_task_t task, int ws_count);
+XBT_PUBLIC void SD_task_build_MxN_1D_block_matrix(SD_task_t task, int src_nb, int dst_nb);
+XBT_PUBLIC void SD_task_schedulev(SD_task_t task, int count, const sg_host_t* list);
+XBT_PUBLIC void SD_task_schedulel(SD_task_t task, int count, ...);
/** @brief A constant to use in SD_task_schedule to mean that there is no cost.
*
* @see SD_task_api
* @{
*/
-XBT_PUBLIC(void) SD_task_dependency_add(SD_task_t src, SD_task_t dst);
-XBT_PUBLIC(void) SD_task_dependency_remove(SD_task_t src, SD_task_t dst);
-XBT_PUBLIC(int) SD_task_dependency_exists(SD_task_t src, SD_task_t dst);
+XBT_PUBLIC void SD_task_dependency_add(SD_task_t src, SD_task_t dst);
+XBT_PUBLIC void SD_task_dependency_remove(SD_task_t src, SD_task_t dst);
+XBT_PUBLIC int SD_task_dependency_exists(SD_task_t src, SD_task_t dst);
/** @} */
/************************** Global *******************************************/
SD_init_nocheck(argc, argv); \
} while (0)
-XBT_PUBLIC(void) SD_init_nocheck(int *argc, char **argv);
-XBT_PUBLIC(void) SD_config(const char *key, const char *value);
-XBT_PUBLIC(void) SD_create_environment(const char *platform_file);
-XBT_PUBLIC(void) SD_simulate(double how_long);
-XBT_PUBLIC(void) SD_simulate_with_update(double how_long, xbt_dynar_t changed_tasks_dynar);
-XBT_PUBLIC(double) SD_get_clock();
-XBT_PUBLIC(void) SD_exit();
-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_dotload_with_sched(const char *filename);
-XBT_PUBLIC(xbt_dynar_t) SD_PTG_dotload(const char *filename);
+XBT_PUBLIC void SD_init_nocheck(int* argc, char** argv);
+XBT_PUBLIC void SD_config(const char* key, const char* value);
+XBT_PUBLIC void SD_create_environment(const char* platform_file);
+XBT_PUBLIC void SD_simulate(double how_long);
+XBT_PUBLIC void SD_simulate_with_update(double how_long, xbt_dynar_t changed_tasks_dynar);
+XBT_PUBLIC double SD_get_clock();
+XBT_PUBLIC void SD_exit();
+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_dotload_with_sched(const char* filename);
+XBT_PUBLIC xbt_dynar_t SD_PTG_dotload(const char* filename);
/** @} */
/* Support some backward compatibility */
#ifdef __cplusplus
namespace simgrid {
namespace sd {
-XBT_PUBLIC(std::set<SD_task_t>*) simulate(double how_long);
+XBT_PUBLIC std::set<SD_task_t>* simulate(double how_long);
}
}
#endif
SG_BEGIN_DECL()
-XBT_PUBLIC(smx_actor_t) SIMIX_process_from_PID(aid_t PID);
+XBT_PUBLIC smx_actor_t SIMIX_process_from_PID(aid_t PID);
/* parallelism */
-XBT_PUBLIC(int) SIMIX_context_is_parallel();
-XBT_PUBLIC(int) SIMIX_context_get_nthreads();
-XBT_PUBLIC(void) SIMIX_context_set_nthreads(int nb_threads);
-XBT_PUBLIC(int) SIMIX_context_get_parallel_threshold();
-XBT_PUBLIC(void) SIMIX_context_set_parallel_threshold(int threshold);
-XBT_PUBLIC(e_xbt_parmap_mode_t) SIMIX_context_get_parallel_mode();
-XBT_PUBLIC(void) SIMIX_context_set_parallel_mode(e_xbt_parmap_mode_t mode);
-XBT_PUBLIC(int) SIMIX_is_maestro();
-
+XBT_PUBLIC int SIMIX_context_is_parallel();
+XBT_PUBLIC int SIMIX_context_get_nthreads();
+XBT_PUBLIC void SIMIX_context_set_nthreads(int nb_threads);
+XBT_PUBLIC int SIMIX_context_get_parallel_threshold();
+XBT_PUBLIC void SIMIX_context_set_parallel_threshold(int threshold);
+XBT_PUBLIC e_xbt_parmap_mode_t SIMIX_context_get_parallel_mode();
+XBT_PUBLIC void SIMIX_context_set_parallel_mode(e_xbt_parmap_mode_t mode);
+XBT_PUBLIC int SIMIX_is_maestro();
/********************************** Global ************************************/
/* Initialization and exit */
-XBT_PUBLIC(void) SIMIX_global_init(int *argc, char **argv);
+XBT_PUBLIC void SIMIX_global_init(int* argc, char** argv);
/* Set to execute in the maestro
*
* If no maestro code is registered (the default), the main thread
* is assumed to be the maestro. */
-XBT_PUBLIC(void) SIMIX_set_maestro(void (*code)(void*), void* data);
+XBT_PUBLIC void SIMIX_set_maestro(void (*code)(void*), void* data);
-XBT_PUBLIC(void) SIMIX_function_register_process_cleanup(void_pfn_smxprocess_t function);
-XBT_PUBLIC(void) SIMIX_function_register_process_kill(void_pfn_smxprocess_t function);
+XBT_PUBLIC void SIMIX_function_register_process_cleanup(void_pfn_smxprocess_t function);
+XBT_PUBLIC void SIMIX_function_register_process_kill(void_pfn_smxprocess_t function);
/* Simulation execution */
-XBT_PUBLIC(void) SIMIX_run();
-XBT_PUBLIC(double) SIMIX_get_clock();
+XBT_PUBLIC void SIMIX_run();
+XBT_PUBLIC double SIMIX_get_clock();
/* Timer functions FIXME: should these be public? */
typedef struct s_smx_timer_t* smx_timer_t;
-XBT_PUBLIC(smx_timer_t) SIMIX_timer_set(double date, void (*function)(void*), void *arg);
-XBT_PUBLIC(void) SIMIX_timer_remove(smx_timer_t timer);
-XBT_PUBLIC(double) SIMIX_timer_next();
-XBT_PUBLIC(double) SIMIX_timer_get_date(smx_timer_t timer);
+XBT_PUBLIC smx_timer_t SIMIX_timer_set(double date, void (*function)(void*), void* arg);
+XBT_PUBLIC void SIMIX_timer_remove(smx_timer_t timer);
+XBT_PUBLIC double SIMIX_timer_next();
+XBT_PUBLIC double SIMIX_timer_get_date(smx_timer_t timer);
-XBT_PUBLIC(void) SIMIX_display_process_status();
+XBT_PUBLIC void SIMIX_display_process_status();
/******************************* Environment **********************************/
-XBT_PUBLIC(void) SIMIX_create_environment(const char *file);
+XBT_PUBLIC void SIMIX_create_environment(const char* file);
/******************************** Deployment **********************************/
-XBT_PUBLIC(void) SIMIX_function_register(const char *name, xbt_main_func_t code);
-XBT_PUBLIC(void) SIMIX_function_register_default(xbt_main_func_t code);
-XBT_PUBLIC(void) SIMIX_init_application();
-XBT_PUBLIC(void) SIMIX_launch_application(const char *file);
+XBT_PUBLIC void SIMIX_function_register(const char* name, xbt_main_func_t code);
+XBT_PUBLIC void SIMIX_function_register_default(xbt_main_func_t code);
+XBT_PUBLIC void SIMIX_init_application();
+XBT_PUBLIC void SIMIX_launch_application(const char* file);
-XBT_PUBLIC(void) SIMIX_process_set_function(const char* process_host,
- const char *process_function,
- xbt_dynar_t arguments,
- double process_start_time,
- double process_kill_time);
+XBT_PUBLIC void SIMIX_process_set_function(const char* process_host, const char* process_function,
+ xbt_dynar_t arguments, double process_start_time, double process_kill_time);
/*********************************** Host *************************************/
/* Functions for running a process in main()
* 4. detach (this waits for the simulation to terminate)
*/
-XBT_PUBLIC(void) SIMIX_maestro_create(void (*code)(void*), void* data);
+XBT_PUBLIC void SIMIX_maestro_create(void (*code)(void*), void* data);
#ifdef __cplusplus
-XBT_PUBLIC(smx_actor_t)
-SIMIX_process_attach(const char* name, void* data, const char* hostname, std::map<std::string, std::string>* properties,
- smx_actor_t parent_process);
+XBT_PUBLIC smx_actor_t SIMIX_process_attach(const char* name, void* data, const char* hostname,
+ std::map<std::string, std::string>* properties, smx_actor_t parent_process);
#endif
-XBT_PUBLIC(void) SIMIX_process_detach();
+XBT_PUBLIC void SIMIX_process_detach();
/*********************************** Host *************************************/
-XBT_PUBLIC(void) SIMIX_host_off(sg_host_t host, smx_actor_t issuer);
+XBT_PUBLIC void SIMIX_host_off(sg_host_t host, smx_actor_t issuer);
/********************************* Process ************************************/
-XBT_PUBLIC(int) SIMIX_process_count();
-XBT_PUBLIC(smx_actor_t) SIMIX_process_self();
-XBT_PUBLIC(const char*) SIMIX_process_self_get_name();
-XBT_PUBLIC(void) SIMIX_process_self_set_data(void *data);
-XBT_PUBLIC(void*) SIMIX_process_self_get_data();
-XBT_PUBLIC(int) SIMIX_process_has_pending_comms(smx_actor_t process);
-XBT_PUBLIC(void) SIMIX_process_on_exit_runall(smx_actor_t process);
-XBT_PUBLIC(void) SIMIX_process_on_exit(smx_actor_t process, int_f_pvoid_pvoid_t fun, void *data);
+XBT_PUBLIC int SIMIX_process_count();
+XBT_PUBLIC smx_actor_t SIMIX_process_self();
+XBT_PUBLIC const char* SIMIX_process_self_get_name();
+XBT_PUBLIC void SIMIX_process_self_set_data(void* data);
+XBT_PUBLIC void* SIMIX_process_self_get_data();
+XBT_PUBLIC int SIMIX_process_has_pending_comms(smx_actor_t process);
+XBT_PUBLIC void SIMIX_process_on_exit_runall(smx_actor_t process);
+XBT_PUBLIC void SIMIX_process_on_exit(smx_actor_t process, int_f_pvoid_pvoid_t fun, void* data);
SG_END_DECL()
/****************************** Communication *********************************/
-XBT_PUBLIC(void) SIMIX_comm_set_copy_data_callback(void (*callback) (smx_activity_t, void*, size_t));
-XBT_PUBLIC(void) SIMIX_comm_copy_pointer_callback(smx_activity_t comm, void* buff, size_t buff_size);
-XBT_PUBLIC(void) SIMIX_comm_copy_buffer_callback(smx_activity_t comm, void* buff, size_t buff_size);
+XBT_PUBLIC void SIMIX_comm_set_copy_data_callback(void (*callback)(smx_activity_t, void*, size_t));
+XBT_PUBLIC void SIMIX_comm_copy_pointer_callback(smx_activity_t comm, void* buff, size_t buff_size);
+XBT_PUBLIC void SIMIX_comm_copy_buffer_callback(smx_activity_t comm, void* buff, size_t buff_size);
-XBT_PUBLIC(void) SIMIX_comm_finish(smx_activity_t synchro);
+XBT_PUBLIC void SIMIX_comm_finish(smx_activity_t synchro);
/******************************************************************************/
/* SIMIX simcalls */
/* They can also be called from maestro's context, and they are thread safe. */
/******************************************************************************/
-XBT_PUBLIC(void) simcall_call(smx_actor_t process);
+XBT_PUBLIC void simcall_call(smx_actor_t process);
/******************************* Host simcalls ********************************/
-XBT_PUBLIC(smx_activity_t)
-simcall_execution_start(const char* name, double flops_amount, double priority, double bound, sg_host_t host);
-XBT_PUBLIC(smx_activity_t)
-simcall_execution_parallel_start(const char* name, int host_nb, sg_host_t* host_list, double* flops_amount,
- double* bytes_amount, double rate, double timeout);
-XBT_PUBLIC(void) simcall_execution_cancel(smx_activity_t execution);
-XBT_PUBLIC(void) simcall_execution_set_priority(smx_activity_t execution, double priority);
-XBT_PUBLIC(void) simcall_execution_set_bound(smx_activity_t execution, double bound);
-XBT_PUBLIC(e_smx_state_t) simcall_execution_wait(smx_activity_t execution);
-XBT_PUBLIC(e_smx_state_t) simcall_execution_test(smx_activity_t execution);
+XBT_PUBLIC smx_activity_t simcall_execution_start(const char* name, double flops_amount, double priority, double bound,
+ sg_host_t host);
+XBT_PUBLIC smx_activity_t simcall_execution_parallel_start(const char* name, int host_nb, sg_host_t* host_list,
+ double* flops_amount, double* bytes_amount, double rate,
+ double timeout);
+XBT_PUBLIC void simcall_execution_cancel(smx_activity_t execution);
+XBT_PUBLIC void simcall_execution_set_priority(smx_activity_t execution, double priority);
+XBT_PUBLIC void simcall_execution_set_bound(smx_activity_t execution, double bound);
+XBT_PUBLIC e_smx_state_t simcall_execution_wait(smx_activity_t execution);
+XBT_PUBLIC e_smx_state_t simcall_execution_test(smx_activity_t execution);
/**************************** Process simcalls ********************************/
SG_BEGIN_DECL()
/* Constructor and Destructor */
#ifdef __cplusplus
-XBT_PUBLIC(smx_actor_t)
-simcall_process_create(const char* name, xbt_main_func_t code, void* data, sg_host_t host, int argc, char** argv,
- std::map<std::string, std::string>* properties);
+XBT_PUBLIC smx_actor_t simcall_process_create(const char* name, xbt_main_func_t code, void* data, sg_host_t host,
+ int argc, char** argv, std::map<std::string, std::string>* properties);
#endif
-XBT_PUBLIC(void) simcall_process_killall();
-XBT_PUBLIC(void) SIMIX_process_throw(smx_actor_t process, xbt_errcat_t cat, int value, const char *msg);
-
+XBT_PUBLIC void simcall_process_killall();
+XBT_PUBLIC void SIMIX_process_throw(smx_actor_t process, xbt_errcat_t cat, int value, const char* msg);
/* Process handling */
-XBT_PUBLIC(void) simcall_process_cleanup(smx_actor_t process);
-XBT_PUBLIC(void) simcall_process_suspend(smx_actor_t process);
+XBT_PUBLIC void simcall_process_cleanup(smx_actor_t process);
+XBT_PUBLIC void simcall_process_suspend(smx_actor_t process);
/* Getters and Setters */
-XBT_PUBLIC(int) simcall_process_count();
-XBT_PUBLIC(void) simcall_process_set_data(smx_actor_t process, void *data);
-XBT_PUBLIC(void) simcall_process_set_kill_time(smx_actor_t process, double kill_time);
-XBT_PUBLIC(void) simcall_process_on_exit(smx_actor_t process, int_f_pvoid_pvoid_t fun, void *data);
-XBT_PUBLIC(void) simcall_process_join(smx_actor_t process, double timeout);
+XBT_PUBLIC int simcall_process_count();
+XBT_PUBLIC void simcall_process_set_data(smx_actor_t process, void* data);
+XBT_PUBLIC void simcall_process_set_kill_time(smx_actor_t process, double kill_time);
+XBT_PUBLIC void simcall_process_on_exit(smx_actor_t process, int_f_pvoid_pvoid_t fun, void* data);
+XBT_PUBLIC void simcall_process_join(smx_actor_t process, double timeout);
/* Sleep control */
-XBT_PUBLIC(e_smx_state_t) simcall_process_sleep(double duration);
+XBT_PUBLIC e_smx_state_t simcall_process_sleep(double duration);
SG_END_DECL()
/************************** Comunication simcalls *****************************/
#ifdef __cplusplus
-XBT_PUBLIC(void)
-simcall_comm_send(smx_actor_t sender, smx_mailbox_t mbox, double task_size, double rate, void* src_buff,
- size_t src_buff_size, int (*match_fun)(void*, void*, simgrid::kernel::activity::CommImpl*),
- void (*copy_data_fun)(smx_activity_t, void*, size_t), void* data, double timeout);
-
-XBT_PUBLIC(smx_activity_t)
-simcall_comm_isend(smx_actor_t sender, smx_mailbox_t mbox, double task_size, double rate, void* src_buff,
- size_t src_buff_size, int (*match_fun)(void*, void*, simgrid::kernel::activity::CommImpl*),
- void (*clean_fun)(void*), void (*copy_data_fun)(smx_activity_t, void*, size_t), void* data,
- int detached);
-
-XBT_PUBLIC(void)
-simcall_comm_recv(smx_actor_t receiver, smx_mailbox_t mbox, void* dst_buff, size_t* dst_buff_size,
- int (*match_fun)(void*, void*, simgrid::kernel::activity::CommImpl*),
- void (*copy_data_fun)(smx_activity_t, void*, size_t), void* data, double timeout, double rate);
-
-XBT_PUBLIC(smx_activity_t)
-simcall_comm_irecv(smx_actor_t receiver, smx_mailbox_t mbox, void* dst_buff, size_t* dst_buff_size,
- int (*match_fun)(void*, void*, simgrid::kernel::activity::CommImpl*),
- void (*copy_data_fun)(smx_activity_t, void*, size_t), void* data, double rate);
-
-XBT_PUBLIC(smx_activity_t)
-simcall_comm_iprobe(smx_mailbox_t mbox, int type, int (*match_fun)(void*, void*, simgrid::kernel::activity::CommImpl*),
- void* data);
+XBT_PUBLIC void simcall_comm_send(smx_actor_t sender, smx_mailbox_t mbox, double task_size, double rate, void* src_buff,
+ size_t src_buff_size,
+ int (*match_fun)(void*, void*, simgrid::kernel::activity::CommImpl*),
+ void (*copy_data_fun)(smx_activity_t, void*, size_t), void* data, double timeout);
+
+XBT_PUBLIC smx_activity_t simcall_comm_isend(smx_actor_t sender, smx_mailbox_t mbox, double task_size, double rate,
+ void* src_buff, size_t src_buff_size,
+ int (*match_fun)(void*, void*, simgrid::kernel::activity::CommImpl*),
+ void (*clean_fun)(void*),
+ void (*copy_data_fun)(smx_activity_t, void*, size_t), void* data,
+ int detached);
+
+XBT_PUBLIC void simcall_comm_recv(smx_actor_t receiver, smx_mailbox_t mbox, void* dst_buff, size_t* dst_buff_size,
+ int (*match_fun)(void*, void*, simgrid::kernel::activity::CommImpl*),
+ void (*copy_data_fun)(smx_activity_t, void*, size_t), void* data, double timeout,
+ double rate);
+
+XBT_PUBLIC smx_activity_t simcall_comm_irecv(smx_actor_t receiver, smx_mailbox_t mbox, void* dst_buff,
+ size_t* dst_buff_size,
+ int (*match_fun)(void*, void*, simgrid::kernel::activity::CommImpl*),
+ void (*copy_data_fun)(smx_activity_t, void*, size_t), void* data,
+ double rate);
+
+XBT_PUBLIC smx_activity_t simcall_comm_iprobe(smx_mailbox_t mbox, int type,
+ int (*match_fun)(void*, void*, simgrid::kernel::activity::CommImpl*),
+ void* data);
#endif
-XBT_PUBLIC(void) simcall_comm_cancel(smx_activity_t comm);
+XBT_PUBLIC void simcall_comm_cancel(smx_activity_t comm);
/* FIXME: waitany is going to be a vararg function, and should take a timeout */
-XBT_PUBLIC(unsigned int) simcall_comm_waitany(xbt_dynar_t comms, double timeout);
-XBT_PUBLIC(void) simcall_comm_wait(smx_activity_t comm, double timeout);
-XBT_PUBLIC(int) simcall_comm_test(smx_activity_t comm);
-XBT_PUBLIC(int) simcall_comm_testany(smx_activity_t* comms, size_t count);
+XBT_PUBLIC unsigned int simcall_comm_waitany(xbt_dynar_t comms, double timeout);
+XBT_PUBLIC void simcall_comm_wait(smx_activity_t comm, double timeout);
+XBT_PUBLIC int simcall_comm_test(smx_activity_t comm);
+XBT_PUBLIC int simcall_comm_testany(smx_activity_t* comms, size_t count);
/************************** Tracing handling **********************************/
-XBT_PUBLIC(void) simcall_set_category(smx_activity_t synchro, const char *category);
+XBT_PUBLIC void simcall_set_category(smx_activity_t synchro, const char* category);
/************************** Synchro simcalls **********************************/
SG_BEGIN_DECL()
-XBT_PUBLIC(smx_mutex_t) simcall_mutex_init();
-XBT_PUBLIC(smx_mutex_t) SIMIX_mutex_ref(smx_mutex_t mutex);
-XBT_PUBLIC(void) SIMIX_mutex_unref(smx_mutex_t mutex);
-XBT_PUBLIC(void) simcall_mutex_lock(smx_mutex_t mutex);
-XBT_PUBLIC(int) simcall_mutex_trylock(smx_mutex_t mutex);
-XBT_PUBLIC(void) simcall_mutex_unlock(smx_mutex_t mutex);
-
-XBT_PUBLIC(smx_cond_t) simcall_cond_init();
-XBT_PUBLIC(void) SIMIX_cond_unref(smx_cond_t cond);
-XBT_PUBLIC(smx_cond_t) SIMIX_cond_ref(smx_cond_t cond);
-XBT_PUBLIC(void) simcall_cond_signal(smx_cond_t cond);
-XBT_PUBLIC(void) simcall_cond_wait(smx_cond_t cond, smx_mutex_t mutex);
-XBT_PUBLIC(void) simcall_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double max_duration);
-XBT_PUBLIC(void) simcall_cond_broadcast(smx_cond_t cond);
-
-XBT_PUBLIC(void) SIMIX_sem_destroy(smx_sem_t sem);
-XBT_PUBLIC(void) simcall_sem_acquire(smx_sem_t sem);
-XBT_PUBLIC(void) simcall_sem_acquire_timeout(smx_sem_t sem, double max_duration);
+XBT_PUBLIC smx_mutex_t simcall_mutex_init();
+XBT_PUBLIC smx_mutex_t SIMIX_mutex_ref(smx_mutex_t mutex);
+XBT_PUBLIC void SIMIX_mutex_unref(smx_mutex_t mutex);
+XBT_PUBLIC void simcall_mutex_lock(smx_mutex_t mutex);
+XBT_PUBLIC int simcall_mutex_trylock(smx_mutex_t mutex);
+XBT_PUBLIC void simcall_mutex_unlock(smx_mutex_t mutex);
+
+XBT_PUBLIC smx_cond_t simcall_cond_init();
+XBT_PUBLIC void SIMIX_cond_unref(smx_cond_t cond);
+XBT_PUBLIC smx_cond_t SIMIX_cond_ref(smx_cond_t cond);
+XBT_PUBLIC void simcall_cond_signal(smx_cond_t cond);
+XBT_PUBLIC void simcall_cond_wait(smx_cond_t cond, smx_mutex_t mutex);
+XBT_PUBLIC void simcall_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double max_duration);
+XBT_PUBLIC void simcall_cond_broadcast(smx_cond_t cond);
+
+XBT_PUBLIC void SIMIX_sem_destroy(smx_sem_t sem);
+XBT_PUBLIC void simcall_sem_acquire(smx_sem_t sem);
+XBT_PUBLIC void simcall_sem_acquire_timeout(smx_sem_t sem, double max_duration);
/***************************** Storage **********************************/
-XBT_PUBLIC(sg_size_t) simcall_storage_read(surf_storage_t st, sg_size_t size);
-XBT_PUBLIC(sg_size_t) simcall_storage_write(surf_storage_t fd, sg_size_t size);
+XBT_PUBLIC sg_size_t simcall_storage_read(surf_storage_t st, sg_size_t size);
+XBT_PUBLIC sg_size_t simcall_storage_write(surf_storage_t fd, sg_size_t size);
/************************** MC simcalls **********************************/
-XBT_PUBLIC(int) simcall_mc_random(int min, int max);
+XBT_PUBLIC int simcall_mc_random(int min, int max);
SG_END_DECL()
-/* Copyright (c) 2007-2010, 2012-2017. The SimGrid Team.
+/* Copyright (c) 2007-2010, 2012-2018. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
#include <map>
#include <string>
-XBT_PUBLIC(void) simcall_run_kernel(std::function<void()> const& code);
+XBT_PUBLIC void simcall_run_kernel(std::function<void()> const& code);
/** Execute some code in the kernel and block
*
*
* @ref simix::kernelSync() is a higher level wrapper for this.
*/
-XBT_PUBLIC(void) simcall_run_blocking(std::function<void()> const& code);
+XBT_PUBLIC void simcall_run_blocking(std::function<void()> const& code);
template<class F> inline
void simcall_run_kernel(F& f)
return result.get();
}
-XBT_PUBLIC(const std::vector<smx_actor_t>&) process_get_runnable();
+XBT_PUBLIC const std::vector<smx_actor_t>& process_get_runnable();
-XBT_PUBLIC(void) set_maestro(std::function<void()> code);
-XBT_PUBLIC(void) create_maestro(std::function<void()> code);
+XBT_PUBLIC void set_maestro(std::function<void()> code);
+XBT_PUBLIC void create_maestro(std::function<void()> code);
// What's executed as SIMIX actor code:
typedef std::function<void()> ActorCode;
// Create ActorCode based on argv:
typedef std::function<ActorCode(std::vector<std::string> args)> ActorCodeFactory;
-XBT_PUBLIC(void) registerFunction(const char* name, ActorCodeFactory factory);
+XBT_PUBLIC void registerFunction(const char* name, ActorCodeFactory factory);
/** These functions will be called when we detect a deadlock: any remaining process is locked on an action
*
/* props */ std::map<std::string, std::string>*,
/* parent_process */ smx_actor_t);
-extern "C"
-XBT_PUBLIC(void) SIMIX_function_register_process_create(smx_creation_func_t function);
+extern "C" XBT_PUBLIC void SIMIX_function_register_process_create(smx_creation_func_t function);
-XBT_PUBLIC(smx_actor_t)
-simcall_process_create(const char* name, std::function<void()> code, void* data, sg_host_t host,
- std::map<std::string, std::string>* properties);
+XBT_PUBLIC smx_actor_t simcall_process_create(const char* name, std::function<void()> code, void* data, sg_host_t host,
+ std::map<std::string, std::string>* properties);
-XBT_PUBLIC(smx_timer_t) SIMIX_timer_set(double date, simgrid::xbt::Task<void()> callback);
+XBT_PUBLIC smx_timer_t SIMIX_timer_set(double date, simgrid::xbt::Task<void()> callback);
template<class F> inline
smx_timer_t SIMIX_timer_set(double date, F callback)
-/* Copyright (c) 2016-2017. The SimGrid Team.
+/* Copyright (c) 2016-2018. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
#include <simgrid/simix.h>
#include <simgrid/simix.hpp>
-XBT_PUBLIC(void) simcall_run_blocking(std::function<void()> const& code);
+XBT_PUBLIC void simcall_run_blocking(std::function<void()> const& code);
namespace simgrid {
namespace simix {
-XBT_PUBLIC(void) unblock(smx_actor_t process);
+XBT_PUBLIC void unblock(smx_actor_t process);
/** Execute some code in kernel mode and wakes up the actor when
* the result is available.
/* simgrid_config.h - Results of the configure made visible to user code. */
-/* Copyright (c) 2009-2016. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2009-2018. 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. */
SG_BEGIN_DECL()
/** Retrieves the version numbers of the used dynamic library (so, DLL or dynlib), while
SIMGRID_VERSION_MAJOR and friends give the version numbers of the used header files */
-XBT_PUBLIC(void) sg_version_get(int *major,int *minor,int *patch);
+XBT_PUBLIC void sg_version_get(int* major, int* minor, int* patch);
/** Display the version information and some additional blurb. */
-XBT_PUBLIC(void) sg_version();
+XBT_PUBLIC void sg_version();
SG_END_DECL()
typedef int (MPI_Datarep_extent_function)(MPI_Datatype, MPI_Aint *, void *);
typedef int (MPI_Datarep_conversion_function)(void *, MPI_Datatype, int, void *, MPI_Offset, void *);
-MPI_CALL(XBT_PUBLIC(int), MPI_Init, (int *argc, char ***argv));
-MPI_CALL(XBT_PUBLIC(int), MPI_Finalize, (void));
-MPI_CALL(XBT_PUBLIC(int), MPI_Finalized, (int* flag));
-MPI_CALL(XBT_PUBLIC(int), MPI_Init_thread, (int *argc, char ***argv, int required, int *provided));
-MPI_CALL(XBT_PUBLIC(int), MPI_Initialized, (int* flag));
-MPI_CALL(XBT_PUBLIC(int), MPI_Query_thread, (int *provided));
-MPI_CALL(XBT_PUBLIC(int), MPI_Is_thread_main, (int *flag));
-MPI_CALL(XBT_PUBLIC(int), MPI_Get_version, (int *version,int *subversion));
-MPI_CALL(XBT_PUBLIC(int), MPI_Get_library_version, (char *version,int *len));
-MPI_CALL(XBT_PUBLIC(int), MPI_Get_processor_name, (char *name, int *resultlen));
-MPI_CALL(XBT_PUBLIC(int), MPI_Abort, (MPI_Comm comm, int errorcode));
-MPI_CALL(XBT_PUBLIC(int), MPI_Alloc_mem, (MPI_Aint size, MPI_Info info, void *baseptr));
-MPI_CALL(XBT_PUBLIC(int), MPI_Free_mem, (void *base));
-MPI_CALL(XBT_PUBLIC(double), MPI_Wtime, (void));
-MPI_CALL(XBT_PUBLIC(double), MPI_Wtick,(void));
-
-MPI_CALL(XBT_PUBLIC(int), MPI_Address, (void *location, MPI_Aint * address));
-MPI_CALL(XBT_PUBLIC(int), MPI_Get_address, (void *location, MPI_Aint * address));
-MPI_CALL(XBT_PUBLIC(int), MPI_Error_class, (int errorcode, int* errorclass));
-
-MPI_CALL(XBT_PUBLIC(int), MPI_Attr_delete, (MPI_Comm comm, int keyval));
-MPI_CALL(XBT_PUBLIC(int), MPI_Attr_get, (MPI_Comm comm, int keyval, void* attr_value, int* flag));
-MPI_CALL(XBT_PUBLIC(int), MPI_Attr_put, (MPI_Comm comm, int keyval, void* attr_value));
-MPI_CALL(XBT_PUBLIC(int), MPI_Keyval_create, (MPI_Copy_function* copy_fn, MPI_Delete_function* delete_fn, int* keyval,
- void* extra_state));
-MPI_CALL(XBT_PUBLIC(int), MPI_Keyval_free, (int* keyval));
-
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_free, (MPI_Datatype * datatype));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_size, (MPI_Datatype datatype, int *size));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_size_x, (MPI_Datatype datatype, MPI_Count *size));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_get_extent, (MPI_Datatype datatype, MPI_Aint * lb, MPI_Aint * extent));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_get_true_extent, (MPI_Datatype datatype, MPI_Aint * lb, MPI_Aint * extent));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_extent, (MPI_Datatype datatype, MPI_Aint * extent));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_lb, (MPI_Datatype datatype, MPI_Aint * disp));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_ub, (MPI_Datatype datatype, MPI_Aint * disp));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_commit, (MPI_Datatype* datatype));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_hindexed,(int count, int* blocklens, MPI_Aint* indices,
- MPI_Datatype old_type, MPI_Datatype* newtype));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_create_hindexed, (int count, int* blocklens, MPI_Aint* indices,
- MPI_Datatype old_type, MPI_Datatype* newtype));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_create_hindexed_block, (int count, int blocklength, MPI_Aint* indices,
- MPI_Datatype old_type, MPI_Datatype* newtype));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_hvector, (int count, int blocklen, MPI_Aint stride,
- MPI_Datatype old_type, MPI_Datatype* newtype));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_create_hvector, (int count, int blocklen, MPI_Aint stride,
- MPI_Datatype old_type, MPI_Datatype* newtype));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_indexed, (int count, int* blocklens, int* indices,
- MPI_Datatype old_type, MPI_Datatype* newtype));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_create_indexed, (int count, int* blocklens, int* indices,
- MPI_Datatype old_type, MPI_Datatype* newtype));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_create_indexed_block, (int count, int blocklength, int* indices,
- MPI_Datatype old_type, MPI_Datatype* newtype));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_struct, (int count, int* blocklens, MPI_Aint* indices,
- MPI_Datatype* old_types, MPI_Datatype* newtype));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_create_struct, (int count, int* blocklens, MPI_Aint* indices,
- MPI_Datatype* old_types, MPI_Datatype* newtype));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_vector, (int count, int blocklen, int stride,
- MPI_Datatype old_type, MPI_Datatype* newtype));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_contiguous, (int count, MPI_Datatype old_type, MPI_Datatype* newtype));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_create_resized ,(MPI_Datatype oldtype,MPI_Aint lb, MPI_Aint extent,
- MPI_Datatype *newtype));
-MPI_CALL(XBT_PUBLIC(MPI_Datatype), MPI_Type_f2c,(MPI_Fint datatype));
-MPI_CALL(XBT_PUBLIC(MPI_Fint), MPI_Type_c2f,(MPI_Datatype datatype));
-MPI_CALL(XBT_PUBLIC(int), MPI_Get_count, (MPI_Status * status, MPI_Datatype datatype, int *count));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_get_attr, (MPI_Datatype type, int type_keyval, void *attribute_val, int* flag));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_set_attr, (MPI_Datatype type, int type_keyval, void *att));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_delete_attr, (MPI_Datatype type, int comm_keyval));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_create_keyval,(MPI_Type_copy_attr_function* copy_fn,
- MPI_Type_delete_attr_function* delete_fn, int* keyval, void* extra_state));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_free_keyval,(int* keyval));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_dup,(MPI_Datatype datatype,MPI_Datatype *newtype));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_set_name,(MPI_Datatype datatype, char * name));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_get_name,(MPI_Datatype datatype, char * name, int* len));
-
-
-MPI_CALL(XBT_PUBLIC(int), MPI_Pack, (void* inbuf, int incount, MPI_Datatype type, void* outbuf, int outcount,
- int* position, MPI_Comm comm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Pack_size, (int incount, MPI_Datatype datatype, MPI_Comm comm, int* size));
-MPI_CALL(XBT_PUBLIC(int), MPI_Unpack, (void* inbuf, int insize, int* position, void* outbuf, int outcount,
- MPI_Datatype type, MPI_Comm comm));
-
-MPI_CALL(XBT_PUBLIC(int), MPI_Op_create, (MPI_User_function * function, int commute, MPI_Op * op));
-MPI_CALL(XBT_PUBLIC(int), MPI_Op_free, (MPI_Op * op));
-MPI_CALL(XBT_PUBLIC(int), MPI_Op_commutative, (MPI_Op op, int *commute));
-MPI_CALL(XBT_PUBLIC(MPI_Op), MPI_Op_f2c,(MPI_Fint op));
-MPI_CALL(XBT_PUBLIC(MPI_Fint), MPI_Op_c2f,(MPI_Op op));
-
-MPI_CALL(XBT_PUBLIC(int), MPI_Group_free, (MPI_Group * group));
-MPI_CALL(XBT_PUBLIC(int), MPI_Group_size, (MPI_Group group, int *size));
-MPI_CALL(XBT_PUBLIC(int), MPI_Group_rank, (MPI_Group group, int *rank));
-MPI_CALL(XBT_PUBLIC(int), MPI_Group_translate_ranks, (MPI_Group group1, int n, int *ranks1, MPI_Group group2,
- int *ranks2));
-MPI_CALL(XBT_PUBLIC(int), MPI_Group_compare, (MPI_Group group1, MPI_Group group2, int *result));
-MPI_CALL(XBT_PUBLIC(int), MPI_Group_union, (MPI_Group group1, MPI_Group group2, MPI_Group * newgroup));
-MPI_CALL(XBT_PUBLIC(int), MPI_Group_intersection, (MPI_Group group1, MPI_Group group2, MPI_Group * newgroup));
-MPI_CALL(XBT_PUBLIC(int), MPI_Group_difference, (MPI_Group group1, MPI_Group group2, MPI_Group * newgroup));
-MPI_CALL(XBT_PUBLIC(int), MPI_Group_incl, (MPI_Group group, int n, int *ranks, MPI_Group * newgroup));
-MPI_CALL(XBT_PUBLIC(int), MPI_Group_excl, (MPI_Group group, int n, int *ranks, MPI_Group * newgroup));
-MPI_CALL(XBT_PUBLIC(int), MPI_Group_range_incl, (MPI_Group group, int n, int ranges[][3], MPI_Group * newgroup));
-MPI_CALL(XBT_PUBLIC(int), MPI_Group_range_excl, (MPI_Group group, int n, int ranges[][3], MPI_Group * newgroup));
-MPI_CALL(XBT_PUBLIC(MPI_Group), MPI_Group_f2c,(MPI_Fint group));
-MPI_CALL(XBT_PUBLIC(MPI_Fint), MPI_Group_c2f,(MPI_Group group));
-
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_rank, (MPI_Comm comm, int *rank));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_size, (MPI_Comm comm, int *size));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_get_name, (MPI_Comm comm, char* name, int* len));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_set_name, (MPI_Comm comm, char* name));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_dup, (MPI_Comm comm, MPI_Comm * newcomm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_get_attr, (MPI_Comm comm, int comm_keyval, void *attribute_val, int *flag));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_set_attr, (MPI_Comm comm, int comm_keyval, void *attribute_val));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_delete_attr, (MPI_Comm comm, int comm_keyval));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_create_keyval,(MPI_Comm_copy_attr_function* copy_fn,
- MPI_Comm_delete_attr_function* delete_fn, int* keyval, void* extra_state));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_free_keyval,(int* keyval));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_group, (MPI_Comm comm, MPI_Group * group));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_compare, (MPI_Comm comm1, MPI_Comm comm2, int *result));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_create, (MPI_Comm comm, MPI_Group group, MPI_Comm * newcomm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_create_group, (MPI_Comm comm, MPI_Group group, int tag, MPI_Comm * newcomm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_free, (MPI_Comm * comm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_disconnect, (MPI_Comm * comm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_split, (MPI_Comm comm, int color, int key, MPI_Comm* comm_out));
-MPI_CALL(XBT_PUBLIC(MPI_Comm), MPI_Comm_f2c,(MPI_Fint comm));
-MPI_CALL(XBT_PUBLIC(MPI_Fint), MPI_Comm_c2f,(MPI_Comm comm));
-
-MPI_CALL(XBT_PUBLIC(int), MPI_Send_init, (void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm,
- MPI_Request * request));
-MPI_CALL(XBT_PUBLIC(int), MPI_Recv_init, (void *buf, int count, MPI_Datatype datatype, int src, int tag, MPI_Comm comm,
- MPI_Request * request));
-MPI_CALL(XBT_PUBLIC(int), MPI_Start, (MPI_Request * request));
-MPI_CALL(XBT_PUBLIC(int), MPI_Startall, (int count, MPI_Request * requests));
-MPI_CALL(XBT_PUBLIC(int), MPI_Request_free, (MPI_Request * request));
-MPI_CALL(XBT_PUBLIC(int), MPI_Irecv, (void *buf, int count, MPI_Datatype datatype, int src, int tag, MPI_Comm comm,
- MPI_Request * request));
-MPI_CALL(XBT_PUBLIC(int), MPI_Isend, (void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm,
- MPI_Request * request));
-MPI_CALL(XBT_PUBLIC(int), MPI_Recv, (void *buf, int count, MPI_Datatype datatype, int src, int tag, MPI_Comm comm,
- MPI_Status * status));
-MPI_CALL(XBT_PUBLIC(int), MPI_Send, (void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Ssend, (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Ssend_init, (void* buf, int count, MPI_Datatype datatype, int dest, int tag,
- MPI_Comm comm, MPI_Request* request));
-MPI_CALL(XBT_PUBLIC(int), MPI_Issend, (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm,
- MPI_Request* request));
-MPI_CALL(XBT_PUBLIC(int), MPI_Sendrecv, (void *sendbuf, int sendcount, MPI_Datatype sendtype, int dst, int sendtag,
- void *recvbuf, int recvcount, MPI_Datatype recvtype, int src, int recvtag,
- MPI_Comm comm, MPI_Status * status));
-MPI_CALL(XBT_PUBLIC(int), MPI_Sendrecv_replace, (void *buf, int count, MPI_Datatype datatype, int dst,
- int sendtag, int src, int recvtag, MPI_Comm comm, MPI_Status * status));
-
-MPI_CALL(XBT_PUBLIC(int), MPI_Test, (MPI_Request * request, int *flag, MPI_Status* status));
-MPI_CALL(XBT_PUBLIC(int), MPI_Testany, (int count, MPI_Request requests[], int *index, int *flag, MPI_Status * status));
-MPI_CALL(XBT_PUBLIC(int), MPI_Testall, (int count, MPI_Request* requests, int* flag, MPI_Status* statuses));
-MPI_CALL(XBT_PUBLIC(int), MPI_Testsome, (int incount, MPI_Request requests[], int *outcount, int *indices,
- MPI_Status status[]));
-MPI_CALL(XBT_PUBLIC(int), MPI_Wait, (MPI_Request * request, MPI_Status * status));
-MPI_CALL(XBT_PUBLIC(int), MPI_Waitany, (int count, MPI_Request requests[], int *index, MPI_Status * status));
-MPI_CALL(XBT_PUBLIC(int), MPI_Waitall, (int count, MPI_Request requests[], MPI_Status status[]));
-MPI_CALL(XBT_PUBLIC(int), MPI_Waitsome, (int incount, MPI_Request requests[], int *outcount, int *indices,
- MPI_Status status[]));
-MPI_CALL(XBT_PUBLIC(int), MPI_Iprobe, (int source, int tag, MPI_Comm comm, int* flag, MPI_Status* status));
-MPI_CALL(XBT_PUBLIC(int), MPI_Probe, (int source, int tag, MPI_Comm comm, MPI_Status* status));
-MPI_CALL(XBT_PUBLIC(MPI_Request), MPI_Request_f2c,(MPI_Fint request));
-MPI_CALL(XBT_PUBLIC(MPI_Fint), MPI_Request_c2f,(MPI_Request request));
-
-MPI_CALL(XBT_PUBLIC(int), MPI_Bcast, (void *buf, int count, MPI_Datatype datatype, int root, MPI_Comm comm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Barrier, (MPI_Comm comm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Gather, (void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf,
- int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Gatherv, (void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf,
- int *recvcounts, int *displs, MPI_Datatype recvtype, int root, MPI_Comm comm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Allgather, (void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf,
- int recvcount, MPI_Datatype recvtype, MPI_Comm comm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Allgatherv, (void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf,
- int *recvcounts, int *displs, MPI_Datatype recvtype, MPI_Comm comm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Scatter, (void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf,
- int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Scatterv, (void *sendbuf, int *sendcounts, int *displs, MPI_Datatype sendtype,
- void *recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Reduce, (void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op,
- int root, MPI_Comm comm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Allreduce, (void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op,
- MPI_Comm comm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Scan, (void *sendbuf, void *recvbuf, int count,MPI_Datatype datatype, MPI_Op op,
- MPI_Comm comm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Exscan,(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op,
- MPI_Comm comm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Reduce_scatter, (void *sendbuf, void *recvbuf, int *recvcounts, MPI_Datatype datatype,
- MPI_Op op, MPI_Comm comm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Reduce_scatter_block, (void *sendbuf, void *recvbuf, int recvcount, MPI_Datatype datatype,
- MPI_Op op, MPI_Comm comm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Alltoall, (void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf,
- int recvcount, MPI_Datatype recvtype, MPI_Comm comm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Alltoallv, (void *sendbuf, int *sendcounts, int *senddisps, MPI_Datatype sendtype,
- void *recvbuf, int *recvcounts, int *recvdisps, MPI_Datatype recvtype, MPI_Comm comm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Reduce_local,(void *inbuf, void *inoutbuf, int count, MPI_Datatype datatype, MPI_Op op));
-
-MPI_CALL(XBT_PUBLIC(int), MPI_Info_create,( MPI_Info *info));
-MPI_CALL(XBT_PUBLIC(int), MPI_Info_set,( MPI_Info info, char *key, char *value));
-MPI_CALL(XBT_PUBLIC(int), MPI_Info_get,(MPI_Info info,char *key,int valuelen, char *value, int *flag));
-MPI_CALL(XBT_PUBLIC(int), MPI_Info_free,( MPI_Info *info));
-MPI_CALL(XBT_PUBLIC(int), MPI_Info_delete,( MPI_Info info, char *key));
-MPI_CALL(XBT_PUBLIC(int), MPI_Info_dup,(MPI_Info info, MPI_Info *newinfo));
-MPI_CALL(XBT_PUBLIC(int), MPI_Info_get_nkeys,( MPI_Info info, int *nkeys));
-MPI_CALL(XBT_PUBLIC(int), MPI_Info_get_nthkey,( MPI_Info info, int n, char *key));
-MPI_CALL(XBT_PUBLIC(int), MPI_Info_get_valuelen,( MPI_Info info, char *key, int *valuelen, int *flag));
-MPI_CALL(XBT_PUBLIC(MPI_Info), MPI_Info_f2c,(MPI_Fint info));
-MPI_CALL(XBT_PUBLIC(MPI_Fint), MPI_Info_c2f,(MPI_Info info));
-
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_free,( MPI_Win* win));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_create,( void *base, MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm,
- MPI_Win *win));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_allocate,( MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm, void *base,
- MPI_Win *win));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_create_dynamic,( MPI_Info info, MPI_Comm comm,
- MPI_Win *win));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_attach,(MPI_Win win, void *base, MPI_Aint size));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_detach,(MPI_Win win, void *base));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_set_name,(MPI_Win win, char * name));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_get_name,(MPI_Win win, char * name, int* len));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_set_info,(MPI_Win win, MPI_Info info));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_get_info,(MPI_Win win, MPI_Info* info));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_get_group,(MPI_Win win, MPI_Group * group));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_fence,( int assert, MPI_Win win));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_get_attr, (MPI_Win type, int type_keyval, void *attribute_val, int* flag));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_set_attr, (MPI_Win type, int type_keyval, void *att));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_delete_attr, (MPI_Win type, int comm_keyval));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_create_keyval,(MPI_Win_copy_attr_function* copy_fn,
- MPI_Win_delete_attr_function* delete_fn, int* keyval, void* extra_state));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_free_keyval,(int* keyval));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_complete,(MPI_Win win));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_post,(MPI_Group group, int assert, MPI_Win win));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_start,(MPI_Group group, int assert, MPI_Win win));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_wait,(MPI_Win win));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_lock,(int lock_type, int rank, int assert, MPI_Win win));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_lock_all,(int assert, MPI_Win win));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_unlock,(int rank, MPI_Win win));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_unlock_all,(MPI_Win win));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_flush,(int rank, MPI_Win win));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_flush_local,(int rank, MPI_Win win));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_flush_all,(MPI_Win win));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_flush_local_all,(MPI_Win win));
-MPI_CALL(XBT_PUBLIC(MPI_Win), MPI_Win_f2c,(MPI_Fint win));
-MPI_CALL(XBT_PUBLIC(MPI_Fint), MPI_Win_c2f,(MPI_Win win));
-
-MPI_CALL(XBT_PUBLIC(int), MPI_Get,( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
- MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win));
-MPI_CALL(XBT_PUBLIC(int), MPI_Put,( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
- MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win));
-MPI_CALL(XBT_PUBLIC(int), MPI_Accumulate,( void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
- int target_rank, MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Op op, MPI_Win win));
-MPI_CALL(XBT_PUBLIC(int), MPI_Get_accumulate,( void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
- void* result_addr, int result_count, MPI_Datatype result_datatype, int target_rank, MPI_Aint target_disp,
- int target_count, MPI_Datatype target_datatype, MPI_Op op, MPI_Win win));
-MPI_CALL(XBT_PUBLIC(int), MPI_Rget,( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
- MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win, MPI_Request* request));
-MPI_CALL(XBT_PUBLIC(int), MPI_Rput,( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
- MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win, MPI_Request* request));
-MPI_CALL(XBT_PUBLIC(int), MPI_Raccumulate,( void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
- int target_rank, MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Op op, MPI_Win win, MPI_Request* request));
-MPI_CALL(XBT_PUBLIC(int), MPI_Rget_accumulate,( void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
- void* result_addr, int result_count, MPI_Datatype result_datatype, int target_rank, MPI_Aint target_disp,
- int target_count, MPI_Datatype target_datatype, MPI_Op op, MPI_Win win, MPI_Request* request));
-MPI_CALL(XBT_PUBLIC(int), MPI_Fetch_and_op,( void *origin_addr, void* result_addr, MPI_Datatype datatype,
- int target_rank, MPI_Aint target_disp, MPI_Op op, MPI_Win win));
-MPI_CALL(XBT_PUBLIC(int), MPI_Compare_and_swap, (void *origin_addr, void *compare_addr,
- void *result_addr, MPI_Datatype datatype, int target_rank, MPI_Aint target_disp, MPI_Win win));
-
-MPI_CALL(XBT_PUBLIC(int), MPI_Cart_coords, (MPI_Comm comm, int rank, int maxdims, int* coords));
-MPI_CALL(XBT_PUBLIC(int), MPI_Cart_create, (MPI_Comm comm_old, int ndims, int* dims, int* periods, int reorder,
- MPI_Comm* comm_cart));
-MPI_CALL(XBT_PUBLIC(int), MPI_Cart_get, (MPI_Comm comm, int maxdims, int* dims, int* periods, int* coords));
-MPI_CALL(XBT_PUBLIC(int), MPI_Cart_rank, (MPI_Comm comm, int* coords, int* rank));
-MPI_CALL(XBT_PUBLIC(int), MPI_Cart_shift, (MPI_Comm comm, int direction, int displ, int* source, int* dest));
-MPI_CALL(XBT_PUBLIC(int), MPI_Cart_sub, (MPI_Comm comm, int* remain_dims, MPI_Comm* comm_new));
-MPI_CALL(XBT_PUBLIC(int), MPI_Cartdim_get, (MPI_Comm comm, int* ndims));
-MPI_CALL(XBT_PUBLIC(int), MPI_Dims_create, (int nnodes, int ndims, int* dims));
-
+MPI_CALL(XBT_PUBLIC int, MPI_Init, (int* argc, char*** argv));
+MPI_CALL(XBT_PUBLIC int, MPI_Finalize, (void));
+MPI_CALL(XBT_PUBLIC int, MPI_Finalized, (int* flag));
+MPI_CALL(XBT_PUBLIC int, MPI_Init_thread, (int* argc, char*** argv, int required, int* provided));
+MPI_CALL(XBT_PUBLIC int, MPI_Initialized, (int* flag));
+MPI_CALL(XBT_PUBLIC int, MPI_Query_thread, (int* provided));
+MPI_CALL(XBT_PUBLIC int, MPI_Is_thread_main, (int* flag));
+MPI_CALL(XBT_PUBLIC int, MPI_Get_version, (int* version, int* subversion));
+MPI_CALL(XBT_PUBLIC int, MPI_Get_library_version, (char* version, int* len));
+MPI_CALL(XBT_PUBLIC int, MPI_Get_processor_name, (char* name, int* resultlen));
+MPI_CALL(XBT_PUBLIC int, MPI_Abort, (MPI_Comm comm, int errorcode));
+MPI_CALL(XBT_PUBLIC int, MPI_Alloc_mem, (MPI_Aint size, MPI_Info info, void* baseptr));
+MPI_CALL(XBT_PUBLIC int, MPI_Free_mem, (void* base));
+MPI_CALL(XBT_PUBLIC double, MPI_Wtime, (void));
+MPI_CALL(XBT_PUBLIC double, MPI_Wtick, (void));
+
+MPI_CALL(XBT_PUBLIC int, MPI_Address, (void* location, MPI_Aint* address));
+MPI_CALL(XBT_PUBLIC int, MPI_Get_address, (void* location, MPI_Aint* address));
+MPI_CALL(XBT_PUBLIC int, MPI_Error_class, (int errorcode, int* errorclass));
+
+MPI_CALL(XBT_PUBLIC int, MPI_Attr_delete, (MPI_Comm comm, int keyval));
+MPI_CALL(XBT_PUBLIC int, MPI_Attr_get, (MPI_Comm comm, int keyval, void* attr_value, int* flag));
+MPI_CALL(XBT_PUBLIC int, MPI_Attr_put, (MPI_Comm comm, int keyval, void* attr_value));
+MPI_CALL(XBT_PUBLIC int, MPI_Keyval_create,
+ (MPI_Copy_function * copy_fn, MPI_Delete_function* delete_fn, int* keyval, void* extra_state));
+MPI_CALL(XBT_PUBLIC int, MPI_Keyval_free, (int* keyval));
+
+MPI_CALL(XBT_PUBLIC int, MPI_Type_free, (MPI_Datatype * datatype));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_size, (MPI_Datatype datatype, int* size));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_size_x, (MPI_Datatype datatype, MPI_Count* size));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_get_extent, (MPI_Datatype datatype, MPI_Aint* lb, MPI_Aint* extent));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_get_true_extent, (MPI_Datatype datatype, MPI_Aint* lb, MPI_Aint* extent));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_extent, (MPI_Datatype datatype, MPI_Aint* extent));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_lb, (MPI_Datatype datatype, MPI_Aint* disp));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_ub, (MPI_Datatype datatype, MPI_Aint* disp));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_commit, (MPI_Datatype * datatype));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_hindexed,
+ (int count, int* blocklens, MPI_Aint* indices, MPI_Datatype old_type, MPI_Datatype* newtype));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_create_hindexed,
+ (int count, int* blocklens, MPI_Aint* indices, MPI_Datatype old_type, MPI_Datatype* newtype));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_create_hindexed_block,
+ (int count, int blocklength, MPI_Aint* indices, MPI_Datatype old_type, MPI_Datatype* newtype));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_hvector,
+ (int count, int blocklen, MPI_Aint stride, MPI_Datatype old_type, MPI_Datatype* newtype));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_create_hvector,
+ (int count, int blocklen, MPI_Aint stride, MPI_Datatype old_type, MPI_Datatype* newtype));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_indexed,
+ (int count, int* blocklens, int* indices, MPI_Datatype old_type, MPI_Datatype* newtype));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_create_indexed,
+ (int count, int* blocklens, int* indices, MPI_Datatype old_type, MPI_Datatype* newtype));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_create_indexed_block,
+ (int count, int blocklength, int* indices, MPI_Datatype old_type, MPI_Datatype* newtype));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_struct,
+ (int count, int* blocklens, MPI_Aint* indices, MPI_Datatype* old_types, MPI_Datatype* newtype));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_create_struct,
+ (int count, int* blocklens, MPI_Aint* indices, MPI_Datatype* old_types, MPI_Datatype* newtype));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_vector,
+ (int count, int blocklen, int stride, MPI_Datatype old_type, MPI_Datatype* newtype));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_contiguous, (int count, MPI_Datatype old_type, MPI_Datatype* newtype));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_create_resized,
+ (MPI_Datatype oldtype, MPI_Aint lb, MPI_Aint extent, MPI_Datatype* newtype));
+MPI_CALL(XBT_PUBLIC MPI_Datatype, MPI_Type_f2c, (MPI_Fint datatype));
+MPI_CALL(XBT_PUBLIC MPI_Fint, MPI_Type_c2f, (MPI_Datatype datatype));
+MPI_CALL(XBT_PUBLIC int, MPI_Get_count, (MPI_Status * status, MPI_Datatype datatype, int* count));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_get_attr, (MPI_Datatype type, int type_keyval, void* attribute_val, int* flag));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_set_attr, (MPI_Datatype type, int type_keyval, void* att));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_delete_attr, (MPI_Datatype type, int comm_keyval));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_create_keyval,
+ (MPI_Type_copy_attr_function * copy_fn, MPI_Type_delete_attr_function* delete_fn, int* keyval,
+ void* extra_state));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_free_keyval, (int* keyval));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_dup, (MPI_Datatype datatype, MPI_Datatype* newtype));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_set_name, (MPI_Datatype datatype, char* name));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_get_name, (MPI_Datatype datatype, char* name, int* len));
+
+MPI_CALL(XBT_PUBLIC int, MPI_Pack,
+ (void* inbuf, int incount, MPI_Datatype type, void* outbuf, int outcount, int* position, MPI_Comm comm));
+MPI_CALL(XBT_PUBLIC int, MPI_Pack_size, (int incount, MPI_Datatype datatype, MPI_Comm comm, int* size));
+MPI_CALL(XBT_PUBLIC int, MPI_Unpack,
+ (void* inbuf, int insize, int* position, void* outbuf, int outcount, MPI_Datatype type, MPI_Comm comm));
+
+MPI_CALL(XBT_PUBLIC int, MPI_Op_create, (MPI_User_function * function, int commute, MPI_Op* op));
+MPI_CALL(XBT_PUBLIC int, MPI_Op_free, (MPI_Op * op));
+MPI_CALL(XBT_PUBLIC int, MPI_Op_commutative, (MPI_Op op, int* commute));
+MPI_CALL(XBT_PUBLIC MPI_Op, MPI_Op_f2c, (MPI_Fint op));
+MPI_CALL(XBT_PUBLIC MPI_Fint, MPI_Op_c2f, (MPI_Op op));
+
+MPI_CALL(XBT_PUBLIC int, MPI_Group_free, (MPI_Group * group));
+MPI_CALL(XBT_PUBLIC int, MPI_Group_size, (MPI_Group group, int* size));
+MPI_CALL(XBT_PUBLIC int, MPI_Group_rank, (MPI_Group group, int* rank));
+MPI_CALL(XBT_PUBLIC int, MPI_Group_translate_ranks,
+ (MPI_Group group1, int n, int* ranks1, MPI_Group group2, int* ranks2));
+MPI_CALL(XBT_PUBLIC int, MPI_Group_compare, (MPI_Group group1, MPI_Group group2, int* result));
+MPI_CALL(XBT_PUBLIC int, MPI_Group_union, (MPI_Group group1, MPI_Group group2, MPI_Group* newgroup));
+MPI_CALL(XBT_PUBLIC int, MPI_Group_intersection, (MPI_Group group1, MPI_Group group2, MPI_Group* newgroup));
+MPI_CALL(XBT_PUBLIC int, MPI_Group_difference, (MPI_Group group1, MPI_Group group2, MPI_Group* newgroup));
+MPI_CALL(XBT_PUBLIC int, MPI_Group_incl, (MPI_Group group, int n, int* ranks, MPI_Group* newgroup));
+MPI_CALL(XBT_PUBLIC int, MPI_Group_excl, (MPI_Group group, int n, int* ranks, MPI_Group* newgroup));
+MPI_CALL(XBT_PUBLIC int, MPI_Group_range_incl, (MPI_Group group, int n, int ranges[][3], MPI_Group* newgroup));
+MPI_CALL(XBT_PUBLIC int, MPI_Group_range_excl, (MPI_Group group, int n, int ranges[][3], MPI_Group* newgroup));
+MPI_CALL(XBT_PUBLIC MPI_Group, MPI_Group_f2c, (MPI_Fint group));
+MPI_CALL(XBT_PUBLIC MPI_Fint, MPI_Group_c2f, (MPI_Group group));
+
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_rank, (MPI_Comm comm, int* rank));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_size, (MPI_Comm comm, int* size));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_get_name, (MPI_Comm comm, char* name, int* len));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_set_name, (MPI_Comm comm, char* name));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_dup, (MPI_Comm comm, MPI_Comm* newcomm));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_get_attr, (MPI_Comm comm, int comm_keyval, void* attribute_val, int* flag));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_set_attr, (MPI_Comm comm, int comm_keyval, void* attribute_val));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_delete_attr, (MPI_Comm comm, int comm_keyval));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_create_keyval,
+ (MPI_Comm_copy_attr_function * copy_fn, MPI_Comm_delete_attr_function* delete_fn, int* keyval,
+ void* extra_state));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_free_keyval, (int* keyval));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_group, (MPI_Comm comm, MPI_Group* group));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_compare, (MPI_Comm comm1, MPI_Comm comm2, int* result));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_create, (MPI_Comm comm, MPI_Group group, MPI_Comm* newcomm));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_create_group, (MPI_Comm comm, MPI_Group group, int tag, MPI_Comm* newcomm));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_free, (MPI_Comm * comm));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_disconnect, (MPI_Comm * comm));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_split, (MPI_Comm comm, int color, int key, MPI_Comm* comm_out));
+MPI_CALL(XBT_PUBLIC MPI_Comm, MPI_Comm_f2c, (MPI_Fint comm));
+MPI_CALL(XBT_PUBLIC MPI_Fint, MPI_Comm_c2f, (MPI_Comm comm));
+
+MPI_CALL(XBT_PUBLIC int, MPI_Send_init,
+ (void* buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm, MPI_Request* request));
+MPI_CALL(XBT_PUBLIC int, MPI_Recv_init,
+ (void* buf, int count, MPI_Datatype datatype, int src, int tag, MPI_Comm comm, MPI_Request* request));
+MPI_CALL(XBT_PUBLIC int, MPI_Start, (MPI_Request * request));
+MPI_CALL(XBT_PUBLIC int, MPI_Startall, (int count, MPI_Request* requests));
+MPI_CALL(XBT_PUBLIC int, MPI_Request_free, (MPI_Request * request));
+MPI_CALL(XBT_PUBLIC int, MPI_Irecv,
+ (void* buf, int count, MPI_Datatype datatype, int src, int tag, MPI_Comm comm, MPI_Request* request));
+MPI_CALL(XBT_PUBLIC int, MPI_Isend,
+ (void* buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm, MPI_Request* request));
+MPI_CALL(XBT_PUBLIC int, MPI_Recv,
+ (void* buf, int count, MPI_Datatype datatype, int src, int tag, MPI_Comm comm, MPI_Status* status));
+MPI_CALL(XBT_PUBLIC int, MPI_Send, (void* buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm));
+MPI_CALL(XBT_PUBLIC int, MPI_Ssend, (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm));
+MPI_CALL(XBT_PUBLIC int, MPI_Ssend_init,
+ (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request));
+MPI_CALL(XBT_PUBLIC int, MPI_Issend,
+ (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request));
+MPI_CALL(XBT_PUBLIC int, MPI_Sendrecv,
+ (void* sendbuf, int sendcount, MPI_Datatype sendtype, int dst, int sendtag, void* recvbuf, int recvcount,
+ MPI_Datatype recvtype, int src, int recvtag, MPI_Comm comm, MPI_Status* status));
+MPI_CALL(XBT_PUBLIC int, MPI_Sendrecv_replace, (void* buf, int count, MPI_Datatype datatype, int dst, int sendtag,
+ int src, int recvtag, MPI_Comm comm, MPI_Status* status));
+
+MPI_CALL(XBT_PUBLIC int, MPI_Test, (MPI_Request * request, int* flag, MPI_Status* status));
+MPI_CALL(XBT_PUBLIC int, MPI_Testany, (int count, MPI_Request requests[], int* index, int* flag, MPI_Status* status));
+MPI_CALL(XBT_PUBLIC int, MPI_Testall, (int count, MPI_Request* requests, int* flag, MPI_Status* statuses));
+MPI_CALL(XBT_PUBLIC int, MPI_Testsome,
+ (int incount, MPI_Request requests[], int* outcount, int* indices, MPI_Status status[]));
+MPI_CALL(XBT_PUBLIC int, MPI_Wait, (MPI_Request * request, MPI_Status* status));
+MPI_CALL(XBT_PUBLIC int, MPI_Waitany, (int count, MPI_Request requests[], int* index, MPI_Status* status));
+MPI_CALL(XBT_PUBLIC int, MPI_Waitall, (int count, MPI_Request requests[], MPI_Status status[]));
+MPI_CALL(XBT_PUBLIC int, MPI_Waitsome,
+ (int incount, MPI_Request requests[], int* outcount, int* indices, MPI_Status status[]));
+MPI_CALL(XBT_PUBLIC int, MPI_Iprobe, (int source, int tag, MPI_Comm comm, int* flag, MPI_Status* status));
+MPI_CALL(XBT_PUBLIC int, MPI_Probe, (int source, int tag, MPI_Comm comm, MPI_Status* status));
+MPI_CALL(XBT_PUBLIC MPI_Request, MPI_Request_f2c, (MPI_Fint request));
+MPI_CALL(XBT_PUBLIC MPI_Fint, MPI_Request_c2f, (MPI_Request request));
+
+MPI_CALL(XBT_PUBLIC int, MPI_Bcast, (void* buf, int count, MPI_Datatype datatype, int root, MPI_Comm comm));
+MPI_CALL(XBT_PUBLIC int, MPI_Barrier, (MPI_Comm comm));
+MPI_CALL(XBT_PUBLIC int, MPI_Gather, (void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf, int recvcount,
+ MPI_Datatype recvtype, int root, MPI_Comm comm));
+MPI_CALL(XBT_PUBLIC int, MPI_Gatherv, (void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf,
+ int* recvcounts, int* displs, MPI_Datatype recvtype, int root, MPI_Comm comm));
+MPI_CALL(XBT_PUBLIC int, MPI_Allgather, (void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf,
+ int recvcount, MPI_Datatype recvtype, MPI_Comm comm));
+MPI_CALL(XBT_PUBLIC int, MPI_Allgatherv, (void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf,
+ int* recvcounts, int* displs, MPI_Datatype recvtype, MPI_Comm comm));
+MPI_CALL(XBT_PUBLIC int, MPI_Scatter, (void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf,
+ int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm));
+MPI_CALL(XBT_PUBLIC int, MPI_Scatterv, (void* sendbuf, int* sendcounts, int* displs, MPI_Datatype sendtype,
+ void* recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm));
+MPI_CALL(XBT_PUBLIC int, MPI_Reduce,
+ (void* sendbuf, void* recvbuf, int count, MPI_Datatype datatype, MPI_Op op, int root, MPI_Comm comm));
+MPI_CALL(XBT_PUBLIC int, MPI_Allreduce,
+ (void* sendbuf, void* recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm));
+MPI_CALL(XBT_PUBLIC int, MPI_Scan,
+ (void* sendbuf, void* recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm));
+MPI_CALL(XBT_PUBLIC int, MPI_Exscan,
+ (void* sendbuf, void* recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm));
+MPI_CALL(XBT_PUBLIC int, MPI_Reduce_scatter,
+ (void* sendbuf, void* recvbuf, int* recvcounts, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm));
+MPI_CALL(XBT_PUBLIC int, MPI_Reduce_scatter_block,
+ (void* sendbuf, void* recvbuf, int recvcount, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm));
+MPI_CALL(XBT_PUBLIC int, MPI_Alltoall, (void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf,
+ int recvcount, MPI_Datatype recvtype, MPI_Comm comm));
+MPI_CALL(XBT_PUBLIC int, MPI_Alltoallv,
+ (void* sendbuf, int* sendcounts, int* senddisps, MPI_Datatype sendtype, void* recvbuf, int* recvcounts,
+ int* recvdisps, MPI_Datatype recvtype, MPI_Comm comm));
+MPI_CALL(XBT_PUBLIC int, MPI_Reduce_local, (void* inbuf, void* inoutbuf, int count, MPI_Datatype datatype, MPI_Op op));
+
+MPI_CALL(XBT_PUBLIC int, MPI_Info_create, (MPI_Info * info));
+MPI_CALL(XBT_PUBLIC int, MPI_Info_set, (MPI_Info info, char* key, char* value));
+MPI_CALL(XBT_PUBLIC int, MPI_Info_get, (MPI_Info info, char* key, int valuelen, char* value, int* flag));
+MPI_CALL(XBT_PUBLIC int, MPI_Info_free, (MPI_Info * info));
+MPI_CALL(XBT_PUBLIC int, MPI_Info_delete, (MPI_Info info, char* key));
+MPI_CALL(XBT_PUBLIC int, MPI_Info_dup, (MPI_Info info, MPI_Info* newinfo));
+MPI_CALL(XBT_PUBLIC int, MPI_Info_get_nkeys, (MPI_Info info, int* nkeys));
+MPI_CALL(XBT_PUBLIC int, MPI_Info_get_nthkey, (MPI_Info info, int n, char* key));
+MPI_CALL(XBT_PUBLIC int, MPI_Info_get_valuelen, (MPI_Info info, char* key, int* valuelen, int* flag));
+MPI_CALL(XBT_PUBLIC MPI_Info, MPI_Info_f2c, (MPI_Fint info));
+MPI_CALL(XBT_PUBLIC MPI_Fint, MPI_Info_c2f, (MPI_Info info));
+
+MPI_CALL(XBT_PUBLIC int, MPI_Win_free, (MPI_Win * win));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_create,
+ (void* base, MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm, MPI_Win* win));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_allocate,
+ (MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm, void* base, MPI_Win* win));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_create_dynamic, (MPI_Info info, MPI_Comm comm, MPI_Win* win));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_attach, (MPI_Win win, void* base, MPI_Aint size));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_detach, (MPI_Win win, void* base));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_set_name, (MPI_Win win, char* name));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_get_name, (MPI_Win win, char* name, int* len));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_set_info, (MPI_Win win, MPI_Info info));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_get_info, (MPI_Win win, MPI_Info* info));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_get_group, (MPI_Win win, MPI_Group* group));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_fence, (int assert, MPI_Win win));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_get_attr, (MPI_Win type, int type_keyval, void* attribute_val, int* flag));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_set_attr, (MPI_Win type, int type_keyval, void* att));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_delete_attr, (MPI_Win type, int comm_keyval));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_create_keyval,
+ (MPI_Win_copy_attr_function * copy_fn, MPI_Win_delete_attr_function* delete_fn, int* keyval,
+ void* extra_state));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_free_keyval, (int* keyval));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_complete, (MPI_Win win));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_post, (MPI_Group group, int assert, MPI_Win win));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_start, (MPI_Group group, int assert, MPI_Win win));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_wait, (MPI_Win win));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_lock, (int lock_type, int rank, int assert, MPI_Win win));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_lock_all, (int assert, MPI_Win win));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_unlock, (int rank, MPI_Win win));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_unlock_all, (MPI_Win win));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_flush, (int rank, MPI_Win win));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_flush_local, (int rank, MPI_Win win));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_flush_all, (MPI_Win win));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_flush_local_all, (MPI_Win win));
+MPI_CALL(XBT_PUBLIC MPI_Win, MPI_Win_f2c, (MPI_Fint win));
+MPI_CALL(XBT_PUBLIC MPI_Fint, MPI_Win_c2f, (MPI_Win win));
+
+MPI_CALL(XBT_PUBLIC int, MPI_Get, (void* origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
+ MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win));
+MPI_CALL(XBT_PUBLIC int, MPI_Put, (void* origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
+ MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win));
+MPI_CALL(XBT_PUBLIC int, MPI_Accumulate,
+ (void* origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank, MPI_Aint target_disp,
+ int target_count, MPI_Datatype target_datatype, MPI_Op op, MPI_Win win));
+MPI_CALL(XBT_PUBLIC int, MPI_Get_accumulate,
+ (void* origin_addr, int origin_count, MPI_Datatype origin_datatype, void* result_addr, int result_count,
+ MPI_Datatype result_datatype, int target_rank, MPI_Aint target_disp, int target_count,
+ MPI_Datatype target_datatype, MPI_Op op, MPI_Win win));
+MPI_CALL(XBT_PUBLIC int, MPI_Rget,
+ (void* origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank, MPI_Aint target_disp,
+ int target_count, MPI_Datatype target_datatype, MPI_Win win, MPI_Request* request));
+MPI_CALL(XBT_PUBLIC int, MPI_Rput,
+ (void* origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank, MPI_Aint target_disp,
+ int target_count, MPI_Datatype target_datatype, MPI_Win win, MPI_Request* request));
+MPI_CALL(XBT_PUBLIC int, MPI_Raccumulate,
+ (void* origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank, MPI_Aint target_disp,
+ int target_count, MPI_Datatype target_datatype, MPI_Op op, MPI_Win win, MPI_Request* request));
+MPI_CALL(XBT_PUBLIC int, MPI_Rget_accumulate,
+ (void* origin_addr, int origin_count, MPI_Datatype origin_datatype, void* result_addr, int result_count,
+ MPI_Datatype result_datatype, int target_rank, MPI_Aint target_disp, int target_count,
+ MPI_Datatype target_datatype, MPI_Op op, MPI_Win win, MPI_Request* request));
+MPI_CALL(XBT_PUBLIC int, MPI_Fetch_and_op, (void* origin_addr, void* result_addr, MPI_Datatype datatype,
+ int target_rank, MPI_Aint target_disp, MPI_Op op, MPI_Win win));
+MPI_CALL(XBT_PUBLIC int, MPI_Compare_and_swap,
+ (void* origin_addr, void* compare_addr, void* result_addr, MPI_Datatype datatype, int target_rank,
+ MPI_Aint target_disp, MPI_Win win));
+
+MPI_CALL(XBT_PUBLIC int, MPI_Cart_coords, (MPI_Comm comm, int rank, int maxdims, int* coords));
+MPI_CALL(XBT_PUBLIC int, MPI_Cart_create,
+ (MPI_Comm comm_old, int ndims, int* dims, int* periods, int reorder, MPI_Comm* comm_cart));
+MPI_CALL(XBT_PUBLIC int, MPI_Cart_get, (MPI_Comm comm, int maxdims, int* dims, int* periods, int* coords));
+MPI_CALL(XBT_PUBLIC int, MPI_Cart_rank, (MPI_Comm comm, int* coords, int* rank));
+MPI_CALL(XBT_PUBLIC int, MPI_Cart_shift, (MPI_Comm comm, int direction, int displ, int* source, int* dest));
+MPI_CALL(XBT_PUBLIC int, MPI_Cart_sub, (MPI_Comm comm, int* remain_dims, MPI_Comm* comm_new));
+MPI_CALL(XBT_PUBLIC int, MPI_Cartdim_get, (MPI_Comm comm, int* ndims));
+MPI_CALL(XBT_PUBLIC int, MPI_Dims_create, (int nnodes, int ndims, int* dims));
//FIXME: these are not yet implemented
XBT_PUBLIC_DATA(MPI_Errhandler*) MPI_ERRORS_ARE_FATAL;
XBT_PUBLIC_DATA(MPI_Errhandler*) MPI_ERRHANDLER_NULL;
-MPI_CALL(XBT_PUBLIC(MPI_Errhandler), MPI_Errhandler_f2c,(MPI_Fint errhandler));
-MPI_CALL(XBT_PUBLIC(MPI_Fint), MPI_Errhandler_c2f,(MPI_Errhandler errhandler));
-MPI_CALL(XBT_PUBLIC(int), MPI_Cart_map, (MPI_Comm comm_old, int ndims, int* dims, int* periods, int* newrank));
-MPI_CALL(XBT_PUBLIC(int), MPI_Graph_create, (MPI_Comm comm_old, int nnodes, int* index, int* edges, int reorder,
- MPI_Comm* comm_graph));
-MPI_CALL(XBT_PUBLIC(int), MPI_Graph_get, (MPI_Comm comm, int maxindex, int maxedges, int* index, int* edges));
-MPI_CALL(XBT_PUBLIC(int), MPI_Graph_map, (MPI_Comm comm_old, int nnodes, int* index, int* edges, int* newrank));
-MPI_CALL(XBT_PUBLIC(int), MPI_Graph_neighbors, (MPI_Comm comm, int rank, int maxneighbors, int* neighbors));
-MPI_CALL(XBT_PUBLIC(int), MPI_Graph_neighbors_count, (MPI_Comm comm, int rank, int* nneighbors));
-MPI_CALL(XBT_PUBLIC(int), MPI_Graphdims_get, (MPI_Comm comm, int* nnodes, int* nedges));
-MPI_CALL(XBT_PUBLIC(int), MPI_Topo_test, (MPI_Comm comm, int* top_type));
-MPI_CALL(XBT_PUBLIC(int), MPI_Errhandler_create, (MPI_Handler_function* function, MPI_Errhandler* errhandler));
-MPI_CALL(XBT_PUBLIC(int), MPI_Errhandler_free, (MPI_Errhandler* errhandler));
-MPI_CALL(XBT_PUBLIC(int), MPI_Errhandler_get, (MPI_Comm comm, MPI_Errhandler* errhandler));
-MPI_CALL(XBT_PUBLIC(int), MPI_Error_string, (int errorcode, char* string, int* resultlen));
-MPI_CALL(XBT_PUBLIC(int), MPI_Errhandler_set, (MPI_Comm comm, MPI_Errhandler errhandler));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_set_errhandler, (MPI_Comm comm, MPI_Errhandler errhandler));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_get_errhandler, (MPI_Comm comm, MPI_Errhandler *errhandler));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_create_errhandler,( MPI_Comm_errhandler_fn *function, MPI_Errhandler *errhandler));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_call_errhandler,(MPI_Comm comm,int errorcode));
-MPI_CALL(XBT_PUBLIC(int), MPI_Add_error_class,( int *errorclass));
-MPI_CALL(XBT_PUBLIC(int), MPI_Add_error_code,( int errorclass, int *errorcode));
-MPI_CALL(XBT_PUBLIC(int), MPI_Add_error_string,( int errorcode, char *string));
-MPI_CALL(XBT_PUBLIC(int), MPI_Cancel, (MPI_Request* request));
-MPI_CALL(XBT_PUBLIC(int), MPI_Buffer_attach, (void* buffer, int size));
-MPI_CALL(XBT_PUBLIC(int), MPI_Buffer_detach, (void* buffer, int* size));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_test_inter, (MPI_Comm comm, int* flag));
-MPI_CALL(XBT_PUBLIC(int), MPI_Intercomm_create, (MPI_Comm local_comm, int local_leader, MPI_Comm peer_comm,
- int remote_leader, int tag, MPI_Comm* comm_out));
-MPI_CALL(XBT_PUBLIC(int), MPI_Intercomm_merge, (MPI_Comm comm, int high, MPI_Comm* comm_out));
-MPI_CALL(XBT_PUBLIC(int), MPI_Bsend, (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Bsend_init, (void* buf, int count, MPI_Datatype datatype, int dest, int tag,
- MPI_Comm comm, MPI_Request* request));
-MPI_CALL(XBT_PUBLIC(int), MPI_Ibsend, (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm,
- MPI_Request* request));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_remote_group, (MPI_Comm comm, MPI_Group* group));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_remote_size, (MPI_Comm comm, int* size));
-MPI_CALL(XBT_PUBLIC(int), MPI_Rsend, (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Rsend_init, (void* buf, int count, MPI_Datatype datatype, int dest, int tag,
- MPI_Comm comm, MPI_Request* request));
-MPI_CALL(XBT_PUBLIC(int), MPI_Irsend, (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm,
- MPI_Request* request));
-MPI_CALL(XBT_PUBLIC(int), MPI_Test_cancelled, (MPI_Status* status, int* flag));
-MPI_CALL(XBT_PUBLIC(int), MPI_Get_elements, (MPI_Status* status, MPI_Datatype datatype, int* elements));
-MPI_CALL(XBT_PUBLIC(int), MPI_Pcontrol, (const int level, ... ));
-
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_set_errhandler, (MPI_Win win, MPI_Errhandler errhandler));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_get_envelope,(MPI_Datatype datatype,int *num_integers,int *num_addresses,
- int *num_datatypes, int *combiner));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_get_contents,(MPI_Datatype datatype, int max_integers, int max_addresses,
- int max_datatypes, int* array_of_integers, MPI_Aint* array_of_addresses,
- MPI_Datatype *array_of_datatypes));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_create_darray,(int size, int rank, int ndims, int* array_of_gsizes,
- int* array_of_distribs, int* array_of_dargs, int* array_of_psizes,
- int order, MPI_Datatype oldtype, MPI_Datatype *newtype));
-MPI_CALL(XBT_PUBLIC(int), MPI_Pack_external_size, (char *datarep, int incount, MPI_Datatype datatype, MPI_Aint *size));
-MPI_CALL(XBT_PUBLIC(int), MPI_Pack_external, (char *datarep, void *inbuf, int incount, MPI_Datatype datatype,
- void *outbuf, MPI_Aint outcount, MPI_Aint *position));
-MPI_CALL(XBT_PUBLIC(int), MPI_Unpack_external, (char *datarep, void *inbuf, MPI_Aint insize, MPI_Aint *position,
- void *outbuf, int outcount, MPI_Datatype datatype));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_create_subarray,(int ndims,int *array_of_sizes, int *array_of_subsizes,
- int *array_of_starts, int order, MPI_Datatype oldtype, MPI_Datatype *newtype));
-MPI_CALL(XBT_PUBLIC(int), MPI_Type_match_size,(int typeclass,int size,MPI_Datatype *datatype));
-MPI_CALL(XBT_PUBLIC(int), MPI_Alltoallw, ( void *sendbuf, int *sendcnts, int *sdispls, MPI_Datatype *sendtypes,
- void *recvbuf, int *recvcnts, int *rdispls, MPI_Datatype *recvtypes, MPI_Comm comm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_set_info, (MPI_Comm comm, MPI_Info info));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_get_info, (MPI_Comm comm, MPI_Info* info));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_dup_with_info,(MPI_Comm comm, MPI_Info info, MPI_Comm * newcomm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_split_type,(MPI_Comm comm, int split_type, int key, MPI_Info info,
- MPI_Comm *newcomm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_connect,(char *port_name, MPI_Info info, int root, MPI_Comm comm,
- MPI_Comm *newcomm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Request_get_status,( MPI_Request request, int *flag, MPI_Status *status));
-MPI_CALL(XBT_PUBLIC(int), MPI_Grequest_start,(MPI_Grequest_query_function *query_fn,
- MPI_Grequest_free_function *free_fn,
- MPI_Grequest_cancel_function *cancel_fn,
- void *extra_state, MPI_Request *request));
-MPI_CALL(XBT_PUBLIC(int), MPI_Grequest_complete,( MPI_Request request));
-MPI_CALL(XBT_PUBLIC(int), MPI_Status_set_cancelled,(MPI_Status *status,int flag));
-MPI_CALL(XBT_PUBLIC(int), MPI_Status_set_elements,( MPI_Status *status, MPI_Datatype datatype, int count));
-MPI_CALL(XBT_PUBLIC(int), MPI_Unpublish_name,( char *service_name, MPI_Info info, char *port_name));
-MPI_CALL(XBT_PUBLIC(int), MPI_Publish_name,( char *service_name, MPI_Info info, char *port_name));
-MPI_CALL(XBT_PUBLIC(int), MPI_Lookup_name,( char *service_name, MPI_Info info, char *port_name));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_join,( int fd, MPI_Comm *intercomm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Open_port,( MPI_Info info, char *port_name));
-MPI_CALL(XBT_PUBLIC(int), MPI_Close_port,( char *port_name));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_accept,(char *port_name, MPI_Info info, int root, MPI_Comm comm, MPI_Comm *newcomm));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_spawn,(char *command, char **argv, int maxprocs, MPI_Info info, int root,
- MPI_Comm comm, MPI_Comm *intercomm, int* array_of_errcodes));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_spawn_multiple,(int count, char **array_of_commands, char*** array_of_argv,
- int* array_of_maxprocs, MPI_Info* array_of_info, int root,
- MPI_Comm comm, MPI_Comm *intercomm, int* array_of_errcodes));
-MPI_CALL(XBT_PUBLIC(int), MPI_Comm_get_parent,( MPI_Comm *parent));
-MPI_CALL(XBT_PUBLIC(int), MPI_Win_test,(MPI_Win win, int *flag));
-
-MPI_CALL(XBT_PUBLIC(MPI_Fint), MPI_File_c2f,(MPI_File file));
-MPI_CALL(XBT_PUBLIC(MPI_File), MPI_File_f2c,(MPI_Fint file));
-MPI_CALL(XBT_PUBLIC(int), MPI_Register_datarep,(char *datarep, MPI_Datarep_conversion_function *read_conversion_fn, MPI_Datarep_conversion_function *write_conversion_fn, MPI_Datarep_extent_function *dtype_file_extent_fn, void *extra_state));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_call_errhandler,(MPI_File fh, int errorcode));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_create_errhandler,(MPI_File_errhandler_function *function, MPI_Errhandler *errhandler));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_set_errhandler,( MPI_File file, MPI_Errhandler errhandler));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_get_errhandler,( MPI_File file, MPI_Errhandler *errhandler));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_open,(MPI_Comm comm, char *filename, int amode, MPI_Info info, MPI_File *fh));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_close,(MPI_File *fh));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_delete,(char *filename, MPI_Info info));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_set_size,(MPI_File fh, MPI_Offset size));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_preallocate,(MPI_File fh, MPI_Offset size));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_get_size,(MPI_File fh, MPI_Offset *size));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_get_group,(MPI_File fh, MPI_Group *group));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_get_amode,(MPI_File fh, int *amode));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_set_info,(MPI_File fh, MPI_Info info));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_get_info,(MPI_File fh, MPI_Info *info_used));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_set_view,(MPI_File fh, MPI_Offset disp, MPI_Datatype etype, MPI_Datatype filetype, char *datarep, MPI_Info info));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_get_view,(MPI_File fh, MPI_Offset *disp, MPI_Datatype *etype, MPI_Datatype *filetype, char *datarep));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_read_at,(MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype, MPI_Status *status));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_read_at_all,(MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype, MPI_Status *status));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_write_at,(MPI_File fh, MPI_Offset offset, void *buf,int count, MPI_Datatype datatype, MPI_Status *status));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_write_at_all,(MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype, MPI_Status *status));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_iread_at,(MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype, MPI_Request *request));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_iwrite_at,(MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype, MPI_Request *request));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_iread_at_all,(MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype, MPI_Request *request));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_iwrite_at_all,(MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype, MPI_Request *request));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_read,(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_read_all,(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_write,(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_write_all,(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_iread,(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Request *request));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_iwrite,(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Request *request));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_iread_all,(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Request *request));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_iwrite_all,(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Request *request));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_seek,(MPI_File fh, MPI_Offset offset, int whenace));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_get_position,(MPI_File fh, MPI_Offset *offset));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_get_byte_offset,(MPI_File fh, MPI_Offset offset, MPI_Offset *disp));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_read_shared,(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_write_shared,(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_iread_shared,(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Request *request));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_iwrite_shared,(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Request *request));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_read_ordered,(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_write_ordered,(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_seek_shared,(MPI_File fh, MPI_Offset offset, int whence));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_get_position_shared,(MPI_File fh, MPI_Offset *offset));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_read_at_all_begin,(MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_read_at_all_end,(MPI_File fh, void *buf, MPI_Status *status));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_write_at_all_begin,(MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_write_at_all_end,(MPI_File fh, void *buf, MPI_Status *status));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_read_all_begin,(MPI_File fh, void *buf, int count, MPI_Datatype datatype));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_read_all_end,(MPI_File fh, void *buf, MPI_Status *status));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_write_all_begin,(MPI_File fh, void *buf, int count, MPI_Datatype datatype));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_write_all_end,(MPI_File fh, void *buf, MPI_Status *status));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_read_ordered_begin,(MPI_File fh, void *buf, int count, MPI_Datatype datatype));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_read_ordered_end,(MPI_File fh, void *buf, MPI_Status *status));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_write_ordered_begin,(MPI_File fh, void *buf, int count, MPI_Datatype datatype));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_write_ordered_end,(MPI_File fh, void *buf, MPI_Status *status));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_get_type_extent,(MPI_File fh, MPI_Datatype datatype, MPI_Aint *extent));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_set_atomicity,(MPI_File fh, int flag));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_get_atomicity,(MPI_File fh, int *flag));
-MPI_CALL(XBT_PUBLIC(int), MPI_File_sync,(MPI_File fh));
-
+MPI_CALL(XBT_PUBLIC MPI_Errhandler, MPI_Errhandler_f2c, (MPI_Fint errhandler));
+MPI_CALL(XBT_PUBLIC MPI_Fint, MPI_Errhandler_c2f, (MPI_Errhandler errhandler));
+MPI_CALL(XBT_PUBLIC int, MPI_Cart_map, (MPI_Comm comm_old, int ndims, int* dims, int* periods, int* newrank));
+MPI_CALL(XBT_PUBLIC int, MPI_Graph_create,
+ (MPI_Comm comm_old, int nnodes, int* index, int* edges, int reorder, MPI_Comm* comm_graph));
+MPI_CALL(XBT_PUBLIC int, MPI_Graph_get, (MPI_Comm comm, int maxindex, int maxedges, int* index, int* edges));
+MPI_CALL(XBT_PUBLIC int, MPI_Graph_map, (MPI_Comm comm_old, int nnodes, int* index, int* edges, int* newrank));
+MPI_CALL(XBT_PUBLIC int, MPI_Graph_neighbors, (MPI_Comm comm, int rank, int maxneighbors, int* neighbors));
+MPI_CALL(XBT_PUBLIC int, MPI_Graph_neighbors_count, (MPI_Comm comm, int rank, int* nneighbors));
+MPI_CALL(XBT_PUBLIC int, MPI_Graphdims_get, (MPI_Comm comm, int* nnodes, int* nedges));
+MPI_CALL(XBT_PUBLIC int, MPI_Topo_test, (MPI_Comm comm, int* top_type));
+MPI_CALL(XBT_PUBLIC int, MPI_Errhandler_create, (MPI_Handler_function * function, MPI_Errhandler* errhandler));
+MPI_CALL(XBT_PUBLIC int, MPI_Errhandler_free, (MPI_Errhandler * errhandler));
+MPI_CALL(XBT_PUBLIC int, MPI_Errhandler_get, (MPI_Comm comm, MPI_Errhandler* errhandler));
+MPI_CALL(XBT_PUBLIC int, MPI_Error_string, (int errorcode, char* string, int* resultlen));
+MPI_CALL(XBT_PUBLIC int, MPI_Errhandler_set, (MPI_Comm comm, MPI_Errhandler errhandler));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_set_errhandler, (MPI_Comm comm, MPI_Errhandler errhandler));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_get_errhandler, (MPI_Comm comm, MPI_Errhandler* errhandler));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_create_errhandler, (MPI_Comm_errhandler_fn * function, MPI_Errhandler* errhandler));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_call_errhandler, (MPI_Comm comm, int errorcode));
+MPI_CALL(XBT_PUBLIC int, MPI_Add_error_class, (int* errorclass));
+MPI_CALL(XBT_PUBLIC int, MPI_Add_error_code, (int errorclass, int* errorcode));
+MPI_CALL(XBT_PUBLIC int, MPI_Add_error_string, (int errorcode, char* string));
+MPI_CALL(XBT_PUBLIC int, MPI_Cancel, (MPI_Request * request));
+MPI_CALL(XBT_PUBLIC int, MPI_Buffer_attach, (void* buffer, int size));
+MPI_CALL(XBT_PUBLIC int, MPI_Buffer_detach, (void* buffer, int* size));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_test_inter, (MPI_Comm comm, int* flag));
+MPI_CALL(XBT_PUBLIC int, MPI_Intercomm_create,
+ (MPI_Comm local_comm, int local_leader, MPI_Comm peer_comm, int remote_leader, int tag, MPI_Comm* comm_out));
+MPI_CALL(XBT_PUBLIC int, MPI_Intercomm_merge, (MPI_Comm comm, int high, MPI_Comm* comm_out));
+MPI_CALL(XBT_PUBLIC int, MPI_Bsend, (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm));
+MPI_CALL(XBT_PUBLIC int, MPI_Bsend_init,
+ (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request));
+MPI_CALL(XBT_PUBLIC int, MPI_Ibsend,
+ (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_remote_group, (MPI_Comm comm, MPI_Group* group));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_remote_size, (MPI_Comm comm, int* size));
+MPI_CALL(XBT_PUBLIC int, MPI_Rsend, (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm));
+MPI_CALL(XBT_PUBLIC int, MPI_Rsend_init,
+ (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request));
+MPI_CALL(XBT_PUBLIC int, MPI_Irsend,
+ (void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request* request));
+MPI_CALL(XBT_PUBLIC int, MPI_Test_cancelled, (MPI_Status * status, int* flag));
+MPI_CALL(XBT_PUBLIC int, MPI_Get_elements, (MPI_Status * status, MPI_Datatype datatype, int* elements));
+MPI_CALL(XBT_PUBLIC int, MPI_Pcontrol, (const int level, ...));
+
+MPI_CALL(XBT_PUBLIC int, MPI_Win_set_errhandler, (MPI_Win win, MPI_Errhandler errhandler));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_get_envelope,
+ (MPI_Datatype datatype, int* num_integers, int* num_addresses, int* num_datatypes, int* combiner));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_get_contents,
+ (MPI_Datatype datatype, int max_integers, int max_addresses, int max_datatypes, int* array_of_integers,
+ MPI_Aint* array_of_addresses, MPI_Datatype* array_of_datatypes));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_create_darray,
+ (int size, int rank, int ndims, int* array_of_gsizes, int* array_of_distribs, int* array_of_dargs,
+ int* array_of_psizes, int order, MPI_Datatype oldtype, MPI_Datatype* newtype));
+MPI_CALL(XBT_PUBLIC int, MPI_Pack_external_size, (char* datarep, int incount, MPI_Datatype datatype, MPI_Aint* size));
+MPI_CALL(XBT_PUBLIC int, MPI_Pack_external, (char* datarep, void* inbuf, int incount, MPI_Datatype datatype,
+ void* outbuf, MPI_Aint outcount, MPI_Aint* position));
+MPI_CALL(XBT_PUBLIC int, MPI_Unpack_external, (char* datarep, void* inbuf, MPI_Aint insize, MPI_Aint* position,
+ void* outbuf, int outcount, MPI_Datatype datatype));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_create_subarray,
+ (int ndims, int* array_of_sizes, int* array_of_subsizes, int* array_of_starts, int order, MPI_Datatype oldtype,
+ MPI_Datatype* newtype));
+MPI_CALL(XBT_PUBLIC int, MPI_Type_match_size, (int typeclass, int size, MPI_Datatype* datatype));
+MPI_CALL(XBT_PUBLIC int, MPI_Alltoallw,
+ (void* sendbuf, int* sendcnts, int* sdispls, MPI_Datatype* sendtypes, void* recvbuf, int* recvcnts,
+ int* rdispls, MPI_Datatype* recvtypes, MPI_Comm comm));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_set_info, (MPI_Comm comm, MPI_Info info));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_get_info, (MPI_Comm comm, MPI_Info* info));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_dup_with_info, (MPI_Comm comm, MPI_Info info, MPI_Comm* newcomm));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_split_type,
+ (MPI_Comm comm, int split_type, int key, MPI_Info info, MPI_Comm* newcomm));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_connect,
+ (char* port_name, MPI_Info info, int root, MPI_Comm comm, MPI_Comm* newcomm));
+MPI_CALL(XBT_PUBLIC int, MPI_Request_get_status, (MPI_Request request, int* flag, MPI_Status* status));
+MPI_CALL(XBT_PUBLIC int, MPI_Grequest_start,
+ (MPI_Grequest_query_function * query_fn, MPI_Grequest_free_function* free_fn,
+ MPI_Grequest_cancel_function* cancel_fn, void* extra_state, MPI_Request* request));
+MPI_CALL(XBT_PUBLIC int, MPI_Grequest_complete, (MPI_Request request));
+MPI_CALL(XBT_PUBLIC int, MPI_Status_set_cancelled, (MPI_Status * status, int flag));
+MPI_CALL(XBT_PUBLIC int, MPI_Status_set_elements, (MPI_Status * status, MPI_Datatype datatype, int count));
+MPI_CALL(XBT_PUBLIC int, MPI_Unpublish_name, (char* service_name, MPI_Info info, char* port_name));
+MPI_CALL(XBT_PUBLIC int, MPI_Publish_name, (char* service_name, MPI_Info info, char* port_name));
+MPI_CALL(XBT_PUBLIC int, MPI_Lookup_name, (char* service_name, MPI_Info info, char* port_name));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_join, (int fd, MPI_Comm* intercomm));
+MPI_CALL(XBT_PUBLIC int, MPI_Open_port, (MPI_Info info, char* port_name));
+MPI_CALL(XBT_PUBLIC int, MPI_Close_port, (char* port_name));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_accept, (char* port_name, MPI_Info info, int root, MPI_Comm comm, MPI_Comm* newcomm));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_spawn, (char* command, char** argv, int maxprocs, MPI_Info info, int root,
+ MPI_Comm comm, MPI_Comm* intercomm, int* array_of_errcodes));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_spawn_multiple,
+ (int count, char** array_of_commands, char*** array_of_argv, int* array_of_maxprocs, MPI_Info* array_of_info,
+ int root, MPI_Comm comm, MPI_Comm* intercomm, int* array_of_errcodes));
+MPI_CALL(XBT_PUBLIC int, MPI_Comm_get_parent, (MPI_Comm * parent));
+MPI_CALL(XBT_PUBLIC int, MPI_Win_test, (MPI_Win win, int* flag));
+
+MPI_CALL(XBT_PUBLIC MPI_Fint, MPI_File_c2f, (MPI_File file));
+MPI_CALL(XBT_PUBLIC MPI_File, MPI_File_f2c, (MPI_Fint file));
+MPI_CALL(XBT_PUBLIC int, MPI_Register_datarep, (char* datarep, MPI_Datarep_conversion_function* read_conversion_fn,
+ MPI_Datarep_conversion_function* write_conversion_fn,
+ MPI_Datarep_extent_function* dtype_file_extent_fn, void* extra_state));
+MPI_CALL(XBT_PUBLIC int, MPI_File_call_errhandler, (MPI_File fh, int errorcode));
+MPI_CALL(XBT_PUBLIC int, MPI_File_create_errhandler,
+ (MPI_File_errhandler_function * function, MPI_Errhandler* errhandler));
+MPI_CALL(XBT_PUBLIC int, MPI_File_set_errhandler, (MPI_File file, MPI_Errhandler errhandler));
+MPI_CALL(XBT_PUBLIC int, MPI_File_get_errhandler, (MPI_File file, MPI_Errhandler* errhandler));
+MPI_CALL(XBT_PUBLIC int, MPI_File_open, (MPI_Comm comm, char* filename, int amode, MPI_Info info, MPI_File* fh));
+MPI_CALL(XBT_PUBLIC int, MPI_File_close, (MPI_File * fh));
+MPI_CALL(XBT_PUBLIC int, MPI_File_delete, (char* filename, MPI_Info info));
+MPI_CALL(XBT_PUBLIC int, MPI_File_set_size, (MPI_File fh, MPI_Offset size));
+MPI_CALL(XBT_PUBLIC int, MPI_File_preallocate, (MPI_File fh, MPI_Offset size));
+MPI_CALL(XBT_PUBLIC int, MPI_File_get_size, (MPI_File fh, MPI_Offset* size));
+MPI_CALL(XBT_PUBLIC int, MPI_File_get_group, (MPI_File fh, MPI_Group* group));
+MPI_CALL(XBT_PUBLIC int, MPI_File_get_amode, (MPI_File fh, int* amode));
+MPI_CALL(XBT_PUBLIC int, MPI_File_set_info, (MPI_File fh, MPI_Info info));
+MPI_CALL(XBT_PUBLIC int, MPI_File_get_info, (MPI_File fh, MPI_Info* info_used));
+MPI_CALL(XBT_PUBLIC int, MPI_File_set_view,
+ (MPI_File fh, MPI_Offset disp, MPI_Datatype etype, MPI_Datatype filetype, char* datarep, MPI_Info info));
+MPI_CALL(XBT_PUBLIC int, MPI_File_get_view,
+ (MPI_File fh, MPI_Offset* disp, MPI_Datatype* etype, MPI_Datatype* filetype, char* datarep));
+MPI_CALL(XBT_PUBLIC int, MPI_File_read_at,
+ (MPI_File fh, MPI_Offset offset, void* buf, int count, MPI_Datatype datatype, MPI_Status* status));
+MPI_CALL(XBT_PUBLIC int, MPI_File_read_at_all,
+ (MPI_File fh, MPI_Offset offset, void* buf, int count, MPI_Datatype datatype, MPI_Status* status));
+MPI_CALL(XBT_PUBLIC int, MPI_File_write_at,
+ (MPI_File fh, MPI_Offset offset, void* buf, int count, MPI_Datatype datatype, MPI_Status* status));
+MPI_CALL(XBT_PUBLIC int, MPI_File_write_at_all,
+ (MPI_File fh, MPI_Offset offset, void* buf, int count, MPI_Datatype datatype, MPI_Status* status));
+MPI_CALL(XBT_PUBLIC int, MPI_File_iread_at,
+ (MPI_File fh, MPI_Offset offset, void* buf, int count, MPI_Datatype datatype, MPI_Request* request));
+MPI_CALL(XBT_PUBLIC int, MPI_File_iwrite_at,
+ (MPI_File fh, MPI_Offset offset, void* buf, int count, MPI_Datatype datatype, MPI_Request* request));
+MPI_CALL(XBT_PUBLIC int, MPI_File_iread_at_all,
+ (MPI_File fh, MPI_Offset offset, void* buf, int count, MPI_Datatype datatype, MPI_Request* request));
+MPI_CALL(XBT_PUBLIC int, MPI_File_iwrite_at_all,
+ (MPI_File fh, MPI_Offset offset, void* buf, int count, MPI_Datatype datatype, MPI_Request* request));
+MPI_CALL(XBT_PUBLIC int, MPI_File_read, (MPI_File fh, void* buf, int count, MPI_Datatype datatype, MPI_Status* status));
+MPI_CALL(XBT_PUBLIC int, MPI_File_read_all,
+ (MPI_File fh, void* buf, int count, MPI_Datatype datatype, MPI_Status* status));
+MPI_CALL(XBT_PUBLIC int, MPI_File_write,
+ (MPI_File fh, void* buf, int count, MPI_Datatype datatype, MPI_Status* status));
+MPI_CALL(XBT_PUBLIC int, MPI_File_write_all,
+ (MPI_File fh, void* buf, int count, MPI_Datatype datatype, MPI_Status* status));
+MPI_CALL(XBT_PUBLIC int, MPI_File_iread,
+ (MPI_File fh, void* buf, int count, MPI_Datatype datatype, MPI_Request* request));
+MPI_CALL(XBT_PUBLIC int, MPI_File_iwrite,
+ (MPI_File fh, void* buf, int count, MPI_Datatype datatype, MPI_Request* request));
+MPI_CALL(XBT_PUBLIC int, MPI_File_iread_all,
+ (MPI_File fh, void* buf, int count, MPI_Datatype datatype, MPI_Request* request));
+MPI_CALL(XBT_PUBLIC int, MPI_File_iwrite_all,
+ (MPI_File fh, void* buf, int count, MPI_Datatype datatype, MPI_Request* request));
+MPI_CALL(XBT_PUBLIC int, MPI_File_seek, (MPI_File fh, MPI_Offset offset, int whenace));
+MPI_CALL(XBT_PUBLIC int, MPI_File_get_position, (MPI_File fh, MPI_Offset* offset));
+MPI_CALL(XBT_PUBLIC int, MPI_File_get_byte_offset, (MPI_File fh, MPI_Offset offset, MPI_Offset* disp));
+MPI_CALL(XBT_PUBLIC int, MPI_File_read_shared,
+ (MPI_File fh, void* buf, int count, MPI_Datatype datatype, MPI_Status* status));
+MPI_CALL(XBT_PUBLIC int, MPI_File_write_shared,
+ (MPI_File fh, void* buf, int count, MPI_Datatype datatype, MPI_Status* status));
+MPI_CALL(XBT_PUBLIC int, MPI_File_iread_shared,
+ (MPI_File fh, void* buf, int count, MPI_Datatype datatype, MPI_Request* request));
+MPI_CALL(XBT_PUBLIC int, MPI_File_iwrite_shared,
+ (MPI_File fh, void* buf, int count, MPI_Datatype datatype, MPI_Request* request));
+MPI_CALL(XBT_PUBLIC int, MPI_File_read_ordered,
+ (MPI_File fh, void* buf, int count, MPI_Datatype datatype, MPI_Status* status));
+MPI_CALL(XBT_PUBLIC int, MPI_File_write_ordered,
+ (MPI_File fh, void* buf, int count, MPI_Datatype datatype, MPI_Status* status));
+MPI_CALL(XBT_PUBLIC int, MPI_File_seek_shared, (MPI_File fh, MPI_Offset offset, int whence));
+MPI_CALL(XBT_PUBLIC int, MPI_File_get_position_shared, (MPI_File fh, MPI_Offset* offset));
+MPI_CALL(XBT_PUBLIC int, MPI_File_read_at_all_begin,
+ (MPI_File fh, MPI_Offset offset, void* buf, int count, MPI_Datatype datatype));
+MPI_CALL(XBT_PUBLIC int, MPI_File_read_at_all_end, (MPI_File fh, void* buf, MPI_Status* status));
+MPI_CALL(XBT_PUBLIC int, MPI_File_write_at_all_begin,
+ (MPI_File fh, MPI_Offset offset, void* buf, int count, MPI_Datatype datatype));
+MPI_CALL(XBT_PUBLIC int, MPI_File_write_at_all_end, (MPI_File fh, void* buf, MPI_Status* status));
+MPI_CALL(XBT_PUBLIC int, MPI_File_read_all_begin, (MPI_File fh, void* buf, int count, MPI_Datatype datatype));
+MPI_CALL(XBT_PUBLIC int, MPI_File_read_all_end, (MPI_File fh, void* buf, MPI_Status* status));
+MPI_CALL(XBT_PUBLIC int, MPI_File_write_all_begin, (MPI_File fh, void* buf, int count, MPI_Datatype datatype));
+MPI_CALL(XBT_PUBLIC int, MPI_File_write_all_end, (MPI_File fh, void* buf, MPI_Status* status));
+MPI_CALL(XBT_PUBLIC int, MPI_File_read_ordered_begin, (MPI_File fh, void* buf, int count, MPI_Datatype datatype));
+MPI_CALL(XBT_PUBLIC int, MPI_File_read_ordered_end, (MPI_File fh, void* buf, MPI_Status* status));
+MPI_CALL(XBT_PUBLIC int, MPI_File_write_ordered_begin, (MPI_File fh, void* buf, int count, MPI_Datatype datatype));
+MPI_CALL(XBT_PUBLIC int, MPI_File_write_ordered_end, (MPI_File fh, void* buf, MPI_Status* status));
+MPI_CALL(XBT_PUBLIC int, MPI_File_get_type_extent, (MPI_File fh, MPI_Datatype datatype, MPI_Aint* extent));
+MPI_CALL(XBT_PUBLIC int, MPI_File_set_atomicity, (MPI_File fh, int flag));
+MPI_CALL(XBT_PUBLIC int, MPI_File_get_atomicity, (MPI_File fh, int* flag));
+MPI_CALL(XBT_PUBLIC int, MPI_File_sync, (MPI_File fh));
//FIXME: End of all the not yet implemented stuff
// smpi functions
-XBT_PUBLIC(int) smpi_global_size();
-XBT_PUBLIC(MPI_Comm) smpi_process_comm_self();
-XBT_PUBLIC(void*) smpi_process_get_user_data();
-XBT_PUBLIC(void) smpi_process_set_user_data(void *);
+XBT_PUBLIC int smpi_global_size();
+XBT_PUBLIC MPI_Comm smpi_process_comm_self();
+XBT_PUBLIC void* smpi_process_get_user_data();
+XBT_PUBLIC void smpi_process_set_user_data(void*);
-XBT_PUBLIC(void) smpi_execute_flops(double flops);
-XBT_PUBLIC(void) smpi_execute(double duration);
-XBT_PUBLIC(void) smpi_execute_benched(double duration);
+XBT_PUBLIC void smpi_execute_flops(double flops);
+XBT_PUBLIC void smpi_execute(double duration);
+XBT_PUBLIC void smpi_execute_benched(double duration);
-XBT_PUBLIC(double) smpi_get_host_power_peak_at(int pstate_index);
-XBT_PUBLIC(double) smpi_get_host_current_power_peak();
-XBT_PUBLIC(int) smpi_get_host_nb_pstates();
-XBT_PUBLIC(void) smpi_set_host_pstate(int pstate_index);
-XBT_PUBLIC(int) smpi_get_host_pstate();
+XBT_PUBLIC double smpi_get_host_power_peak_at(int pstate_index);
+XBT_PUBLIC double smpi_get_host_current_power_peak();
+XBT_PUBLIC int smpi_get_host_nb_pstates();
+XBT_PUBLIC void smpi_set_host_pstate(int pstate_index);
+XBT_PUBLIC int smpi_get_host_pstate();
-XBT_PUBLIC(double) smpi_get_host_consumed_energy();
+XBT_PUBLIC double smpi_get_host_consumed_energy();
-XBT_PUBLIC(int) smpi_usleep(useconds_t usecs);
+XBT_PUBLIC int smpi_usleep(useconds_t usecs);
#if _POSIX_TIMERS > 0
-XBT_PUBLIC(int) smpi_nanosleep(const struct timespec *tp, struct timespec * t);
-XBT_PUBLIC(int) smpi_clock_gettime(clockid_t clk_id, struct timespec *tp);
+XBT_PUBLIC int smpi_nanosleep(const struct timespec* tp, struct timespec* t);
+XBT_PUBLIC int smpi_clock_gettime(clockid_t clk_id, struct timespec* tp);
#endif
-XBT_PUBLIC(unsigned int) smpi_sleep(unsigned int secs);
-XBT_PUBLIC(int) smpi_gettimeofday(struct timeval *tv, void* tz);
-XBT_PUBLIC(unsigned long long) smpi_rastro_resolution ();
-XBT_PUBLIC(unsigned long long) smpi_rastro_timestamp ();
-XBT_PUBLIC(void) smpi_sample_1(int global, const char *file, int line, int iters, double threshold);
-XBT_PUBLIC(int) smpi_sample_2(int global, const char *file, int line);
-XBT_PUBLIC(void) smpi_sample_3(int global, const char *file, int line);
+XBT_PUBLIC unsigned int smpi_sleep(unsigned int secs);
+XBT_PUBLIC int smpi_gettimeofday(struct timeval* tv, void* tz);
+XBT_PUBLIC unsigned long long smpi_rastro_resolution();
+XBT_PUBLIC unsigned long long smpi_rastro_timestamp();
+XBT_PUBLIC void smpi_sample_1(int global, const char* file, int line, int iters, double threshold);
+XBT_PUBLIC int smpi_sample_2(int global, const char* file, int line);
+XBT_PUBLIC void smpi_sample_3(int global, const char* file, int line);
/**
* Need a public setter for SMPI copy_callback function, so users can define
* their own while still using default SIMIX_copy_callback for MSG copies.
*/
-XBT_PUBLIC(void) smpi_comm_set_copy_data_callback(void (*callback) (smx_activity_t, void*, size_t));
-
+XBT_PUBLIC void smpi_comm_set_copy_data_callback(void (*callback)(smx_activity_t, void*, size_t));
/**
* Functions for call location tracing. These functions will be
* called from the user's application! (With the __FILE__ and __LINE__ values
* passed as parameters.)
*/
-XBT_PUBLIC(void) smpi_trace_set_call_location(const char *file, int line);
+XBT_PUBLIC void smpi_trace_set_call_location(const char* file, int line);
/** Fortran binding **/
-XBT_PUBLIC(void) smpi_trace_set_call_location_(const char *file, int* line);
+XBT_PUBLIC void smpi_trace_set_call_location_(const char* file, int* line);
/** Fortran binding + -fsecond-underscore **/
-XBT_PUBLIC(void) smpi_trace_set_call_location__(const char *file, int* line);
+XBT_PUBLIC void smpi_trace_set_call_location__(const char* file, int* line);
#define SMPI_SAMPLE_LOOP(global, iters, thres) \
for (smpi_sample_1(global, __FILE__, __LINE__, iters, thres); smpi_sample_2(global, __FILE__, __LINE__); \
#define SMPI_SAMPLE_DELAY(duration) for(smpi_execute(duration); 0; )
#define SMPI_SAMPLE_FLOPS(flops) for(smpi_execute_flops(flops); 0; )
-XBT_PUBLIC(void *) smpi_shared_malloc(size_t size, const char *file, int line);
+XBT_PUBLIC void* smpi_shared_malloc(size_t size, const char* file, int line);
#define SMPI_SHARED_MALLOC(size) smpi_shared_malloc(size, __FILE__, __LINE__)
-XBT_PUBLIC(void*) smpi_shared_malloc_partial(size_t size, size_t* shared_block_offsets, int nb_shared_blocks);
+XBT_PUBLIC void* smpi_shared_malloc_partial(size_t size, size_t* shared_block_offsets, int nb_shared_blocks);
#define SMPI_PARTIAL_SHARED_MALLOC(size, shared_block_offsets, nb_shared_blocks) \
smpi_shared_malloc_partial(size, shared_block_offsets, nb_shared_blocks)
-XBT_PUBLIC(void) smpi_shared_free(void *data);
+XBT_PUBLIC void smpi_shared_free(void* data);
#define SMPI_SHARED_FREE(data) smpi_shared_free(data)
-XBT_PUBLIC(int) smpi_shared_known_call(const char* func, const char* input);
-XBT_PUBLIC(void*) smpi_shared_get_call(const char* func, const char* input);
-XBT_PUBLIC(void*) smpi_shared_set_call(const char* func, const char* input, void* data);
+XBT_PUBLIC int smpi_shared_known_call(const char* func, const char* input);
+XBT_PUBLIC void* smpi_shared_get_call(const char* func, const char* input);
+XBT_PUBLIC void* smpi_shared_set_call(const char* func, const char* input, void* data);
#define SMPI_SHARED_CALL(func, input, ...) \
(smpi_shared_known_call(#func, input) ? smpi_shared_get_call(#func, input) \
: smpi_shared_set_call(#func, input, (func(__VA_ARGS__))))
/* Fortran specific stuff */
-XBT_PUBLIC(int) smpi_main(const char* program, int argc, char *argv[]);
-XBT_ATTRIB_DEPRECATED_v322("Use Actor::self()->getPid(): v3.22 will turn this warning into an error.") XBT_PUBLIC(int) smpi_process_index();
-XBT_PUBLIC(void) smpi_process_init(int *argc, char ***argv);
+XBT_PUBLIC int smpi_main(const char* program, int argc, char* argv[]);
+XBT_ATTRIB_DEPRECATED_v322("Use Actor::self()->getPid(): v3.22 will turn this warning into an error.") XBT_PUBLIC
+ int smpi_process_index();
+XBT_PUBLIC void smpi_process_init(int* argc, char*** argv);
/* Trace replay specific stuff */
-XBT_PUBLIC(void) smpi_replay_init(int* argc, char*** argv); // Only initialization
-XBT_PUBLIC(void) smpi_replay_main(int* argc, char*** argv); // Launch the replay once init is done
-XBT_PUBLIC(void) smpi_replay_run(int* argc, char*** argv); // Both init and start
+XBT_PUBLIC void smpi_replay_init(int* argc, char*** argv); // Only initialization
+XBT_PUBLIC void smpi_replay_main(int* argc, char*** argv); // Launch the replay once init is done
+XBT_PUBLIC void smpi_replay_run(int* argc, char*** argv); // Both init and start
-XBT_PUBLIC(void) SMPI_app_instance_register(const char *name, xbt_main_func_t code, int num_processes);
-XBT_PUBLIC(void) SMPI_init();
-XBT_PUBLIC(void) SMPI_finalize();
+XBT_PUBLIC void SMPI_app_instance_register(const char* name, xbt_main_func_t code, int num_processes);
+XBT_PUBLIC void SMPI_init();
+XBT_PUBLIC void SMPI_finalize();
/* Manual global privatization fallback */
-XBT_PUBLIC(void) smpi_register_static(void* arg, void_f_pvoid_t free_fn);
-XBT_PUBLIC(void) smpi_free_static();
+XBT_PUBLIC void smpi_register_static(void* arg, void_f_pvoid_t free_fn);
+XBT_PUBLIC void smpi_free_static();
#define SMPI_VARINIT_GLOBAL(name,type) \
type *name = NULL; \
#ifdef __cplusplus
#include <vector>
-XBT_PUBLIC(int) smpi_is_shared(void* ptr, std::vector<std::pair<size_t, size_t>>& private_blocks, size_t* offset);
+XBT_PUBLIC int smpi_is_shared(void* ptr, std::vector<std::pair<size_t, size_t>>& private_blocks, size_t* offset);
std::vector<std::pair<size_t, size_t>> shift_and_frame_private_blocks(const std::vector<std::pair<size_t, size_t>> vec,
size_t offset, size_t buff_size);
-/* Copyright (c) 2012, 2014. The SimGrid Team.
+/* Copyright (c) 2012, 2014-2018. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
SG_BEGIN_DECL();
-XBT_PUBLIC(int) RngStream_SetPackageSeed (unsigned long seed[6]);
-XBT_PUBLIC(RngStream) RngStream_CreateStream (const char name[]);
-XBT_PUBLIC(void) RngStream_DeleteStream (RngStream *pg);
-XBT_PUBLIC(RngStream) RngStream_CopyStream (const RngStream src);
-XBT_PUBLIC(void) RngStream_ResetStartStream (RngStream g);
-XBT_PUBLIC(void) RngStream_ResetStartSubstream (RngStream g);
-XBT_PUBLIC(void) RngStream_ResetNextSubstream (RngStream g);
-XBT_PUBLIC(void) RngStream_SetAntithetic (RngStream g, int a);
-XBT_PUBLIC(void) RngStream_IncreasedPrecis (RngStream g, int incp);
-XBT_PUBLIC(int) RngStream_SetSeed (RngStream g, unsigned long seed[6]);
-XBT_PUBLIC(void) RngStream_AdvanceState (RngStream g, long e, long c);
-XBT_PUBLIC(void) RngStream_GetState (RngStream g, unsigned long seed[6]);
-XBT_PUBLIC(void) RngStream_WriteState (RngStream g);
-XBT_PUBLIC(void) RngStream_WriteStateFull (RngStream g);
-XBT_PUBLIC(double) RngStream_RandU01 (RngStream g);
-XBT_PUBLIC(int) RngStream_RandInt (RngStream g, int i, int j);
+XBT_PUBLIC int RngStream_SetPackageSeed(unsigned long seed[6]);
+XBT_PUBLIC RngStream RngStream_CreateStream(const char name[]);
+XBT_PUBLIC void RngStream_DeleteStream(RngStream* pg);
+XBT_PUBLIC RngStream RngStream_CopyStream(const RngStream src);
+XBT_PUBLIC void RngStream_ResetStartStream(RngStream g);
+XBT_PUBLIC void RngStream_ResetStartSubstream(RngStream g);
+XBT_PUBLIC void RngStream_ResetNextSubstream(RngStream g);
+XBT_PUBLIC void RngStream_SetAntithetic(RngStream g, int a);
+XBT_PUBLIC void RngStream_IncreasedPrecis(RngStream g, int incp);
+XBT_PUBLIC int RngStream_SetSeed(RngStream g, unsigned long seed[6]);
+XBT_PUBLIC void RngStream_AdvanceState(RngStream g, long e, long c);
+XBT_PUBLIC void RngStream_GetState(RngStream g, unsigned long seed[6]);
+XBT_PUBLIC void RngStream_WriteState(RngStream g);
+XBT_PUBLIC void RngStream_WriteStateFull(RngStream g);
+XBT_PUBLIC double RngStream_RandU01(RngStream g);
+XBT_PUBLIC int RngStream_RandInt(RngStream g, int i, int j);
SG_END_DECL();
typedef int (*xbt_automaton_propositional_symbol_callback_type)(void*);
typedef void (*xbt_automaton_propositional_symbol_free_function_type)(void*);
-XBT_PUBLIC(xbt_automaton_t) xbt_automaton_new(void);
-XBT_PUBLIC(void) xbt_automaton_load(xbt_automaton_t automaton, const char *file);
-XBT_PUBLIC(xbt_automaton_state_t) xbt_automaton_state_new(xbt_automaton_t a, int type, char* id);
-XBT_PUBLIC(xbt_automaton_transition_t)
- xbt_automaton_transition_new(xbt_automaton_t a, xbt_automaton_state_t src, xbt_automaton_state_t dst,
- xbt_automaton_exp_label_t label);
-XBT_PUBLIC(xbt_automaton_exp_label_t) xbt_automaton_exp_label_new(int type, ...);
-XBT_PUBLIC(xbt_dynar_t) xbt_automaton_get_states(xbt_automaton_t a);
-XBT_PUBLIC(xbt_dynar_t) xbt_automaton_get_transitions(xbt_automaton_t a);
-XBT_PUBLIC(xbt_automaton_transition_t) xbt_automaton_get_transition(xbt_automaton_t a, xbt_automaton_state_t src,
- xbt_automaton_state_t dst);
-XBT_PUBLIC(xbt_automaton_state_t) xbt_automaton_transition_get_source(xbt_automaton_transition_t t);
-XBT_PUBLIC(xbt_automaton_state_t) xbt_automaton_transition_get_destination(xbt_automaton_transition_t t);
-XBT_PUBLIC(void) xbt_automaton_transition_set_source(xbt_automaton_transition_t t, xbt_automaton_state_t src);
-XBT_PUBLIC(void) xbt_automaton_transition_set_destination(xbt_automaton_transition_t t, xbt_automaton_state_t dst);
-XBT_PUBLIC(xbt_dynar_t) xbt_automaton_state_get_out_transitions(xbt_automaton_state_t s);
-XBT_PUBLIC(xbt_dynar_t) xbt_automaton_state_get_in_transitions(xbt_automaton_state_t s);
-XBT_PUBLIC(xbt_automaton_state_t) xbt_automaton_state_exists(xbt_automaton_t a, char *id);
-XBT_PUBLIC(void) xbt_automaton_display(xbt_automaton_t a);
-XBT_PUBLIC(void) xbt_automaton_exp_label_display(xbt_automaton_exp_label_t l);
+XBT_PUBLIC xbt_automaton_t xbt_automaton_new(void);
+XBT_PUBLIC void xbt_automaton_load(xbt_automaton_t automaton, const char* file);
+XBT_PUBLIC xbt_automaton_state_t xbt_automaton_state_new(xbt_automaton_t a, int type, char* id);
+XBT_PUBLIC xbt_automaton_transition_t xbt_automaton_transition_new(xbt_automaton_t a, xbt_automaton_state_t src,
+ xbt_automaton_state_t dst,
+ xbt_automaton_exp_label_t label);
+XBT_PUBLIC xbt_automaton_exp_label_t xbt_automaton_exp_label_new(int type, ...);
+XBT_PUBLIC xbt_dynar_t xbt_automaton_get_states(xbt_automaton_t a);
+XBT_PUBLIC xbt_dynar_t xbt_automaton_get_transitions(xbt_automaton_t a);
+XBT_PUBLIC xbt_automaton_transition_t xbt_automaton_get_transition(xbt_automaton_t a, xbt_automaton_state_t src,
+ xbt_automaton_state_t dst);
+XBT_PUBLIC xbt_automaton_state_t xbt_automaton_transition_get_source(xbt_automaton_transition_t t);
+XBT_PUBLIC xbt_automaton_state_t xbt_automaton_transition_get_destination(xbt_automaton_transition_t t);
+XBT_PUBLIC void xbt_automaton_transition_set_source(xbt_automaton_transition_t t, xbt_automaton_state_t src);
+XBT_PUBLIC void xbt_automaton_transition_set_destination(xbt_automaton_transition_t t, xbt_automaton_state_t dst);
+XBT_PUBLIC xbt_dynar_t xbt_automaton_state_get_out_transitions(xbt_automaton_state_t s);
+XBT_PUBLIC xbt_dynar_t xbt_automaton_state_get_in_transitions(xbt_automaton_state_t s);
+XBT_PUBLIC xbt_automaton_state_t xbt_automaton_state_exists(xbt_automaton_t a, char* id);
+XBT_PUBLIC void xbt_automaton_display(xbt_automaton_t a);
+XBT_PUBLIC void xbt_automaton_exp_label_display(xbt_automaton_exp_label_t l);
// xbt_automaton_propositional_symbol constructors:
-XBT_PUBLIC(xbt_automaton_propositional_symbol_t)
- xbt_automaton_propositional_symbol_new(xbt_automaton_t a, const char* id, int(*fct)(void));
-XBT_PUBLIC(xbt_automaton_propositional_symbol_t)
- xbt_automaton_propositional_symbol_new_pointer(xbt_automaton_t a, const char* id, int* value);
-XBT_PUBLIC(xbt_automaton_propositional_symbol_t)
- xbt_automaton_propositional_symbol_new_callback(xbt_automaton_t a, const char* id,
- xbt_automaton_propositional_symbol_callback_type callback,
- void* data, xbt_automaton_propositional_symbol_free_function_type free_function);
+XBT_PUBLIC xbt_automaton_propositional_symbol_t xbt_automaton_propositional_symbol_new(xbt_automaton_t a,
+ const char* id,
+ int (*fct)(void));
+XBT_PUBLIC xbt_automaton_propositional_symbol_t xbt_automaton_propositional_symbol_new_pointer(xbt_automaton_t a,
+ const char* id,
+ int* value);
+XBT_PUBLIC xbt_automaton_propositional_symbol_t xbt_automaton_propositional_symbol_new_callback(
+ xbt_automaton_t a, const char* id, xbt_automaton_propositional_symbol_callback_type callback, void* data,
+ xbt_automaton_propositional_symbol_free_function_type free_function);
// xbt_automaton_propositional_symbol accessors:
-XBT_PUBLIC(xbt_automaton_propositional_symbol_callback_type)
- xbt_automaton_propositional_symbol_get_callback(xbt_automaton_propositional_symbol_t symbol);
-XBT_PUBLIC(void*) xbt_automaton_propositional_symbol_get_data(xbt_automaton_propositional_symbol_t symbol);
-XBT_PUBLIC(const char*) xbt_automaton_propositional_symbol_get_name(xbt_automaton_propositional_symbol_t symbol);
+XBT_PUBLIC xbt_automaton_propositional_symbol_callback_type
+xbt_automaton_propositional_symbol_get_callback(xbt_automaton_propositional_symbol_t symbol);
+XBT_PUBLIC void* xbt_automaton_propositional_symbol_get_data(xbt_automaton_propositional_symbol_t symbol);
+XBT_PUBLIC const char* xbt_automaton_propositional_symbol_get_name(xbt_automaton_propositional_symbol_t symbol);
// xbt_automaton_propositional_symbol methods!
-XBT_PUBLIC(int) xbt_automaton_propositional_symbol_evaluate(xbt_automaton_propositional_symbol_t symbol);
-
-XBT_PUBLIC(xbt_automaton_state_t) xbt_automaton_get_current_state(xbt_automaton_t a);
-XBT_PUBLIC(int) xbt_automaton_state_compare(xbt_automaton_state_t s1, xbt_automaton_state_t s2);
-XBT_PUBLIC(int) xbt_automaton_propositional_symbols_compare_value(xbt_dynar_t s1, xbt_dynar_t s2);
-XBT_PUBLIC(int) xbt_automaton_transition_compare(const void *t1, const void *t2);
-XBT_PUBLIC(int) xbt_automaton_exp_label_compare(xbt_automaton_exp_label_t l1, xbt_automaton_exp_label_t l2);
-XBT_PUBLIC(void) xbt_automaton_state_free_voidp(void *s);
-XBT_PUBLIC(void) xbt_automaton_state_free(xbt_automaton_state_t s);
-XBT_PUBLIC(void) xbt_automaton_transition_free_voidp(void *t);
-XBT_PUBLIC(void) xbt_automaton_exp_label_free_voidp(void *e);
-XBT_PUBLIC(void) xbt_automaton_propositional_symbol_free_voidp(void *ps);
-XBT_PUBLIC(void) xbt_automaton_free(xbt_automaton_t a);
+XBT_PUBLIC int xbt_automaton_propositional_symbol_evaluate(xbt_automaton_propositional_symbol_t symbol);
+
+XBT_PUBLIC xbt_automaton_state_t xbt_automaton_get_current_state(xbt_automaton_t a);
+XBT_PUBLIC int xbt_automaton_state_compare(xbt_automaton_state_t s1, xbt_automaton_state_t s2);
+XBT_PUBLIC int xbt_automaton_propositional_symbols_compare_value(xbt_dynar_t s1, xbt_dynar_t s2);
+XBT_PUBLIC int xbt_automaton_transition_compare(const void* t1, const void* t2);
+XBT_PUBLIC int xbt_automaton_exp_label_compare(xbt_automaton_exp_label_t l1, xbt_automaton_exp_label_t l2);
+XBT_PUBLIC void xbt_automaton_state_free_voidp(void* s);
+XBT_PUBLIC void xbt_automaton_state_free(xbt_automaton_state_t s);
+XBT_PUBLIC void xbt_automaton_transition_free_voidp(void* t);
+XBT_PUBLIC void xbt_automaton_exp_label_free_voidp(void* e);
+XBT_PUBLIC void xbt_automaton_propositional_symbol_free_voidp(void* ps);
+XBT_PUBLIC void xbt_automaton_free(xbt_automaton_t a);
SG_END_DECL()
-/* Copyright (c) 2005-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2005-2018. The SimGrid Team. All rights reserved. */
#ifndef XBT_BACKTRACE_H
#define XBT_BACKTRACE_H
typedef void* xbt_backtrace_location_t;
/** @brief Shows a backtrace of the current location */
-XBT_PUBLIC(void) xbt_backtrace_display_current();
+XBT_PUBLIC void xbt_backtrace_display_current();
/** @brief reimplementation of glibc backtrace based directly on gcc library, without implicit malloc */
-XBT_PUBLIC(int) xbt_backtrace_no_malloc(void**bt, int size);
+XBT_PUBLIC int xbt_backtrace_no_malloc(void** bt, int size);
/** @brief Captures a backtrace for further use */
-XBT_PUBLIC(size_t) xbt_backtrace_current(xbt_backtrace_location_t* loc, size_t count);
+XBT_PUBLIC size_t xbt_backtrace_current(xbt_backtrace_location_t* loc, size_t count);
/** @brief Display a previously captured backtrace */
-XBT_PUBLIC(void) xbt_backtrace_display(xbt_backtrace_location_t* loc, size_t count);
+XBT_PUBLIC void xbt_backtrace_display(xbt_backtrace_location_t* loc, size_t count);
/** @brief Get current backtrace with libunwind */
-XBT_PUBLIC(int) xbt_libunwind_backtrace(void** bt, int size);
+XBT_PUBLIC int xbt_libunwind_backtrace(void** bt, int size);
SG_END_DECL()
-/* Copyright (c) 2005-2019. The SimGrid Team.
+/* Copyright (c) 2005-2018. The SimGrid Team.
* All rights reserved. */
#ifndef SIMGRIX_XBT_BACKTRACE_HPP
*
* Return the origin string if this fails.
*/
-XBT_PUBLIC() std::unique_ptr<char, void(*)(void*)> demangle(const char* name);
+XBT_PUBLIC std::unique_ptr<char, void (*)(void*)> demangle(const char* name);
/** Get the current backtrace */
-XBT_PUBLIC(std::vector<xbt_backtrace_location_t>) backtrace();
+XBT_PUBLIC std::vector<xbt_backtrace_location_t> backtrace();
/* Translate the backtrace in a human friendly form
*
* Try ro resolve symbols and source code location.
*/
-XBT_PUBLIC(std::vector<std::string>) resolveBacktrace(
- xbt_backtrace_location_t const* loc, std::size_t count);
-
+XBT_PUBLIC std::vector<std::string> resolveBacktrace(xbt_backtrace_location_t const* loc, std::size_t count);
}
}
/* Build the DLL */
#if defined(DLL_EXPORT)
-# define XBT_ATTRIB_PUBLIC __declspec(dllexport)
-# define XBT_PUBLIC(type) __declspec(dllexport) type
+# define XBT_PUBLIC __declspec(dllexport)
# define XBT_EXPORT_NO_IMPORT(type) __declspec(dllexport) type
# define XBT_IMPORT_NO_EXPORT(type) type
# define XBT_PUBLIC_DATA(type) extern __declspec(dllexport) type
/* Link against the DLL */
#elif (defined(_WIN32) && !defined(DLL_EXPORT))
-# define XBT_ATTRIB_PUBLIC __declspec(dllimport)
-# define XBT_PUBLIC(type) __declspec(dllimport) type
+# define XBT_PUBLIC __declspec(dllimport)
# define XBT_EXPORT_NO_IMPORT(type) type
# define XBT_IMPORT_NO_EXPORT(type) __declspec(dllimport) type
# define XBT_PUBLIC_DATA(type) extern __declspec(dllimport) type
# define XBT_PRIVATE
#elif defined(__ELF__)
-# define XBT_ATTRIB_PUBLIC __attribute__((visibility("default")))
-# define XBT_PUBLIC(type) __attribute__((visibility("default"))) type
+# define XBT_PUBLIC __attribute__((visibility("default")))
# define XBT_EXPORT_NO_IMPORT(type) __attribute__((visibility("default"))) type
# define XBT_IMPORT_NO_EXPORT(type) __attribute__((visibility("default"))) type
# define XBT_PUBLIC_DATA(type) extern __attribute__((visibility("default"))) type
# define XBT_PRIVATE __attribute__((visibility("hidden")))
#else
-# define XBT_ATTRIB_PUBLIC /* public */
-# define XBT_PUBLIC(type) type
+# define XBT_PUBLIC /* public */
# define XBT_EXPORT_NO_IMPORT(type) type
# define XBT_IMPORT_NO_EXPORT(type) type
# define XBT_PUBLIC_DATA(type) extern type
/* config - Dictionary where the type of each cell is provided. */
/* This is useful to build named structs, like option or property sets. */
-/* Copyright (c) 2004-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2004-2018. 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. */
SG_BEGIN_DECL()
-XBT_PUBLIC(void) xbt_cfg_set_parse(const char *options);
+XBT_PUBLIC void xbt_cfg_set_parse(const char* options);
/* Set the value of the cell \a name in \a cfg with the provided value.*/
-XBT_PUBLIC(void) xbt_cfg_set_int (const char *name, int val);
-XBT_PUBLIC(void) xbt_cfg_set_double (const char *name, double val);
-XBT_PUBLIC(void) xbt_cfg_set_boolean (const char *name, const char *val);
-XBT_PUBLIC(void) xbt_cfg_set_string(const char* name, const char* val);
-XBT_PUBLIC(void) xbt_cfg_set_as_string(const char *name, const char *val);
+XBT_PUBLIC void xbt_cfg_set_int(const char* name, int val);
+XBT_PUBLIC void xbt_cfg_set_double(const char* name, double val);
+XBT_PUBLIC void xbt_cfg_set_boolean(const char* name, const char* val);
+XBT_PUBLIC void xbt_cfg_set_string(const char* name, const char* val);
+XBT_PUBLIC void xbt_cfg_set_as_string(const char* name, const char* val);
/*
Set the default value of the cell \a name in \a cfg with the provided value.
If it was already set to something (possibly from the command line), do nothing.
*/
-XBT_PUBLIC(void) xbt_cfg_setdefault_int (const char *name, int val);
-XBT_PUBLIC(void) xbt_cfg_setdefault_double (const char *name, double val);
-XBT_PUBLIC(void) xbt_cfg_setdefault_string (const char *name, const char *val);
-XBT_PUBLIC(void) xbt_cfg_setdefault_boolean(const char *name, const char *val);
+XBT_PUBLIC void xbt_cfg_setdefault_int(const char* name, int val);
+XBT_PUBLIC void xbt_cfg_setdefault_double(const char* name, double val);
+XBT_PUBLIC void xbt_cfg_setdefault_string(const char* name, const char* val);
+XBT_PUBLIC void xbt_cfg_setdefault_boolean(const char* name, const char* val);
/** @brief Return if configuration is set by default*/
-XBT_PUBLIC(int) xbt_cfg_is_default_value(const char *name);
+XBT_PUBLIC int xbt_cfg_is_default_value(const char* name);
/* @} */
*/
/** \brief Callback types. They get the name of the modified entry, and the position of the changed value */
-typedef void (*xbt_cfg_cb_t) (const char * name);
+typedef void (*xbt_cfg_cb_t)(const char* name);
-XBT_PUBLIC(xbt_cfg_t) xbt_cfg_new();
-XBT_PUBLIC(void) xbt_cfg_free(xbt_cfg_t * cfg);
-XBT_PUBLIC(void) xbt_cfg_dump(const char *name, const char *indent, xbt_cfg_t cfg);
+XBT_PUBLIC xbt_cfg_t xbt_cfg_new();
+XBT_PUBLIC void xbt_cfg_free(xbt_cfg_t* cfg);
+XBT_PUBLIC void xbt_cfg_dump(const char* name, const char* indent, xbt_cfg_t cfg);
- /** @} */
+/** @} */
/** @defgroup XBT_cfg_register Registering stuff
* @ingroup XBT_config
*
* @{
*/
-XBT_PUBLIC(void) xbt_cfg_register_double (const char *name, double default_val, xbt_cfg_cb_t cb_set, const char *desc);
-XBT_PUBLIC(void) xbt_cfg_register_int (const char *name, int default_val, xbt_cfg_cb_t cb_set, const char *desc);
-XBT_PUBLIC(void) xbt_cfg_register_string (const char *name, const char*default_val,xbt_cfg_cb_t cb_set, const char *desc);
-XBT_PUBLIC(void) xbt_cfg_register_boolean(const char *name, const char*default_val,xbt_cfg_cb_t cb_set, const char *desc);
-XBT_PUBLIC(void) xbt_cfg_register_alias(const char *newname, const char *oldname);
+XBT_PUBLIC void xbt_cfg_register_double(const char* name, double default_val, xbt_cfg_cb_t cb_set, const char* desc);
+XBT_PUBLIC void xbt_cfg_register_int(const char* name, int default_val, xbt_cfg_cb_t cb_set, const char* desc);
+XBT_PUBLIC void xbt_cfg_register_string(const char* name, const char* default_val, xbt_cfg_cb_t cb_set,
+ const char* desc);
+XBT_PUBLIC void xbt_cfg_register_boolean(const char* name, const char* default_val, xbt_cfg_cb_t cb_set,
+ const char* desc);
+XBT_PUBLIC void xbt_cfg_register_alias(const char* newname, const char* oldname);
-XBT_PUBLIC(void) xbt_cfg_aliases();
-XBT_PUBLIC(void) xbt_cfg_help();
+XBT_PUBLIC void xbt_cfg_aliases();
+XBT_PUBLIC void xbt_cfg_help();
/* @} */
/** @defgroup XBT_cfg_get Getting the stored values
* @{
*/
-XBT_PUBLIC(int) xbt_cfg_get_int(const char *name);
-XBT_PUBLIC(double) xbt_cfg_get_double(const char *name);
-XBT_PUBLIC(int) xbt_cfg_get_boolean(const char *name);
+XBT_PUBLIC int xbt_cfg_get_int(const char* name);
+XBT_PUBLIC double xbt_cfg_get_double(const char* name);
+XBT_PUBLIC int xbt_cfg_get_boolean(const char* name);
/** @} */
-/* Copyright (c) 2016-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2016-2018. 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. */
// Get config
-template<class T>
-XBT_PUBLIC(T const&) getConfig(const char* name);
+template <class T> XBT_PUBLIC T const& getConfig(const char* name);
-extern template XBT_PUBLIC(int const&) getConfig<int>(const char* name);
-extern template XBT_PUBLIC(double const&) getConfig<double>(const char* name);
-extern template XBT_PUBLIC(bool const&) getConfig<bool>(const char* name);
-extern template XBT_PUBLIC(std::string const&) getConfig<std::string>(const char* name);
+extern template XBT_PUBLIC int const& getConfig<int>(const char* name);
+extern template XBT_PUBLIC double const& getConfig<double>(const char* name);
+extern template XBT_PUBLIC bool const& getConfig<bool>(const char* name);
+extern template XBT_PUBLIC std::string const& getConfig<std::string>(const char* name);
// Register:
* @param value Initial/default value
* @param callback called with the option value
*/
-template<class T>
-XBT_PUBLIC(void) declareFlag(const char* name, const char* description,
- T value, std::function<void(const T&)> callback = std::function<void(const T&)>());
-
-extern template XBT_PUBLIC(void) declareFlag(const char* name,
- const char* description, int value, std::function<void(int const &)> callback);
-extern template XBT_PUBLIC(void) declareFlag(const char* name,
- const char* description, double value, std::function<void(double const &)> callback);
-extern template XBT_PUBLIC(void) declareFlag(const char* name,
- const char* description, bool value, std::function<void(bool const &)> callback);
-extern template XBT_PUBLIC(void) declareFlag(const char* name,
- const char* description, std::string value, std::function<void(std::string const &)> callback);
+template <class T>
+XBT_PUBLIC void declareFlag(const char* name, const char* description, T value,
+ std::function<void(const T&)> callback = std::function<void(const T&)>());
+
+extern template XBT_PUBLIC void declareFlag(const char* name, const char* description, int value,
+ std::function<void(int const&)> callback);
+extern template XBT_PUBLIC void declareFlag(const char* name, const char* description, double value,
+ std::function<void(double const&)> callback);
+extern template XBT_PUBLIC void declareFlag(const char* name, const char* description, bool value,
+ std::function<void(bool const&)> callback);
+extern template XBT_PUBLIC void declareFlag(const char* name, const char* description, std::string value,
+ std::function<void(std::string const&)> callback);
// ***** alias *****
-XBT_PUBLIC(void) alias(const char* realname, const char* aliasname);
+XBT_PUBLIC void alias(const char* realname, const char* aliasname);
inline
void alias(std::initializer_list<const char*> names)
}
}
-XBT_PUBLIC(std::string) xbt_cfg_get_string(const char* name);
+XBT_PUBLIC std::string xbt_cfg_get_string(const char* name);
#endif
/* cunit - A little C Unit facility */
-/* Copyright (c) 2005-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2005-2018. 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. */
typedef void (*ts_test_cb_t) ();
/* test suite operations */
-XBT_PUBLIC(xbt_test_suite_t) xbt_test_suite_by_name(const char *name, const char *fmt, ...);
-XBT_PUBLIC(void) xbt_test_suite_push(xbt_test_suite_t suite, const char *name, ts_test_cb_t func, const char *fmt, ...);
+XBT_PUBLIC xbt_test_suite_t xbt_test_suite_by_name(const char* name, const char* fmt, ...);
+XBT_PUBLIC void xbt_test_suite_push(xbt_test_suite_t suite, const char* name, ts_test_cb_t func, const char* fmt, ...);
/* Run all the specified tests. what_to_do allows to disable some tests.
* It is a coma (,) separated list of directives. They are applied from left to right.
* * testname: if given, the test on which the directive acts. If not, acts on any tests.
*/
-XBT_PUBLIC(int) xbt_test_run(char *selection, int verbosity);
+XBT_PUBLIC int xbt_test_run(char* selection, int verbosity);
/* Show information about the selection of tests */
-XBT_PUBLIC(void) xbt_test_dump(char *selection);
+XBT_PUBLIC void xbt_test_dump(char* selection);
/* Cleanup the mess */
-XBT_PUBLIC(void) xbt_test_exit();
+XBT_PUBLIC void xbt_test_exit();
/**
* @addtogroup XBT_cunit
#endif
/* test operations */
-XBT_PUBLIC(void) _xbt_test_add(const char *file, int line, const char *fmt, ...) XBT_ATTRIB_PRINTF(3, 4);
-XBT_PUBLIC(void) _xbt_test_fail(const char *file, int line, const char *fmt, ...) XBT_ATTRIB_PRINTF(3, 4);
-XBT_PUBLIC(void) _xbt_test_log(const char *file, int line, const char *fmt, ...) XBT_ATTRIB_PRINTF(3, 4);
+XBT_PUBLIC void _xbt_test_add(const char* file, int line, const char* fmt, ...) XBT_ATTRIB_PRINTF(3, 4);
+XBT_PUBLIC void _xbt_test_fail(const char* file, int line, const char* fmt, ...) XBT_ATTRIB_PRINTF(3, 4);
+XBT_PUBLIC void _xbt_test_log(const char* file, int line, const char* fmt, ...) XBT_ATTRIB_PRINTF(3, 4);
/** @brief Declare that a new test begins (printf-like parameters, describing the test)
* @hideinitializer */
#define xbt_test_add(...) _xbt_test_add(__FILE__, __LINE__, __VA_ARGS__)
#define xbt_test_log(...) _xbt_test_log(__FILE__, __LINE__, __VA_ARGS__)
/** @brief Declare that the lastly started test failed because of the provided exception */
-XBT_PUBLIC(void) xbt_test_exception(xbt_ex_t e);
+XBT_PUBLIC void xbt_test_exception(xbt_ex_t e);
/** @brief Declare that the lastly started test was expected to fail (and actually failed) */
-XBT_PUBLIC(void) xbt_test_expect_failure();
+XBT_PUBLIC void xbt_test_expect_failure();
/** @brief Declare that the lastly started test should be skipped today */
-XBT_PUBLIC(void) xbt_test_skip();
+XBT_PUBLIC void xbt_test_skip();
/** @} */
xbt_dictelm_t next;
} s_xbt_dictelm_t;
-XBT_PUBLIC(xbt_dict_t) xbt_dict_new_homogeneous(void_f_pvoid_t free_ctn);
-XBT_PUBLIC(void) xbt_dict_free(xbt_dict_t * dict);
-XBT_PUBLIC(unsigned int) xbt_dict_size(xbt_dict_t dict);
+XBT_PUBLIC xbt_dict_t xbt_dict_new_homogeneous(void_f_pvoid_t free_ctn);
+XBT_PUBLIC void xbt_dict_free(xbt_dict_t* dict);
+XBT_PUBLIC unsigned int xbt_dict_size(xbt_dict_t dict);
/** @} */
/** @defgroup XBT_dict_basic Dictionaries basic usage
* @{
*/
-XBT_PUBLIC(void) xbt_dict_set(xbt_dict_t dict, const char *key, void *data, void_f_pvoid_t free_ctn);
-XBT_PUBLIC(void *) xbt_dict_get(xbt_dict_t dict, const char *key);
-XBT_PUBLIC(void *) xbt_dict_get_or_null(xbt_dict_t dict, const char *key);
-XBT_PUBLIC(char*) xbt_dict_get_key(xbt_dict_t dict, const void* data);
-XBT_ATTRIB_DEPRECATED_v321("xbt_dict is dying. v3.21 will turn this warning into an error.") XBT_PUBLIC(char*)
- xbt_dict_get_elm_key(xbt_dictelm_t elem);
-XBT_PUBLIC(xbt_dictelm_t) xbt_dict_get_elm(xbt_dict_t dict, const char *key);
-XBT_PUBLIC(xbt_dictelm_t) xbt_dict_get_elm_or_null(xbt_dict_t dict, const char *key);
-
-XBT_PUBLIC(void) xbt_dict_remove(xbt_dict_t dict, const char *key);
-XBT_PUBLIC(void) xbt_dict_reset(xbt_dict_t dict);
-XBT_PUBLIC(int) xbt_dict_length(xbt_dict_t dict);
-XBT_ATTRIB_DEPRECATED_v321("xbt_dict is dying. v3.21 will turn this warning into an error.") XBT_PUBLIC(void)
- xbt_dict_dump_output_string(void* s);
-XBT_PUBLIC(void) xbt_dict_dump(xbt_dict_t dict, void (*output) (void *));
-XBT_ATTRIB_DEPRECATED_v321("xbt_dict is dying. v3.21 will turn this warning into an error.") XBT_PUBLIC(void)
- xbt_dict_dump_sizes(xbt_dict_t dict);
-XBT_PUBLIC(int) xbt_dict_is_empty(xbt_dict_t dict);
+XBT_PUBLIC void xbt_dict_set(xbt_dict_t dict, const char* key, void* data, void_f_pvoid_t free_ctn);
+XBT_PUBLIC void* xbt_dict_get(xbt_dict_t dict, const char* key);
+XBT_PUBLIC void* xbt_dict_get_or_null(xbt_dict_t dict, const char* key);
+XBT_PUBLIC char* xbt_dict_get_key(xbt_dict_t dict, const void* data);
+XBT_ATTRIB_DEPRECATED_v321("xbt_dict is dying. v3.21 will turn this warning into an error.") XBT_PUBLIC
+ char* xbt_dict_get_elm_key(xbt_dictelm_t elem);
+XBT_PUBLIC xbt_dictelm_t xbt_dict_get_elm(xbt_dict_t dict, const char* key);
+XBT_PUBLIC xbt_dictelm_t xbt_dict_get_elm_or_null(xbt_dict_t dict, const char* key);
+
+XBT_PUBLIC void xbt_dict_remove(xbt_dict_t dict, const char* key);
+XBT_PUBLIC void xbt_dict_reset(xbt_dict_t dict);
+XBT_PUBLIC int xbt_dict_length(xbt_dict_t dict);
+XBT_ATTRIB_DEPRECATED_v321("xbt_dict is dying. v3.21 will turn this warning into an error.") XBT_PUBLIC
+ void xbt_dict_dump_output_string(void* s);
+XBT_PUBLIC void xbt_dict_dump(xbt_dict_t dict, void (*output)(void*));
+XBT_ATTRIB_DEPRECATED_v321("xbt_dict is dying. v3.21 will turn this warning into an error.") XBT_PUBLIC
+ void xbt_dict_dump_sizes(xbt_dict_t dict);
+XBT_PUBLIC int xbt_dict_is_empty(xbt_dict_t dict);
/** @} */
/** @defgroup XBT_dict_nnul Dictionaries with non-nul terminated keys
*
* @{
*/
-XBT_PUBLIC(void) xbt_dict_set_ext(xbt_dict_t dict, const char *key, int key_len, void *data, void_f_pvoid_t free_ctn);
-XBT_PUBLIC(void*) xbt_dict_get_ext(xbt_dict_t dict, const char* key, int key_len);
-XBT_PUBLIC(void*) xbt_dict_get_or_null_ext(xbt_dict_t dict, const char* key, int key_len);
-XBT_PUBLIC(void) xbt_dict_remove_ext(xbt_dict_t dict, const char *key, int key_len);
+XBT_PUBLIC void xbt_dict_set_ext(xbt_dict_t dict, const char* key, int key_len, void* data, void_f_pvoid_t free_ctn);
+XBT_PUBLIC void* xbt_dict_get_ext(xbt_dict_t dict, const char* key, int key_len);
+XBT_PUBLIC void* xbt_dict_get_or_null_ext(xbt_dict_t dict, const char* key, int key_len);
+XBT_PUBLIC void xbt_dict_remove_ext(xbt_dict_t dict, const char* key, int key_len);
struct s_xbt_dict_cursor {
xbt_dictelm_t current;
return cursor->current;
}
-XBT_PUBLIC(xbt_dict_cursor_t) xbt_dict_cursor_new(const xbt_dict_t dict);
-XBT_PUBLIC(void) xbt_dict_cursor_free(xbt_dict_cursor_t * cursor);
+XBT_PUBLIC xbt_dict_cursor_t xbt_dict_cursor_new(const xbt_dict_t dict);
+XBT_PUBLIC void xbt_dict_cursor_free(xbt_dict_cursor_t* cursor);
-XBT_PUBLIC(void) xbt_dict_cursor_rewind(xbt_dict_cursor_t cursor);
+XBT_PUBLIC void xbt_dict_cursor_rewind(xbt_dict_cursor_t cursor);
-XBT_PUBLIC(char *) xbt_dict_cursor_get_key(xbt_dict_cursor_t cursor);
-XBT_PUBLIC(void *) xbt_dict_cursor_get_data(xbt_dict_cursor_t cursor);
-XBT_ATTRIB_DEPRECATED_v321("xbt_dict is dying. v3.21 will turn this warning into an error.") XBT_PUBLIC(void)
- xbt_dict_cursor_set_data(xbt_dict_cursor_t cursor, void* data, void_f_pvoid_t free_ctn);
+XBT_PUBLIC char* xbt_dict_cursor_get_key(xbt_dict_cursor_t cursor);
+XBT_PUBLIC void* xbt_dict_cursor_get_data(xbt_dict_cursor_t cursor);
+XBT_ATTRIB_DEPRECATED_v321("xbt_dict is dying. v3.21 will turn this warning into an error.") XBT_PUBLIC
+ void xbt_dict_cursor_set_data(xbt_dict_cursor_t cursor, void* data, void_f_pvoid_t free_ctn);
-XBT_PUBLIC(void) xbt_dict_cursor_first(const xbt_dict_t dict, xbt_dict_cursor_t * cursor);
-XBT_PUBLIC(void) xbt_dict_cursor_step(xbt_dict_cursor_t cursor);
-XBT_PUBLIC(int) xbt_dict_cursor_get_or_free(xbt_dict_cursor_t * cursor, char **key, void **data);
+XBT_PUBLIC void xbt_dict_cursor_first(const xbt_dict_t dict, xbt_dict_cursor_t* cursor);
+XBT_PUBLIC void xbt_dict_cursor_step(xbt_dict_cursor_t cursor);
+XBT_PUBLIC int xbt_dict_cursor_get_or_free(xbt_dict_cursor_t* cursor, char** key, void** data);
/** @def xbt_dict_foreach
* @param dict a \ref xbt_dict_t iterator
* @param cursor an \ref xbt_dict_cursor_t used as cursor
/* dynar - a generic dynamic array */
-/* Copyright (c) 2004-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2004-2018. 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. */
/** \brief Dynar data type (opaque type) */
typedef struct xbt_dynar_s *xbt_dynar_t;
-XBT_PUBLIC(xbt_dynar_t) xbt_dynar_new(const unsigned long elm_size, void_f_pvoid_t const free_f);
-XBT_PUBLIC(void) xbt_dynar_init(xbt_dynar_t dynar, const unsigned long elmsize, void_f_pvoid_t const free_f);
-XBT_PUBLIC(void) xbt_dynar_free(xbt_dynar_t * dynar);
-XBT_PUBLIC(void) xbt_dynar_free_voidp(void *dynar);
-XBT_PUBLIC(void) xbt_dynar_free_container(xbt_dynar_t * dynar);
-XBT_PUBLIC(void) xbt_dynar_free_data(xbt_dynar_t dynar);
-XBT_PUBLIC(void) xbt_dynar_shrink(xbt_dynar_t dynar, int empty_slots);
-XBT_PUBLIC(void) xbt_dynar_dump(xbt_dynar_t dynar);
+XBT_PUBLIC xbt_dynar_t xbt_dynar_new(const unsigned long elm_size, void_f_pvoid_t const free_f);
+XBT_PUBLIC void xbt_dynar_init(xbt_dynar_t dynar, const unsigned long elmsize, void_f_pvoid_t const free_f);
+XBT_PUBLIC void xbt_dynar_free(xbt_dynar_t* dynar);
+XBT_PUBLIC void xbt_dynar_free_voidp(void* dynar);
+XBT_PUBLIC void xbt_dynar_free_container(xbt_dynar_t* dynar);
+XBT_PUBLIC void xbt_dynar_free_data(xbt_dynar_t dynar);
+XBT_PUBLIC void xbt_dynar_shrink(xbt_dynar_t dynar, int empty_slots);
+XBT_PUBLIC void xbt_dynar_dump(xbt_dynar_t dynar);
/** @} */
/** @defgroup XBT_dynar_array Dynar as a regular array
* @{
*/
-XBT_PUBLIC(void) xbt_dynar_get_cpy(const xbt_dynar_t dynar, const unsigned long idx, void *const dst);
-XBT_PUBLIC(void) xbt_dynar_set(xbt_dynar_t dynar, const int idx, const void *src);
-XBT_PUBLIC(void) xbt_dynar_replace(xbt_dynar_t dynar, const unsigned long idx, const void *object);
+XBT_PUBLIC void xbt_dynar_get_cpy(const xbt_dynar_t dynar, const unsigned long idx, void* const dst);
+XBT_PUBLIC void xbt_dynar_set(xbt_dynar_t dynar, const int idx, const void* src);
+XBT_PUBLIC void xbt_dynar_replace(xbt_dynar_t dynar, const unsigned long idx, const void* object);
-XBT_PUBLIC(void) xbt_dynar_insert_at(xbt_dynar_t const dynar, const int idx, const void *src);
-XBT_PUBLIC(void) xbt_dynar_remove_at(xbt_dynar_t const dynar, const int idx, void *const dst);
-XBT_PUBLIC(void) xbt_dynar_remove_n_at(xbt_dynar_t const dynar, const unsigned int n, const int idx);
+XBT_PUBLIC void xbt_dynar_insert_at(xbt_dynar_t const dynar, const int idx, const void* src);
+XBT_PUBLIC void xbt_dynar_remove_at(xbt_dynar_t const dynar, const int idx, void* const dst);
+XBT_PUBLIC void xbt_dynar_remove_n_at(xbt_dynar_t const dynar, const unsigned int n, const int idx);
-XBT_PUBLIC(unsigned int) xbt_dynar_search(xbt_dynar_t const dynar, void *elem);
-XBT_PUBLIC(signed int) xbt_dynar_search_or_negative(xbt_dynar_t const dynar, void *const elem);
-XBT_PUBLIC(int) xbt_dynar_member(xbt_dynar_t const dynar, void *elem);
-XBT_PUBLIC(void) xbt_dynar_sort(xbt_dynar_t const dynar, int_f_cpvoid_cpvoid_t compar_fn);
-XBT_PUBLIC(xbt_dynar_t) xbt_dynar_sort_strings(xbt_dynar_t dynar);
-XBT_PUBLIC(int) xbt_dynar_compare(xbt_dynar_t d1, xbt_dynar_t d2, int(*compar)(const void *, const void *));
-XBT_PUBLIC(void *) xbt_dynar_to_array (xbt_dynar_t dynar);
+XBT_PUBLIC unsigned int xbt_dynar_search(xbt_dynar_t const dynar, void* elem);
+XBT_PUBLIC signed int xbt_dynar_search_or_negative(xbt_dynar_t const dynar, void* const elem);
+XBT_PUBLIC int xbt_dynar_member(xbt_dynar_t const dynar, void* elem);
+XBT_PUBLIC void xbt_dynar_sort(xbt_dynar_t const dynar, int_f_cpvoid_cpvoid_t compar_fn);
+XBT_PUBLIC xbt_dynar_t xbt_dynar_sort_strings(xbt_dynar_t dynar);
+XBT_PUBLIC int xbt_dynar_compare(xbt_dynar_t d1, xbt_dynar_t d2, int (*compar)(const void*, const void*));
+XBT_PUBLIC void* xbt_dynar_to_array(xbt_dynar_t dynar);
/** @} */
/** @defgroup XBT_dynar_misc Dynar miscellaneous functions
* @{
*/
-XBT_PUBLIC(unsigned long) xbt_dynar_length(const xbt_dynar_t dynar);
-XBT_PUBLIC(int) xbt_dynar_is_empty(const xbt_dynar_t dynar);
-XBT_PUBLIC(void) xbt_dynar_reset(xbt_dynar_t const dynar);
-XBT_PUBLIC(void) xbt_dynar_merge(xbt_dynar_t *d1, xbt_dynar_t *d2);
+XBT_PUBLIC unsigned long xbt_dynar_length(const xbt_dynar_t dynar);
+XBT_PUBLIC int xbt_dynar_is_empty(const xbt_dynar_t dynar);
+XBT_PUBLIC void xbt_dynar_reset(xbt_dynar_t const dynar);
+XBT_PUBLIC void xbt_dynar_merge(xbt_dynar_t* d1, xbt_dynar_t* d2);
/** @} */
/** @defgroup XBT_dynar_perl Perl-like use of dynars
* @{
*/
-XBT_PUBLIC(void) xbt_dynar_push(xbt_dynar_t const dynar, const void *src);
-XBT_PUBLIC(void) xbt_dynar_pop(xbt_dynar_t const dynar, void *const dst);
-XBT_PUBLIC(void) xbt_dynar_unshift(xbt_dynar_t const dynar, const void *src);
-XBT_PUBLIC(void) xbt_dynar_shift(xbt_dynar_t const dynar, void *const dst);
-XBT_PUBLIC(void) xbt_dynar_map(const xbt_dynar_t dynar, void_f_pvoid_t const op);
+XBT_PUBLIC void xbt_dynar_push(xbt_dynar_t const dynar, const void* src);
+XBT_PUBLIC void xbt_dynar_pop(xbt_dynar_t const dynar, void* const dst);
+XBT_PUBLIC void xbt_dynar_unshift(xbt_dynar_t const dynar, const void* src);
+XBT_PUBLIC void xbt_dynar_shift(xbt_dynar_t const dynar, void* const dst);
+XBT_PUBLIC void xbt_dynar_map(const xbt_dynar_t dynar, void_f_pvoid_t const op);
/** @} */
/** @defgroup XBT_dynar_ctn Direct manipulation to the dynars content
* @{
*/
-XBT_PUBLIC(void *) xbt_dynar_set_at_ptr(const xbt_dynar_t dynar, const unsigned long idx);
-XBT_PUBLIC(void *) xbt_dynar_get_ptr(const xbt_dynar_t dynar, const unsigned long idx);
-XBT_PUBLIC(void *) xbt_dynar_insert_at_ptr(xbt_dynar_t const dynar, const int idx);
-XBT_PUBLIC(void *) xbt_dynar_push_ptr(xbt_dynar_t const dynar);
-XBT_PUBLIC(void *) xbt_dynar_pop_ptr(xbt_dynar_t const dynar);
+XBT_PUBLIC void* xbt_dynar_set_at_ptr(const xbt_dynar_t dynar, const unsigned long idx);
+XBT_PUBLIC void* xbt_dynar_get_ptr(const xbt_dynar_t dynar, const unsigned long idx);
+XBT_PUBLIC void* xbt_dynar_insert_at_ptr(xbt_dynar_t const dynar, const int idx);
+XBT_PUBLIC void* xbt_dynar_push_ptr(xbt_dynar_t const dynar);
+XBT_PUBLIC void* xbt_dynar_pop_ptr(xbt_dynar_t const dynar);
/** @} */
/** @defgroup XBT_dynar_speed Speed optimized access to dynars of scalars
* @{
*/
-XBT_PUBLIC(void) xbt_dynar_cursor_rm(xbt_dynar_t dynar, unsigned int *const cursor);
+XBT_PUBLIC void xbt_dynar_cursor_rm(xbt_dynar_t dynar, unsigned int* const cursor);
/*
* \warning DO NOT USE THIS STRUCTURE DIRECTLY! Instead, use the public interface:
void_f_pvoid_t free_f;
} s_xbt_dynar_t;
-static inline int _xbt_dynar_cursor_get(const xbt_dynar_t dynar, unsigned int idx, void *const dst)
+static inline int _xbt_dynar_cursor_get(const xbt_dynar_t dynar, unsigned int idx, void* const dst)
{
if (!dynar) /* iterating over a NULL dynar is a no-op */
return FALSE;
/** Get the name of a category
* @ingroup XBT_ex_c
*/
-XBT_PUBLIC(const char *) xbt_ex_catname(xbt_errcat_t cat);
+XBT_PUBLIC const char* xbt_ex_catname(xbt_errcat_t cat);
typedef struct xbt_ex xbt_ex_t;
/** Helper function used to throw exceptions in C */
-XBT_ATTRIB_NORETURN XBT_PUBLIC(void)
- _xbt_throw(char* message, xbt_errcat_t errcat, int value, const char* file, int line, const char* func);
+XBT_ATTRIB_NORETURN XBT_PUBLIC void _xbt_throw(char* message, xbt_errcat_t errcat, int value, const char* file,
+ int line, const char* func);
/** Builds and throws an exception
* @ingroup XBT_ex_c
#define DIE_IMPOSSIBLE xbt_die("The Impossible Did Happen (yet again)")
/** Display an exception */
-XBT_PUBLIC(void) xbt_ex_display(xbt_ex_t * e);
+XBT_PUBLIC void xbt_ex_display(xbt_ex_t* e);
SG_END_DECL()
*
* @ingroup XBT_ex_c
*/
-struct XBT_PUBLIC() xbt_ex :
- std::runtime_error,
- simgrid::xbt::WithContextException {
+struct XBT_PUBLIC xbt_ex : std::runtime_error, simgrid::xbt::WithContextException {
xbt_ex() :
std::runtime_error("")
-/* Copyright (c) 2006-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2006-2018. 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. */
} s_xbt_graph_t;
/* API */
-XBT_PUBLIC(xbt_graph_t) xbt_graph_new_graph(unsigned short int directed, void *data);
-XBT_PUBLIC(xbt_node_t) xbt_graph_new_node(xbt_graph_t g, void *data);
-XBT_PUBLIC(xbt_edge_t) xbt_graph_new_edge(xbt_graph_t g, xbt_node_t src, xbt_node_t dst, void *data);
-XBT_PUBLIC(void *) xbt_graph_node_get_data(xbt_node_t node);
-XBT_PUBLIC(void) xbt_graph_node_set_data(xbt_node_t node, void *data);
-XBT_PUBLIC(void *) xbt_graph_edge_get_data(xbt_edge_t edge);
-XBT_PUBLIC(void) xbt_graph_edge_set_data(xbt_edge_t edge, void *data);
+XBT_PUBLIC xbt_graph_t xbt_graph_new_graph(unsigned short int directed, void* data);
+XBT_PUBLIC xbt_node_t xbt_graph_new_node(xbt_graph_t g, void* data);
+XBT_PUBLIC xbt_edge_t xbt_graph_new_edge(xbt_graph_t g, xbt_node_t src, xbt_node_t dst, void* data);
+XBT_PUBLIC void* xbt_graph_node_get_data(xbt_node_t node);
+XBT_PUBLIC void xbt_graph_node_set_data(xbt_node_t node, void* data);
+XBT_PUBLIC void* xbt_graph_edge_get_data(xbt_edge_t edge);
+XBT_PUBLIC void xbt_graph_edge_set_data(xbt_edge_t edge, void* data);
-XBT_PUBLIC(xbt_edge_t) xbt_graph_get_edge(xbt_graph_t g, xbt_node_t src, xbt_node_t dst);
+XBT_PUBLIC xbt_edge_t xbt_graph_get_edge(xbt_graph_t g, xbt_node_t src, xbt_node_t dst);
-XBT_PUBLIC(void) xbt_graph_free_graph(xbt_graph_t g,
- void_f_pvoid_t node_free_function, void_f_pvoid_t edge_free_function, void_f_pvoid_t graph_free_function);
+XBT_PUBLIC void xbt_graph_free_graph(xbt_graph_t g, void_f_pvoid_t node_free_function,
+ void_f_pvoid_t edge_free_function, void_f_pvoid_t graph_free_function);
-XBT_PUBLIC(xbt_dynar_t) xbt_graph_get_nodes(xbt_graph_t g);
-XBT_PUBLIC(xbt_dynar_t) xbt_graph_get_edges(xbt_graph_t g);
-XBT_PUBLIC(xbt_dynar_t) xbt_graph_node_get_outedges(xbt_node_t n);
-XBT_PUBLIC(xbt_node_t) xbt_graph_edge_get_source(xbt_edge_t e);
-XBT_PUBLIC(xbt_node_t) xbt_graph_edge_get_target(xbt_edge_t e);
+XBT_PUBLIC xbt_dynar_t xbt_graph_get_nodes(xbt_graph_t g);
+XBT_PUBLIC xbt_dynar_t xbt_graph_get_edges(xbt_graph_t g);
+XBT_PUBLIC xbt_dynar_t xbt_graph_node_get_outedges(xbt_node_t n);
+XBT_PUBLIC xbt_node_t xbt_graph_edge_get_source(xbt_edge_t e);
+XBT_PUBLIC xbt_node_t xbt_graph_edge_get_target(xbt_edge_t e);
SG_END_DECL()
#endif /* XBT_GRAPH_H */
/* Functions you may call */
-XBT_PUBLIC(void) xbt_log_control_set(const char *cs);
+XBT_PUBLIC void xbt_log_control_set(const char* cs);
/* Forward declarations */
typedef struct xbt_log_appender_s s_xbt_log_appender_t;
*
* Programatically alters a category's threshold priority (don't use).
*/
-XBT_PUBLIC(void) xbt_log_threshold_set(xbt_log_category_t cat, e_xbt_log_priority_t thresholdPriority);
+XBT_PUBLIC void xbt_log_threshold_set(xbt_log_category_t cat, e_xbt_log_priority_t thresholdPriority);
/**
* \ingroup XBT_log_implem
*
* Programatically sets the category's appender. (the preferred interface is through xbt_log_control_set())
*/
-XBT_PUBLIC(void) xbt_log_appender_set(xbt_log_category_t cat, xbt_log_appender_t app);
+XBT_PUBLIC void xbt_log_appender_set(xbt_log_category_t cat, xbt_log_appender_t app);
/**
* \ingroup XBT_log_implem
* \param cat the category (not only its name, but the variable)
*
* Programatically sets the category's layout. (the preferred interface is through xbt_log_control_set())
*/
-XBT_PUBLIC(void) xbt_log_layout_set(xbt_log_category_t cat, xbt_log_layout_t lay);
+XBT_PUBLIC void xbt_log_layout_set(xbt_log_category_t cat, xbt_log_layout_t lay);
/**
* \ingroup XBT_log_implem
* Programatically sets whether the logging actions must be passed to the parent category.
* (the preferred interface is through xbt_log_control_set())
*/
-XBT_PUBLIC(void) xbt_log_additivity_set(xbt_log_category_t cat, int additivity);
+XBT_PUBLIC void xbt_log_additivity_set(xbt_log_category_t cat, int additivity);
/** @brief create a new simple layout
*
* This layout is not as flexible as the pattern one
*/
-XBT_PUBLIC(xbt_log_layout_t) xbt_log_layout_simple_new(char *arg);
-XBT_PUBLIC(xbt_log_layout_t) xbt_log_layout_format_new(char *arg);
-XBT_PUBLIC(xbt_log_appender_t) xbt_log_appender_file_new(char *arg);
-XBT_PUBLIC(xbt_log_appender_t) xbt_log_appender2_file_new(char *arg,int roll);
+XBT_PUBLIC xbt_log_layout_t xbt_log_layout_simple_new(char* arg);
+XBT_PUBLIC xbt_log_layout_t xbt_log_layout_format_new(char* arg);
+XBT_PUBLIC xbt_log_appender_t xbt_log_appender_file_new(char* arg);
+XBT_PUBLIC xbt_log_appender_t xbt_log_appender2_file_new(char* arg, int roll);
/* ********************************** */
/* Functions that you shouldn't call */
/* ********************************** */
-XBT_PUBLIC(void) xbt_log_init(int *argc, char **argv);
-XBT_PUBLIC(void) _xbt_log_event_log(xbt_log_event_t ev, const char *fmt, ...) XBT_ATTRIB_PRINTF(2, 3);
-XBT_PUBLIC(int) _xbt_log_cat_init(xbt_log_category_t category, e_xbt_log_priority_t priority);
+XBT_PUBLIC void xbt_log_init(int* argc, char** argv);
+XBT_PUBLIC void _xbt_log_event_log(xbt_log_event_t ev, const char* fmt, ...) XBT_ATTRIB_PRINTF(2, 3);
+XBT_PUBLIC int _xbt_log_cat_init(xbt_log_category_t category, e_xbt_log_priority_t priority);
#ifdef DLL_EXPORT
XBT_PUBLIC_DATA(s_xbt_log_category_t) _XBT_LOGV(XBT_LOG_ROOT_CAT);
-/* Copyright (c) 2016. The SimGrid Team. All rights reserved.*/
+/* Copyright (c) 2016, 2018. 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. */
*
* @ingroup XBT_ex
*/
-XBT_PUBLIC(void) logException(
- e_xbt_log_priority_t priority,
- const char* context, std::exception const& exception);
-
-XBT_PUBLIC(void) installExceptionHandler();
+XBT_PUBLIC void logException(e_xbt_log_priority_t priority, const char* context, std::exception const& exception);
+XBT_PUBLIC void installExceptionHandler();
}
}
/* xbt/mallocator.h -- api to recycle allocated objects */
-/* Copyright (c) 2006-2007, 2009-2010, 2012-2014. The SimGrid Team.
+/* Copyright (c) 2006-2007, 2009-2010, 2012-2014, 2018. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
*/
/** \brief Mallocator data type (opaque structure) */
typedef struct s_xbt_mallocator *xbt_mallocator_t;
-XBT_PUBLIC(xbt_mallocator_t) xbt_mallocator_new(int size, pvoid_f_void_t new_f, void_f_pvoid_t free_f,
- void_f_pvoid_t reset_f);
-XBT_PUBLIC(void) xbt_mallocator_free(xbt_mallocator_t mallocator);
+XBT_PUBLIC xbt_mallocator_t xbt_mallocator_new(int size, pvoid_f_void_t new_f, void_f_pvoid_t free_f,
+ void_f_pvoid_t reset_f);
+XBT_PUBLIC void xbt_mallocator_free(xbt_mallocator_t mallocator);
/** @} */
/* object handling */
*
* @{
*/
-XBT_PUBLIC(void *) xbt_mallocator_get(xbt_mallocator_t mallocator);
-XBT_PUBLIC(void) xbt_mallocator_release(xbt_mallocator_t mallocator, void *object);
+XBT_PUBLIC void* xbt_mallocator_get(xbt_mallocator_t mallocator);
+XBT_PUBLIC void xbt_mallocator_release(xbt_mallocator_t mallocator, void* object);
-XBT_PUBLIC(void) xbt_mallocator_initialization_is_done(int protect);
+XBT_PUBLIC void xbt_mallocator_initialization_is_done(int protect);
/** @} */
SG_END_DECL()
/* xbt.h - Public interface to the xbt (simgrid's toolbox) */
-/* Copyright (c) 2004-2015. The SimGrid Team.
+/* Copyright (c) 2004-2018. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
XBT_PUBLIC_DATA(int) xbt_pagebits;
/** Helps ensuring that header version (SIMGRID_VERSION_MAJOR and friends) and dynamic library version do match. */
-XBT_PUBLIC(void) sg_version_check(int lib_version_major,int lib_version_minor,int lib_version_patch);
+XBT_PUBLIC void sg_version_check(int lib_version_major, int lib_version_minor, int lib_version_patch);
/** Contains all the parameters we got from the command line */
XBT_PUBLIC_DATA(xbt_dynar_t) sg_cmdline;
*
* Similar to vasprintf(), but returns a pointer to the newly created string (or aborts on error).
*/
-XBT_PUBLIC(char *) bvprintf(const char *fmt, va_list ap);
+XBT_PUBLIC char* bvprintf(const char* fmt, va_list ap);
/** @brief print to allocated string
*
* Similar to asprintf(), but returns a pointer to the newly created string (or aborts on error).
*/
-XBT_PUBLIC(char *) bprintf(const char *fmt, ...) XBT_ATTRIB_PRINTF(1, 2);
+XBT_PUBLIC char* bprintf(const char* fmt, ...) XBT_ATTRIB_PRINTF(1, 2);
/** @} */
SG_END_DECL()
-/* Copyright (c) 2010-2015. The SimGrid Team.
+/* Copyright (c) 2010-2018. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
typedef struct mdesc *xbt_mheap_t;
/* Allocate SIZE bytes of memory (and memset it to 0). */
-XBT_PUBLIC( void ) *mmalloc(xbt_mheap_t md, size_t size);
+XBT_PUBLIC void* mmalloc(xbt_mheap_t md, size_t size);
/* Allocate SIZE bytes of memory (and don't mess with it) */
void *mmalloc_no_memset(xbt_mheap_t mdp, size_t size);
/* Re-allocate the previously allocated block in void*, making the new block SIZE bytes long. */
-XBT_PUBLIC( void ) *mrealloc(xbt_mheap_t md, void *ptr, size_t size);
+XBT_PUBLIC void* mrealloc(xbt_mheap_t md, void* ptr, size_t size);
/* Free a block allocated by `mmalloc', `mrealloc' or `mcalloc'. */
-XBT_PUBLIC( void ) mfree(xbt_mheap_t md, void *ptr);
+XBT_PUBLIC void mfree(xbt_mheap_t md, void* ptr);
-XBT_PUBLIC( xbt_mheap_t ) xbt_mheap_new(int fd, void *baseaddr);
+XBT_PUBLIC xbt_mheap_t xbt_mheap_new(int fd, void* baseaddr);
#define XBT_MHEAP_OPTION_MEMSET 1
-XBT_PUBLIC( xbt_mheap_t ) xbt_mheap_new_options(int fd, void *baseaddr, int options);
+XBT_PUBLIC xbt_mheap_t xbt_mheap_new_options(int fd, void* baseaddr, int options);
-XBT_PUBLIC( void ) xbt_mheap_destroy_no_free(xbt_mheap_t md);
+XBT_PUBLIC void xbt_mheap_destroy_no_free(xbt_mheap_t md);
-XBT_PUBLIC( void ) *xbt_mheap_destroy(xbt_mheap_t md);
+XBT_PUBLIC void* xbt_mheap_destroy(xbt_mheap_t md);
/* return the heap used when NULL is passed as first argument to any mm* function */
-XBT_PUBLIC( xbt_mheap_t ) mmalloc_get_default_md(void);
+XBT_PUBLIC xbt_mheap_t mmalloc_get_default_md(void);
/* To change the heap used when using the legacy version malloc/free/realloc and such */
xbt_mheap_t mmalloc_set_current_heap(xbt_mheap_t new_heap);
/* module - modularize the code */
-/* Copyright (c) 2004-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2004-2018. 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. */
SG_BEGIN_DECL()
-XBT_PUBLIC(void) xbt_init(int *argc, char **argv);
+XBT_PUBLIC void xbt_init(int* argc, char** argv);
SG_END_DECL()
/* xbt/replay_reader.h -- Tools to parse a replay file */
-/* Copyright (c) 2010, 2012-2015, 2017. The SimGrid Team.
+/* Copyright (c) 2010, 2012-2015, 2017-2018. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
static std::unordered_map<std::string, std::queue<ReplayAction*>*> action_queues;
XBT_PUBLIC_DATA(std::ifstream*) action_fs;
-XBT_PUBLIC(int) replay_runner(int argc, char* argv[]);
+XBT_PUBLIC int replay_runner(int argc, char* argv[]);
}
}
#endif
SG_BEGIN_DECL()
typedef void (*action_fun)(const char* const* args);
-XBT_PUBLIC(void) xbt_replay_action_register(const char* action_name, action_fun function);
-XBT_PUBLIC(action_fun) xbt_replay_action_get(const char* action_name);
+XBT_PUBLIC void xbt_replay_action_register(const char* action_name, action_fun function);
+XBT_PUBLIC action_fun xbt_replay_action_get(const char* action_name);
SG_END_DECL()
/* str.h - XBT string related functions. */
-/* Copyright (c) 2007-2017. The SimGrid Team.
+/* Copyright (c) 2007-2018. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
* @{
*/
-XBT_PUBLIC(xbt_dynar_t) xbt_str_split(const char *s, const char *sep);
-XBT_PUBLIC(xbt_dynar_t) xbt_str_split_quoted(const char *s);
-XBT_PUBLIC(xbt_dynar_t) xbt_str_split_quoted_in_place(char *s);
+XBT_PUBLIC xbt_dynar_t xbt_str_split(const char* s, const char* sep);
+XBT_PUBLIC xbt_dynar_t xbt_str_split_quoted(const char* s);
+XBT_PUBLIC xbt_dynar_t xbt_str_split_quoted_in_place(char* s);
-XBT_PUBLIC(char *) xbt_str_join_array(const char *const *strs, const char *sep);
+XBT_PUBLIC char* xbt_str_join_array(const char* const* strs, const char* sep);
-XBT_PUBLIC(long int) xbt_str_parse_int(const char* str, const char* error_msg);
-XBT_PUBLIC(double) xbt_str_parse_double(const char* str, const char* error_msg);
+XBT_PUBLIC long int xbt_str_parse_int(const char* str, const char* error_msg);
+XBT_PUBLIC double xbt_str_parse_double(const char* str, const char* error_msg);
#define XBT_DJB2_HASH_FUNCTION
//#define XBT_FNV_HASH_FUNCTION
/**
* @brief Returns the hash code of a string.
*/
-static inline unsigned int xbt_str_hash_ext(const char *str, int str_len)
+static inline unsigned int xbt_str_hash_ext(const char* str, int str_len)
{
#ifdef XBT_DJB2_HASH_FUNCTION
/* fast implementation of djb2 algorithm */
-/* Copyright (c) 2015-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2015-2018. 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. */
*
* @ingroup XBT_str
*/
-XBT_PUBLIC(std::string) string_printf(const char* fmt, ...);
+XBT_PUBLIC std::string string_printf(const char* fmt, ...);
/** Create a C++ string from a C-style format
*
* @ingroup XBT_str
*/
-XBT_PUBLIC(std::string) string_vprintf(const char* fmt, va_list ap);
+XBT_PUBLIC std::string string_vprintf(const char* fmt, va_list ap);
}
}
/* xbt/synchro.h -- Simulated synchronization */
-/* Copyright (c) 2009-2016. The SimGrid Team. */
+/* Copyright (c) 2009-2018. The SimGrid Team. */
/* 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. */
typedef struct s_smx_mutex_* xbt_mutex_t;
/** @brief Creates a new mutex variable */
-XBT_PUBLIC(xbt_mutex_t) xbt_mutex_init(void);
+XBT_PUBLIC xbt_mutex_t xbt_mutex_init(void);
/** @brief Blocks onto the given mutex variable */
-XBT_PUBLIC(void) xbt_mutex_acquire(xbt_mutex_t mutex);
+XBT_PUBLIC void xbt_mutex_acquire(xbt_mutex_t mutex);
/** @brief Tries to block onto the given mutex variable
* Tries to lock a mutex, return 1 if the mutex is unlocked, else 0.
* \param mutex The mutex
* \return 1 - mutex free, 0 - mutex used
*/
-XBT_PUBLIC(int) xbt_mutex_try_acquire(xbt_mutex_t mutex);
+XBT_PUBLIC int xbt_mutex_try_acquire(xbt_mutex_t mutex);
/** @brief Releases the given mutex variable */
-XBT_PUBLIC(void) xbt_mutex_release(xbt_mutex_t mutex);
+XBT_PUBLIC void xbt_mutex_release(xbt_mutex_t mutex);
/** @brief Destroyes the given mutex variable */
-XBT_PUBLIC(void) xbt_mutex_destroy(xbt_mutex_t mutex);
+XBT_PUBLIC void xbt_mutex_destroy(xbt_mutex_t mutex);
/** @brief Thread condition data type (opaque object)
* @hideinitializer
typedef struct s_smx_cond_* xbt_cond_t;
/** @brief Creates a condition variable */
-XBT_PUBLIC(xbt_cond_t) xbt_cond_init(void);
+XBT_PUBLIC xbt_cond_t xbt_cond_init(void);
/** @brief Blocks onto the given condition variable */
-XBT_PUBLIC(void) xbt_cond_wait(xbt_cond_t cond, xbt_mutex_t mutex);
+XBT_PUBLIC void xbt_cond_wait(xbt_cond_t cond, xbt_mutex_t mutex);
/** @brief Blocks onto the given condition variable, but only for the given amount of time.
* @return 0 on success, 1 on timeout */
-XBT_PUBLIC(int) xbt_cond_timedwait(xbt_cond_t cond, xbt_mutex_t mutex, double delay);
+XBT_PUBLIC int xbt_cond_timedwait(xbt_cond_t cond, xbt_mutex_t mutex, double delay);
/** @brief Signals the given mutex variable */
-XBT_PUBLIC(void) xbt_cond_signal(xbt_cond_t cond);
+XBT_PUBLIC void xbt_cond_signal(xbt_cond_t cond);
/** @brief Broadcasts the given mutex variable */
-XBT_PUBLIC(void) xbt_cond_broadcast(xbt_cond_t cond);
+XBT_PUBLIC void xbt_cond_broadcast(xbt_cond_t cond);
/** @brief Destroys the given mutex variable */
-XBT_PUBLIC(void) xbt_cond_destroy(xbt_cond_t cond);
+XBT_PUBLIC void xbt_cond_destroy(xbt_cond_t cond);
/** @} */
/* no system header should be loaded out of this file so that we have only */
/* one file to check when porting to another OS */
-/* Copyright (c) 2004-2017. The SimGrid Team.
+/* Copyright (c) 2004-2018. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
* @{
*/
/** @brief Kill the program in silence */
-XBT_ATTRIB_NORETURN XBT_PUBLIC(void) xbt_abort(void);
+XBT_ATTRIB_NORETURN XBT_PUBLIC void xbt_abort(void);
/**
* @brief Kill the program with an error message
return res;
}
-XBT_PUBLIC(void) xbt_backtrace_display_current();
+XBT_PUBLIC void xbt_backtrace_display_current();
/** @brief Like malloc, but xbt_die() on error
@hideinitializer */
#define xbt_free(p) free(p) /*nothing specific to do here. A poor valgrind replacement? */
/** @brief like free, but you can be sure that it is a function */
-XBT_PUBLIC(void) xbt_free_f(void *p);
+XBT_PUBLIC void xbt_free_f(void* p);
/** @brief should be given a pointer to pointer, and frees the second one */
-XBT_PUBLIC(void) xbt_free_ref(void *d);
+XBT_PUBLIC void xbt_free_ref(void* d);
SG_END_DECL()
/* virtu - virtualization layer for the logging to know about the actors */
-/* Copyright (c) 2007-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2007-2018. 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. */
SG_BEGIN_DECL()
-XBT_PUBLIC(const char*) xbt_procname(void);
+XBT_PUBLIC const char* xbt_procname(void);
-XBT_PUBLIC(int) xbt_getpid(void);
+XBT_PUBLIC int xbt_getpid(void);
/* Get the name of the UNIX process englobing the world */
XBT_PUBLIC_DATA(char*) xbt_binary_name;
/* xbt/xbt_os_thread.h -- Thread portability layer */
-/* Copyright (c) 2007-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2007-2018. 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. */
* @{
*/
-XBT_PUBLIC(int) xbt_os_get_numcores(void);
+XBT_PUBLIC int xbt_os_get_numcores(void);
- /** \brief Thread data type (opaque structure) */
+/** \brief Thread data type (opaque structure) */
typedef struct xbt_os_thread_ *xbt_os_thread_t;
-XBT_PUBLIC(xbt_os_thread_t) xbt_os_thread_create(const char *name, pvoid_f_pvoid_t start_routine, void *param, void *data);
-XBT_PUBLIC(void) xbt_os_thread_exit(int *retcode);
+XBT_PUBLIC xbt_os_thread_t xbt_os_thread_create(const char* name, pvoid_f_pvoid_t start_routine, void* param,
+ void* data);
+XBT_PUBLIC void xbt_os_thread_exit(int* retcode);
-XBT_PUBLIC(xbt_os_thread_t) xbt_os_thread_self(void);
-XBT_PUBLIC(const char *) xbt_os_thread_self_name(void);
-XBT_PUBLIC(void) xbt_os_thread_set_extra_data(void *data);
-XBT_PUBLIC(void *) xbt_os_thread_get_extra_data(void);
-XBT_PUBLIC(void) xbt_os_thread_key_create(xbt_os_thread_key_t* key);
-XBT_PUBLIC(void) xbt_os_thread_key_destroy(xbt_os_thread_key_t key);
-XBT_PUBLIC(void) xbt_os_thread_set_specific(xbt_os_thread_key_t key, void* value);
-XBT_PUBLIC(void*) xbt_os_thread_get_specific(xbt_os_thread_key_t key);
- /* xbt_os_thread_join frees the joined thread (ie the XBT wrapper around it, the OS frees the rest) */
-XBT_PUBLIC(void) xbt_os_thread_join(xbt_os_thread_t thread, void **thread_return);
-XBT_PUBLIC(void) xbt_os_thread_yield(void);
-XBT_PUBLIC(void) xbt_os_thread_setstacksize(int stack_size);
-XBT_PUBLIC(void) xbt_os_thread_setguardsize(int guard_size);
-XBT_PUBLIC(int) xbt_os_thread_bind(xbt_os_thread_t thread, int core);
-XBT_PUBLIC(int) xbt_os_thread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void));
+XBT_PUBLIC xbt_os_thread_t xbt_os_thread_self(void);
+XBT_PUBLIC const char* xbt_os_thread_self_name(void);
+XBT_PUBLIC void xbt_os_thread_set_extra_data(void* data);
+XBT_PUBLIC void* xbt_os_thread_get_extra_data(void);
+XBT_PUBLIC void xbt_os_thread_key_create(xbt_os_thread_key_t* key);
+XBT_PUBLIC void xbt_os_thread_key_destroy(xbt_os_thread_key_t key);
+XBT_PUBLIC void xbt_os_thread_set_specific(xbt_os_thread_key_t key, void* value);
+XBT_PUBLIC void* xbt_os_thread_get_specific(xbt_os_thread_key_t key);
+/* xbt_os_thread_join frees the joined thread (ie the XBT wrapper around it, the OS frees the rest) */
+XBT_PUBLIC void xbt_os_thread_join(xbt_os_thread_t thread, void** thread_return);
+XBT_PUBLIC void xbt_os_thread_yield(void);
+XBT_PUBLIC void xbt_os_thread_setstacksize(int stack_size);
+XBT_PUBLIC void xbt_os_thread_setguardsize(int guard_size);
+XBT_PUBLIC int xbt_os_thread_bind(xbt_os_thread_t thread, int core);
+XBT_PUBLIC int xbt_os_thread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void));
- /** \brief Thread mutex data type (opaque structure) */
+/** \brief Thread mutex data type (opaque structure) */
typedef struct xbt_os_mutex_ *xbt_os_mutex_t;
-XBT_PUBLIC(xbt_os_mutex_t) xbt_os_mutex_init(void);
-XBT_PUBLIC(void) xbt_os_mutex_acquire(xbt_os_mutex_t mutex);
-XBT_PUBLIC(void) xbt_os_mutex_release(xbt_os_mutex_t mutex);
-XBT_PUBLIC(void) xbt_os_mutex_destroy(xbt_os_mutex_t mutex);
+XBT_PUBLIC xbt_os_mutex_t xbt_os_mutex_init(void);
+XBT_PUBLIC void xbt_os_mutex_acquire(xbt_os_mutex_t mutex);
+XBT_PUBLIC void xbt_os_mutex_release(xbt_os_mutex_t mutex);
+XBT_PUBLIC void xbt_os_mutex_destroy(xbt_os_mutex_t mutex);
/** \brief Thread condition data type (opaque structure) */
typedef struct xbt_os_cond_ *xbt_os_cond_t;
-XBT_PUBLIC(xbt_os_cond_t) xbt_os_cond_init(void);
-XBT_PUBLIC(void) xbt_os_cond_wait(xbt_os_cond_t cond, xbt_os_mutex_t mutex);
-XBT_PUBLIC(void) xbt_os_cond_signal(xbt_os_cond_t cond);
-XBT_PUBLIC(void) xbt_os_cond_broadcast(xbt_os_cond_t cond);
-XBT_PUBLIC(void) xbt_os_cond_destroy(xbt_os_cond_t cond);
+XBT_PUBLIC xbt_os_cond_t xbt_os_cond_init(void);
+XBT_PUBLIC void xbt_os_cond_wait(xbt_os_cond_t cond, xbt_os_mutex_t mutex);
+XBT_PUBLIC void xbt_os_cond_signal(xbt_os_cond_t cond);
+XBT_PUBLIC void xbt_os_cond_broadcast(xbt_os_cond_t cond);
+XBT_PUBLIC void xbt_os_cond_destroy(xbt_os_cond_t cond);
/** \brief Semaphore data type (opaque structure) */
typedef struct xbt_os_sem_ *xbt_os_sem_t;
-XBT_PUBLIC(xbt_os_sem_t) xbt_os_sem_init(unsigned int value);
-XBT_PUBLIC(void) xbt_os_sem_acquire(xbt_os_sem_t sem);
-XBT_PUBLIC(void) xbt_os_sem_release(xbt_os_sem_t sem);
-XBT_PUBLIC(void) xbt_os_sem_destroy(xbt_os_sem_t sem);
+XBT_PUBLIC xbt_os_sem_t xbt_os_sem_init(unsigned int value);
+XBT_PUBLIC void xbt_os_sem_acquire(xbt_os_sem_t sem);
+XBT_PUBLIC void xbt_os_sem_release(xbt_os_sem_t sem);
+XBT_PUBLIC void xbt_os_sem_destroy(xbt_os_sem_t sem);
/** @} */
/* xbt/xbt_os_timer.h -- system dependency on time functions */
-/* Copyright (c) 2007-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2007-2018. 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. */
*
* gives the number of seconds since the Epoch (00:00:00 UTC, January 1, 1970).
*/
-XBT_PUBLIC(double) xbt_os_time(void);
-XBT_PUBLIC(void) xbt_os_sleep(double sec);
+XBT_PUBLIC double xbt_os_time(void);
+XBT_PUBLIC void xbt_os_sleep(double sec);
typedef struct s_xbt_os_timer *xbt_os_timer_t;
-XBT_PUBLIC(xbt_os_timer_t) xbt_os_timer_new(void);
-XBT_PUBLIC(void) xbt_os_timer_free(xbt_os_timer_t timer);
-XBT_PUBLIC(double) xbt_os_timer_elapsed(xbt_os_timer_t timer);
-XBT_PUBLIC(size_t) xbt_os_timer_size(void);
+XBT_PUBLIC xbt_os_timer_t xbt_os_timer_new(void);
+XBT_PUBLIC void xbt_os_timer_free(xbt_os_timer_t timer);
+XBT_PUBLIC double xbt_os_timer_elapsed(xbt_os_timer_t timer);
+XBT_PUBLIC size_t xbt_os_timer_size(void);
-XBT_PUBLIC(void) xbt_os_walltimer_start(xbt_os_timer_t timer);
-XBT_PUBLIC(void) xbt_os_walltimer_resume(xbt_os_timer_t timer);
-XBT_PUBLIC(void) xbt_os_walltimer_stop(xbt_os_timer_t timer);
+XBT_PUBLIC void xbt_os_walltimer_start(xbt_os_timer_t timer);
+XBT_PUBLIC void xbt_os_walltimer_resume(xbt_os_timer_t timer);
+XBT_PUBLIC void xbt_os_walltimer_stop(xbt_os_timer_t timer);
-XBT_PUBLIC(void) xbt_os_cputimer_start(xbt_os_timer_t timer);
-XBT_PUBLIC(void) xbt_os_cputimer_resume(xbt_os_timer_t timer);
-XBT_PUBLIC(void) xbt_os_cputimer_stop(xbt_os_timer_t timer);
+XBT_PUBLIC void xbt_os_cputimer_start(xbt_os_timer_t timer);
+XBT_PUBLIC void xbt_os_cputimer_resume(xbt_os_timer_t timer);
+XBT_PUBLIC void xbt_os_cputimer_stop(xbt_os_timer_t timer);
-XBT_PUBLIC(void) xbt_os_threadtimer_start(xbt_os_timer_t timer);
-XBT_PUBLIC(void) xbt_os_threadtimer_resume(xbt_os_timer_t timer);
-XBT_PUBLIC(void) xbt_os_threadtimer_stop(xbt_os_timer_t timer);
+XBT_PUBLIC void xbt_os_threadtimer_start(xbt_os_timer_t timer);
+XBT_PUBLIC void xbt_os_threadtimer_resume(xbt_os_timer_t timer);
+XBT_PUBLIC void xbt_os_threadtimer_stop(xbt_os_timer_t timer);
SG_END_DECL()
-/* Copyright (c) 2012-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2012-2018. 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. */
SG_BEGIN_DECL()
-XBT_PUBLIC(int) TRACE_start ();
-XBT_PUBLIC(int) TRACE_end ();
-XBT_PUBLIC(void) TRACE_global_init();
-XBT_PUBLIC(void) TRACE_help(int detailed);
+XBT_PUBLIC int TRACE_start();
+XBT_PUBLIC int TRACE_end();
+XBT_PUBLIC void TRACE_global_init();
+XBT_PUBLIC void TRACE_help(int detailed);
SG_END_DECL()
-/* Copyright (c) 2008-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2008-2018. 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. */
SG_BEGIN_DECL()
/********************************** Configuration of MC **************************************/
-extern XBT_PUBLIC(int) _sg_do_model_check;
+extern XBT_PUBLIC int _sg_do_model_check;
extern XBT_PRIVATE int _sg_do_model_check_record;
extern XBT_PRIVATE int _sg_mc_checkpoint;
-extern XBT_PUBLIC(int) _sg_mc_sparse_checkpoint;
-extern XBT_PUBLIC(int) _sg_mc_ksm;
+extern XBT_PUBLIC int _sg_mc_sparse_checkpoint;
+extern XBT_PUBLIC int _sg_mc_ksm;
extern XBT_PRIVATE int _sg_mc_timeout;
extern XBT_PRIVATE int _sg_mc_hash;
extern XBT_PRIVATE int _sg_mc_max_depth;
-extern XBT_PUBLIC(int) _sg_mc_max_visited_states;
-extern XBT_PUBLIC(int) _sg_mc_comms_determinism;
-extern XBT_PUBLIC(int) _sg_mc_send_determinism;
+extern XBT_PUBLIC int _sg_mc_max_visited_states;
+extern XBT_PUBLIC int _sg_mc_comms_determinism;
+extern XBT_PUBLIC int _sg_mc_send_determinism;
extern XBT_PRIVATE int _sg_mc_snapshot_fds;
extern XBT_PRIVATE int _sg_mc_termination;
XBT_PRIVATE void _mc_cfg_cb_send_determinism(const char *name);
XBT_PRIVATE void _mc_cfg_cb_termination(const char *name);
-XBT_PUBLIC(void) MC_run();
-XBT_PUBLIC(void) MC_process_clock_add(smx_actor_t, double);
-XBT_PUBLIC(double) MC_process_clock_get(smx_actor_t);
+XBT_PUBLIC void MC_run();
+XBT_PUBLIC void MC_process_clock_add(smx_actor_t, double);
+XBT_PUBLIC double MC_process_clock_get(smx_actor_t);
XBT_PRIVATE void MC_automaton_load(const char *file);
/********************************* Memory *************************************/
-XBT_PUBLIC(void) MC_memory_init(); /* Initialize the memory subsystem */
+XBT_PUBLIC void MC_memory_init(); /* Initialize the memory subsystem */
SG_END_DECL()
-/* Copyright (c) 2012-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2012-2018. 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. */
XBT_PUBLIC_DATA(int) _sg_cfg_init_status;
XBT_PUBLIC_DATA(int) _sg_cfg_exit_asap;
-XBT_PUBLIC(void) sg_config_init(int *argc, char **argv);
-XBT_PUBLIC(void) sg_config_finalize();
+XBT_PUBLIC void sg_config_init(int* argc, char** argv);
+XBT_PUBLIC void sg_config_finalize();
SG_END_DECL()
};
typedef struct surf_model_description s_surf_model_description_t;
-XBT_PUBLIC(int) find_model_description(s_surf_model_description_t* table, std::string name);
-XBT_PUBLIC(void) model_help(const char* category, s_surf_model_description_t* table);
+XBT_PUBLIC int find_model_description(s_surf_model_description_t* table, std::string name);
+XBT_PUBLIC void model_help(const char* category, s_surf_model_description_t* table);
/***************************/
/* Generic model object */
* @param model The model from which the action is extracted
* @return An action in done state
*/
-XBT_PUBLIC(simgrid::kernel::resource::Action*)
+XBT_PUBLIC simgrid::kernel::resource::Action*
surf_model_extract_done_action_set(simgrid::kernel::resource::Model* model);
/**
* @param model The model from which the action is extracted
* @return An action in failed state
*/
-XBT_PUBLIC(simgrid::kernel::resource::Action*)
+XBT_PUBLIC simgrid::kernel::resource::Action*
surf_model_extract_failed_action_set(simgrid::kernel::resource::Model* model);
/**
* @param model The model
* @return The size of the running action set
*/
-XBT_PUBLIC(int) surf_model_running_action_set_size(simgrid::kernel::resource::Model* model);
+XBT_PUBLIC int surf_model_running_action_set_size(simgrid::kernel::resource::Model* model);
/**
* @brief [brief description]
* @param action The surf cpu action
* @param bound [description]
*/
-XBT_PUBLIC(void) surf_cpu_action_set_bound(simgrid::kernel::resource::Action* action, double bound);
+XBT_PUBLIC void surf_cpu_action_set_bound(simgrid::kernel::resource::Action* action, double bound);
/** @} */
*
* You shouldn't have to call it by yourself.
*/
-XBT_PUBLIC(void) surf_cpu_model_init_Cas01();
+XBT_PUBLIC void surf_cpu_model_init_Cas01();
/** \ingroup SURF_models
* \brief Initializes the CPU model with trace integration [Deprecated]
*
* You shouldn't have to call it by yourself.
*/
-XBT_PUBLIC(void) surf_cpu_model_init_ti();
+XBT_PUBLIC void surf_cpu_model_init_ti();
/** \ingroup SURF_models
* \brief The list of all available optimization modes (both for cpu and networks).
*
* \see surf_host_model_init_SMPI()
*/
-XBT_PUBLIC(void) surf_network_model_init_SMPI();
+XBT_PUBLIC void surf_network_model_init_SMPI();
/** \ingroup SURF_models
* \brief Same as network model 'LagrangeVelho', only with different correction factors.
*
* \see surf_host_model_init_IB()
*/
-XBT_PUBLIC(void) surf_network_model_init_IB();
+XBT_PUBLIC void surf_network_model_init_IB();
/** \ingroup SURF_models
* \brief Initializes the platform with the network model 'LegrandVelho'
*
* \see surf_host_model_init_LegrandVelho()
*/
-XBT_PUBLIC(void) surf_network_model_init_LegrandVelho();
+XBT_PUBLIC void surf_network_model_init_LegrandVelho();
/** \ingroup SURF_models
* \brief Initializes the platform with the network model 'Constant'
*
* \see surf_host_model_init_compound()
*/
-XBT_PUBLIC(void) surf_network_model_init_Constant();
+XBT_PUBLIC void surf_network_model_init_Constant();
/** \ingroup SURF_models
* \brief Initializes the platform with the network model CM02
* You sould call this function by yourself only if you plan using surf_host_model_init_compound.
* See comments in the code for more information.
*/
-XBT_PUBLIC(void) surf_network_model_init_CM02();
+XBT_PUBLIC void surf_network_model_init_CM02();
/** \ingroup SURF_models
* \brief Initializes the platform with the network model NS3
*
* \see surf_host_model_init_NS3()
*/
-XBT_PUBLIC(void) surf_network_model_init_NS3();
+XBT_PUBLIC void surf_network_model_init_NS3();
/** \ingroup SURF_models
* \brief Initializes the platform with the network model Reno
*
* Call this function only if you plan using surf_host_model_init_compound.
*/
-XBT_PUBLIC(void) surf_network_model_init_Reno();
+XBT_PUBLIC void surf_network_model_init_Reno();
/** \ingroup SURF_models
* \brief Initializes the platform with the network model Reno2
*
* Call this function only if you plan using surf_host_model_init_compound.
*/
-XBT_PUBLIC(void) surf_network_model_init_Reno2();
+XBT_PUBLIC void surf_network_model_init_Reno2();
/** \ingroup SURF_models
* \brief Initializes the platform with the network model Vegas
*
* Call this function only if you plan using surf_host_model_init_compound.
*/
-XBT_PUBLIC(void) surf_network_model_init_Vegas();
+XBT_PUBLIC void surf_network_model_init_Vegas();
/** \ingroup SURF_models
* \brief The list of all available network model models
/** \ingroup SURF_models
* \brief The storage model
*/
-XBT_PUBLIC(void) surf_storage_model_init_default();
+XBT_PUBLIC void surf_storage_model_init_default();
/** \ingroup SURF_models
* \brief The list of all available storage modes.
*
* This function should be called after a cpu_model and a network_model have been set up.
*/
-XBT_PUBLIC(void) surf_host_model_init_compound();
+XBT_PUBLIC void surf_host_model_init_compound();
/** \ingroup SURF_models
* \brief Initializes the platform with the current best network and cpu models at hand
* traffic support) and the CPU model with the model Cas01.
* Such model is subject to modification with warning in the ChangeLog so monitor it!
*/
-XBT_PUBLIC(void) surf_host_model_init_current_default();
+XBT_PUBLIC void surf_host_model_init_current_default();
/** \ingroup SURF_models
* \brief Initializes the platform with the model L07
* With this model, only parallel tasks can be used. Resource sharing is done by identifying bottlenecks and giving an
* equal share of the model to each action.
*/
-XBT_PUBLIC(void) surf_host_model_init_ptask_L07();
+XBT_PUBLIC void surf_host_model_init_ptask_L07();
/** \ingroup SURF_models
* \brief The list of all available host model models
* traffic support) and the CPU model with the model Cas01.
* Such model is subject to modification with warning in the ChangeLog so monitor it!
*/
-XBT_PUBLIC(void) surf_vm_model_init_HL13();
+XBT_PUBLIC void surf_vm_model_init_HL13();
/*** SURF Globals **************************/
*
* \see surf_host_model_init_CM02(), surf_host_model_init_compound(), surf_exit()
*/
-XBT_PUBLIC(void) surf_init(int* argc, char** argv); /* initialize common structures */
+XBT_PUBLIC void surf_init(int* argc, char** argv); /* initialize common structures */
/** \ingroup SURF_simulation
* \brief Finish simulation initialization
*
* This function must be called before the first call to surf_solve()
*/
-XBT_PUBLIC(void) surf_presolve();
+XBT_PUBLIC void surf_presolve();
/** \ingroup SURF_simulation
* \brief Performs a part of the simulation
* when you call surf_solve.
* Note that the returned elapsed time can be zero.
*/
-XBT_PUBLIC(double) surf_solve(double max_date);
+XBT_PUBLIC double surf_solve(double max_date);
/** \ingroup SURF_simulation
* \brief Return the current time
*
* Return the current time in millisecond.
*/
-XBT_PUBLIC(double) surf_get_clock();
+XBT_PUBLIC double surf_get_clock();
/** \ingroup SURF_simulation
* \brief Exit SURF
*
* \see surf_init()
*/
-XBT_PUBLIC(void) surf_exit();
+XBT_PUBLIC void surf_exit();
/* surf parse file related (public because called from a test suite) */
-XBT_PUBLIC(void) parse_platform_file(const char* file);
+XBT_PUBLIC void parse_platform_file(const char* file);
/********** Tracing **********/
XBT_PRIVATE int TRACE_precision();
/* Public functions used in SMPI */
-XBT_PUBLIC(bool) TRACE_smpi_is_enabled();
-XBT_PUBLIC(bool) TRACE_smpi_is_grouped();
-XBT_PUBLIC(bool) TRACE_smpi_is_computing();
-XBT_PUBLIC(bool) TRACE_smpi_is_sleeping();
-XBT_PUBLIC(bool) TRACE_smpi_view_internals();
+XBT_PUBLIC bool TRACE_smpi_is_enabled();
+XBT_PUBLIC bool TRACE_smpi_is_grouped();
+XBT_PUBLIC bool TRACE_smpi_is_computing();
+XBT_PUBLIC bool TRACE_smpi_is_sleeping();
+XBT_PUBLIC bool TRACE_smpi_view_internals();
/* from resource_utilization.c */
XBT_PRIVATE void TRACE_surf_host_set_utilization(const char* resource, const char* category, double value, double now,
-/* Copyright (c) 2007-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2007-2018. 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. */
virtual void post() =0; // What to do when a simcall terminates
// boost::intrusive_ptr<ActivityImpl> support:
- friend XBT_PUBLIC(void) intrusive_ptr_add_ref(ActivityImpl * activity);
- friend XBT_PUBLIC(void) intrusive_ptr_release(ActivityImpl * activity);
+ friend XBT_PUBLIC void intrusive_ptr_add_ref(ActivityImpl * activity);
+ friend XBT_PUBLIC void intrusive_ptr_release(ActivityImpl * activity);
private:
std::atomic_int_fast32_t refcount_{0};
-/* Copyright (c) 2012-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2012-2018. 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. */
namespace kernel {
namespace activity {
-class XBT_PUBLIC() MutexImpl {
+class XBT_PUBLIC MutexImpl {
public:
MutexImpl();
~MutexImpl();
-/* Copyright (c) 2007-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2007-2018. 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. */
XBT_PRIVATE void SIMIX_context_mod_init();
XBT_PRIVATE void SIMIX_context_mod_exit();
-XBT_PUBLIC(smx_context_t)
-SIMIX_context_new(std::function<void()> code, void_pfn_smxprocess_t cleanup_func, smx_actor_t simix_process);
+XBT_PUBLIC smx_context_t SIMIX_context_new(std::function<void()> code, void_pfn_smxprocess_t cleanup_func,
+ smx_actor_t simix_process);
#ifndef WIN32
XBT_PUBLIC_DATA(char sigsegv_stack[SIGSTKSZ]);
/** @brief Executes all the processes to run (in parallel if possible). */
XBT_PRIVATE void SIMIX_context_runall();
/** @brief returns the current running context */
-XBT_PUBLIC(smx_context_t) SIMIX_context_self(); // public because it's used in simgrid-java
+XBT_PUBLIC smx_context_t SIMIX_context_self(); // public because it's used in simgrid-java
XBT_PRIVATE void *SIMIX_context_stack_new();
XBT_PRIVATE void SIMIX_context_stack_delete(void *stack);
-XBT_PUBLIC(void) SIMIX_context_set_current(smx_context_t context);
+XBT_PUBLIC void SIMIX_context_set_current(smx_context_t context);
XBT_PRIVATE smx_context_t SIMIX_context_get_current();
-XBT_PUBLIC(int) SIMIX_process_get_maxpid();
+XBT_PUBLIC int SIMIX_process_get_maxpid();
XBT_PRIVATE void SIMIX_post_create_environment();
}
* @brief Solve the lmm system
* @param sys The lmm system to solve
*/
-XBT_PUBLIC(void) lmm_solve(lmm_system_t sys);
+XBT_PUBLIC void lmm_solve(lmm_system_t sys);
-XBT_PUBLIC(void) lagrange_solve(lmm_system_t sys);
-XBT_PUBLIC(void) bottleneck_solve(lmm_system_t sys);
+XBT_PUBLIC void lagrange_solve(lmm_system_t sys);
+XBT_PUBLIC void bottleneck_solve(lmm_system_t sys);
/** Default functions associated to the chosen protocol. When using the lagrangian approach. */
-XBT_PUBLIC(void)
-set_default_protocol_function(double (*func_f)(const Variable& var, double x),
- double (*func_fp)(const Variable& var, double x),
- double (*func_fpi)(const Variable& var, double x));
+XBT_PUBLIC void set_default_protocol_function(double (*func_f)(const Variable& var, double x),
+ double (*func_fp)(const Variable& var, double x),
+ double (*func_fpi)(const Variable& var, double x));
-XBT_PUBLIC(double) func_reno_f(const Variable& var, double x);
-XBT_PUBLIC(double) func_reno_fp(const Variable& var, double x);
-XBT_PUBLIC(double) func_reno_fpi(const Variable& var, double x);
+XBT_PUBLIC double func_reno_f(const Variable& var, double x);
+XBT_PUBLIC double func_reno_fp(const Variable& var, double x);
+XBT_PUBLIC double func_reno_fpi(const Variable& var, double x);
-XBT_PUBLIC(double) func_reno2_f(const Variable& var, double x);
-XBT_PUBLIC(double) func_reno2_fp(const Variable& var, double x);
-XBT_PUBLIC(double) func_reno2_fpi(const Variable& var, double x);
+XBT_PUBLIC double func_reno2_f(const Variable& var, double x);
+XBT_PUBLIC double func_reno2_fp(const Variable& var, double x);
+XBT_PUBLIC double func_reno2_fpi(const Variable& var, double x);
-XBT_PUBLIC(double) func_vegas_f(const Variable& var, double x);
-XBT_PUBLIC(double) func_vegas_fp(const Variable& var, double x);
-XBT_PUBLIC(double) func_vegas_fpi(const Variable& var, double x);
+XBT_PUBLIC double func_vegas_f(const Variable& var, double x);
+XBT_PUBLIC double func_vegas_fp(const Variable& var, double x);
+XBT_PUBLIC double func_vegas_fpi(const Variable& var, double x);
/**
* @brief LMM element
-/* Copyright (c) 2013-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2013-2018. 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. */
}
}
-XBT_PUBLIC(sg_netpoint_t) sg_netpoint_by_name_or_null(const char* name);
+XBT_PUBLIC sg_netpoint_t sg_netpoint_by_name_or_null(const char* name);
#endif /* KERNEL_ROUTING_NETPOINT_HPP_ */
-/* Copyright (c) 2016-2017. The SimGrid Team.
+/* Copyright (c) 2016-2018. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
Session& getSession() { return *session_; }
};
-XBT_PUBLIC() Checker* createLivenessChecker(Session& session);
-XBT_PUBLIC() Checker* createSafetyChecker(Session& session);
-XBT_PUBLIC() Checker* createCommunicationDeterminismChecker(Session& session);
-
+XBT_PUBLIC Checker* createLivenessChecker(Session& session);
+XBT_PUBLIC Checker* createSafetyChecker(Session& session);
+XBT_PUBLIC Checker* createCommunicationDeterminismChecker(Session& session);
}
}
-/* Copyright (c) 2015-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2015-2018. 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 <ucontext.h> /* context relative declarations */
SG_BEGIN_DECL();
-XBT_PUBLIC(void) MC_register_stack_area(void *stack, smx_actor_t process, ucontext_t* context, size_t size);
+XBT_PUBLIC void MC_register_stack_area(void* stack, smx_actor_t process, ucontext_t* context, size_t size);
SG_END_DECL();
#endif
-/* Copyright (c) 2015-2017. The SimGrid Team.
+/* Copyright (c) 2015-2018. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
*
* Send messages to the model-checker and handles message from it.
*/
-class XBT_PUBLIC() Client {
+class XBT_PUBLIC Client {
private:
Channel channel_;
static std::unique_ptr<Client> instance_;
-/* Copyright (c) 2004-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2004-2018. 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. */
* \brief Sets a cleanup function to be called to free the userdata of a process when a process is destroyed.
* \param data_cleanup a cleanup function for the userdata of a process, or nullptr to call no function
*/
-XBT_PUBLIC(void) MSG_process_set_data_cleanup(void_f_pvoid_t data_cleanup) {
+XBT_PUBLIC void MSG_process_set_data_cleanup(void_f_pvoid_t data_cleanup)
+{
msg_global->process_data_cleanup = data_cleanup;
}
* \brief Sets the "auto-restart" flag of the process.
* If the flag is set to 1, the process will be automatically restarted when its host comes back up.
*/
-XBT_PUBLIC(void) MSG_process_auto_restart_set(msg_process_t process, int auto_restart) {
+XBT_PUBLIC void MSG_process_auto_restart_set(msg_process_t process, int auto_restart)
+{
process->setAutoRestart(auto_restart);
}
/**
* \ingroup m_process_management
* \brief Restarts a process from the beginning.
*/
-XBT_PUBLIC(msg_process_t) MSG_process_restart(msg_process_t process) {
+XBT_PUBLIC msg_process_t MSG_process_restart(msg_process_t process)
+{
return process->restart();
}
/** @ingroup m_process_management
* @brief This process will be terminated automatically when the last non-daemon process finishes
*/
-XBT_PUBLIC(void) MSG_process_daemonize(msg_process_t process)
+XBT_PUBLIC void MSG_process_daemonize(msg_process_t process)
{
process->daemonize();
}
/** @ingroup m_process_management
* @brief Take an extra reference on that process to prevent it to be garbage-collected
*/
-XBT_PUBLIC(void) MSG_process_ref(msg_process_t process)
+XBT_PUBLIC void MSG_process_ref(msg_process_t process)
{
intrusive_ptr_add_ref(process);
}
/** @ingroup m_process_management
* @brief Release a reference on that process so that it can get be garbage-collected
*/
-XBT_PUBLIC(void) MSG_process_unref(msg_process_t process)
+XBT_PUBLIC void MSG_process_unref(msg_process_t process)
{
intrusive_ptr_release(process);
}
-/* Copyright (c) 2006-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2006-2018. 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. */
simgrid::simix::kernelImmediate([] { /* do nothing*/ });
}
-XBT_PUBLIC(void) sleep_until(double timeout)
+XBT_PUBLIC void sleep_until(double timeout)
{
double now = SIMIX_get_clock();
if (timeout > now)
#define _FLEXML_dax_H
/* XML application entry points. */
-XBT_PUBLIC(void) STag_dax__adag(void);
-XBT_PUBLIC(void) ETag_dax__adag(void);
-XBT_PUBLIC(void) STag_dax__child(void);
-XBT_PUBLIC(void) ETag_dax__child(void);
-XBT_PUBLIC(void) STag_dax__job(void);
-XBT_PUBLIC(void) ETag_dax__job(void);
-XBT_PUBLIC(void) STag_dax__parent(void);
-XBT_PUBLIC(void) ETag_dax__parent(void);
-XBT_PUBLIC(void) STag_dax__uses(void);
-XBT_PUBLIC(void) ETag_dax__uses(void);
+XBT_PUBLIC void STag_dax__adag(void);
+XBT_PUBLIC void ETag_dax__adag(void);
+XBT_PUBLIC void STag_dax__child(void);
+XBT_PUBLIC void ETag_dax__child(void);
+XBT_PUBLIC void STag_dax__job(void);
+XBT_PUBLIC void ETag_dax__job(void);
+XBT_PUBLIC void STag_dax__parent(void);
+XBT_PUBLIC void ETag_dax__parent(void);
+XBT_PUBLIC void STag_dax__uses(void);
+XBT_PUBLIC void ETag_dax__uses(void);
/* XML application data. */
typedef int AT_dax__adag_childCount;
XBT_PUBLIC_DATA(short int) dax__uses_type_isset;
/* XML application utilities. */
-XBT_PUBLIC(int) dax__element_context(int);
+XBT_PUBLIC int dax__element_context(int);
/* XML processor entry point. */
-XBT_PUBLIC(int) yylex(void);
+XBT_PUBLIC int yylex(void);
/* Flexml error handling function (useful only when -q flag passed to flexml) */
const char * dax__parse_err_msg(void);
/* */
/* This is somehow the "libc" of SimGrid */
-/* Copyright (c) 2010-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2010-2018. 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. */
* \brief Add an on_exit function
* Add an on_exit function which will be executed when the process exits/is killed.
*/
-XBT_PUBLIC(void) simcall_process_on_exit(smx_actor_t process, int_f_pvoid_pvoid_t fun, void *data)
+XBT_PUBLIC void simcall_process_on_exit(smx_actor_t process, int_f_pvoid_pvoid_t fun, void* data)
{
simcall_BODY_process_on_exit(process, fun, data);
}
simgrid::xbt::signal<void()> onDeadlock;
-XBT_PUBLIC(void) set_maestro(std::function<void()> code)
+XBT_PUBLIC void set_maestro(std::function<void()> code)
{
maestro_code = std::move(code);
}
-/* Copyright (c) 2007-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2007-2018. 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. */
namespace simix {
class Global {
- friend XBT_PUBLIC(bool) simgrid::s4u::this_actor::isMaestro();
+ friend XBT_PUBLIC bool simgrid::s4u::this_actor::isMaestro();
public:
smx_context_factory_t context_factory = nullptr;
XBT_PUBLIC_DATA(std::unique_ptr<simgrid::simix::Global>) simix_global;
-XBT_PUBLIC(void) SIMIX_clean();
+XBT_PUBLIC void SIMIX_clean();
/******************************** Exceptions *********************************/
/** @brief Ask to the provided ActorImpl to raise the provided exception */
/* This is the tuning used by MVAPICH for Stampede platform based on (MV2_ARCH_INTEL_XEON_E5_2680_16,
* MV2_HCA_MLX_CX_FDR) */
-/* Copyright (c) 2009-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2009-2018. 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. */
#define MV2_MAX_NB_THRESHOLDS 32
-XBT_PUBLIC(void) smpi_coll_cleanup_mvapich2(void);
+XBT_PUBLIC void smpi_coll_cleanup_mvapich2(void);
struct mv2_alltoall_tuning_element {
int min;
/** @brief Returns the last call location (filename, linenumber). Process-specific. */
extern "C" {
-XBT_PUBLIC(smpi_trace_call_location_t*) smpi_trace_get_call_location();
+XBT_PUBLIC smpi_trace_call_location_t* smpi_trace_get_call_location();
}
enum smpi_priv_strategies {
/*High level handling of collective algorithms*/
-/* Copyright (c) 2009-2010, 2012-2017. The SimGrid Team.
+/* Copyright (c) 2009-2010, 2012-2018. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
class Colls{
public:
- static XBT_PUBLIC(void) coll_help(const char *category, s_mpi_coll_description_t * table);
- static XBT_PUBLIC(int) find_coll_description(s_mpi_coll_description_t* table, std::string name, const char* desc);
+ static XBT_PUBLIC void coll_help(const char* category, s_mpi_coll_description_t* table);
+ static XBT_PUBLIC int find_coll_description(s_mpi_coll_description_t* table, std::string name, const char* desc);
static void set_collectives();
// for each collective type, create the set_* prototype, the description array and the function pointer
};
}
-XBT_PUBLIC(std::vector<s_smpi_factor_t>) parse_factor(std::string smpi_coef_string);
+XBT_PUBLIC std::vector<s_smpi_factor_t> parse_factor(std::string smpi_coef_string);
#endif
-/* Copyright (c) 2007, 2009-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2007, 2009-2018. 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. */
shared_malloc_type smpi_cfg_shared_malloc = shmalloc_global;
double smpi_total_benched_time = 0;
-extern "C" XBT_PUBLIC(void) smpi_execute_flops_(double *flops);
+extern "C" XBT_PUBLIC void smpi_execute_flops_(double* flops);
void smpi_execute_flops_(double *flops)
{
smpi_execute_flops(*flops);
}
-extern "C" XBT_PUBLIC(void) smpi_execute_(double *duration);
+extern "C" XBT_PUBLIC void smpi_execute_(double* duration);
void smpi_execute_(double *duration)
{
smpi_execute(*duration);
-/* Copyright (c) 2013-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2013-2018. 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. */
doublereal i;
};
-extern "C" XBT_PUBLIC(doublereal) smpi_get_host_power_peak_at_(integer *pstate_index);
+extern "C" XBT_PUBLIC doublereal smpi_get_host_power_peak_at_(integer* pstate_index);
doublereal smpi_get_host_power_peak_at_(integer *pstate_index)
{
return static_cast<doublereal>(smpi_get_host_power_peak_at((int)*pstate_index));
}
-extern "C" XBT_PUBLIC(doublereal) smpi_get_host_current_power_peak_();
+extern "C" XBT_PUBLIC doublereal smpi_get_host_current_power_peak_();
doublereal smpi_get_host_current_power_peak_()
{
return smpi_get_host_current_power_peak();
}
-extern "C" XBT_PUBLIC(integer) smpi_get_host_nb_pstates_();
+extern "C" XBT_PUBLIC integer smpi_get_host_nb_pstates_();
integer smpi_get_host_nb_pstates_()
{
return static_cast<integer>(smpi_get_host_nb_pstates());
}
-extern "C" XBT_PUBLIC(void) smpi_set_host_pstate_(integer *pstate_index);
+extern "C" XBT_PUBLIC void smpi_set_host_pstate_(integer* pstate_index);
void smpi_set_host_pstate_(integer *pstate_index)
{
smpi_set_host_pstate(static_cast<int>(*pstate_index));
}
-extern "C" XBT_PUBLIC(doublereal) smpi_get_host_consumed_energy_();
+extern "C" XBT_PUBLIC doublereal smpi_get_host_consumed_energy_();
doublereal smpi_get_host_consumed_energy_()
{
return static_cast<doublereal>(smpi_get_host_consumed_energy());
-/* Copyright (c) 2004-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2004-2018. 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. */
*/
XBT_PUBLIC_CLASS CpuAction : public simgrid::kernel::resource::Action
{
- friend XBT_PUBLIC(Cpu*) getActionCpu(CpuAction* action);
+ friend XBT_PUBLIC Cpu* getActionCpu(CpuAction * action);
public:
/** @brief Signal emitted when the action state changes (ready/running/done, etc)
ns3::Ptr<ns3::Node> ns3Node_;
};
-XBT_PUBLIC(void) ns3_initialize(std::string TcpProtocol);
+XBT_PUBLIC void ns3_initialize(std::string TcpProtocol);
extern "C" {
-XBT_PUBLIC(void) ns3_simulator(double maxSeconds);
-XBT_PUBLIC(void) ns3_add_link(NetPointNs3* src, NetPointNs3* dst, double bw, double lat);
-XBT_PUBLIC(void) ns3_add_cluster(const char* id, double bw, double lat);
+XBT_PUBLIC void ns3_simulator(double maxSeconds);
+XBT_PUBLIC void ns3_add_link(NetPointNs3* src, NetPointNs3* dst, double bw, double lat);
+XBT_PUBLIC void ns3_add_cluster(const char* id, double bw, double lat);
}
class XBT_PRIVATE SgFlow {
}
extern "C" {
-XBT_PUBLIC(double) surf_get_clock();
+XBT_PUBLIC double surf_get_clock();
}
/** \ingroup SURF_simulation
* \brief List of hosts that have just restarted and whose autorestart process should be restarted.
extern XBT_PRIVATE simgrid::trace_mgr::future_evt_set* future_evt_set;
-XBT_PUBLIC(void) storage_register_callbacks();
+XBT_PUBLIC void storage_register_callbacks();
XBT_PRIVATE void parse_after_config();
-/* Copyright (c) 2004-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2004-2018. 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. */
* This flag indicates whether the structure is still used somewhere or not.
* When the structure is freed, the argument is set to nullptr
*/
-XBT_PUBLIC(void) tmgr_trace_event_unref(tmgr_trace_event_t* trace_event);
+XBT_PUBLIC void tmgr_trace_event_unref(tmgr_trace_event_t* trace_event);
-XBT_PUBLIC(void) tmgr_finalize();
+XBT_PUBLIC void tmgr_finalize();
-XBT_PUBLIC(tmgr_trace_t) tmgr_trace_new_from_file(std::string filename);
-XBT_PUBLIC(tmgr_trace_t) tmgr_trace_new_from_string(std::string id, std::string input, double periodicity);
+XBT_PUBLIC tmgr_trace_t tmgr_trace_new_from_file(std::string filename);
+XBT_PUBLIC tmgr_trace_t tmgr_trace_new_from_string(std::string id, std::string input, double periodicity);
}
namespace simgrid {
-/* Copyright (c) 2006-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2006-2018. 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. */
extern "C" {
/* Module management functions */
-XBT_PUBLIC(void) sg_platf_init();;
-XBT_PUBLIC(void) sg_platf_exit();
-
-XBT_PUBLIC(void) surf_parse_open(const char *file);
-XBT_PUBLIC(void) surf_parse_close();
-XBT_PUBLIC(void) surf_parse_assert(bool cond, std::string msg);
-XBT_ATTRIB_NORETURN XBT_PUBLIC(void) surf_parse_error(std::string msg);
-XBT_PUBLIC(void) surf_parse_assert_netpoint(std::string hostname, std::string pre, std::string post);
-
-XBT_PUBLIC(double) surf_parse_get_double(std::string s);
-XBT_PUBLIC(int) surf_parse_get_int(std::string s);
-XBT_PUBLIC(double) surf_parse_get_time(const char* string, const char* entity_kind, std::string name);
-XBT_PUBLIC(double) surf_parse_get_size(const char* string, const char* entity_kind, std::string name);
-XBT_PUBLIC(double) surf_parse_get_bandwidth(const char* string, const char* entity_kind, std::string name);
-XBT_PUBLIC(double) surf_parse_get_speed(const char* string, const char* entity_kind, std::string name);
-
-XBT_PUBLIC(int) surf_parse(); /* Entry-point to the parser */
+XBT_PUBLIC void sg_platf_init();
+XBT_PUBLIC void sg_platf_exit();
+
+XBT_PUBLIC void surf_parse_open(const char* file);
+XBT_PUBLIC void surf_parse_close();
+XBT_PUBLIC void surf_parse_assert(bool cond, std::string msg);
+XBT_ATTRIB_NORETURN XBT_PUBLIC void surf_parse_error(std::string msg);
+XBT_PUBLIC void surf_parse_assert_netpoint(std::string hostname, std::string pre, std::string post);
+
+XBT_PUBLIC double surf_parse_get_double(std::string s);
+XBT_PUBLIC int surf_parse_get_int(std::string s);
+XBT_PUBLIC double surf_parse_get_time(const char* string, const char* entity_kind, std::string name);
+XBT_PUBLIC double surf_parse_get_size(const char* string, const char* entity_kind, std::string name);
+XBT_PUBLIC double surf_parse_get_bandwidth(const char* string, const char* entity_kind, std::string name);
+XBT_PUBLIC double surf_parse_get_speed(const char* string, const char* entity_kind, std::string name);
+
+XBT_PUBLIC int surf_parse(); /* Entry-point to the parser */
}
#endif
/* platf_private.h - Interface to the SimGrid platforms which visibility should be limited to this directory */
-/* Copyright (c) 2004-2017. The SimGrid Team.
+/* Copyright (c) 2004-2018. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
void routing_cluster_add_backbone(simgrid::surf::LinkImpl* bb);
/*** END of the parsing cruft ***/
-XBT_PUBLIC(void) sg_platf_begin(); // Start a new platform
-XBT_PUBLIC(void) sg_platf_end(); // Finish the creation of the platform
+XBT_PUBLIC void sg_platf_begin(); // Start a new platform
+XBT_PUBLIC void sg_platf_end(); // Finish the creation of the platform
-XBT_PUBLIC(simgrid::s4u::NetZone*) sg_platf_new_Zone_begin(ZoneCreationArgs* zone); // Begin description of new Zone
-XBT_PUBLIC(void) sg_platf_new_Zone_seal(); // That Zone is fully described
+XBT_PUBLIC simgrid::s4u::NetZone* sg_platf_new_Zone_begin(ZoneCreationArgs* zone); // Begin description of new Zone
+XBT_PUBLIC void sg_platf_new_Zone_seal(); // That Zone is fully described
-XBT_PUBLIC(void) sg_platf_new_host(sg_platf_host_cbarg_t host); // Add a host to the current Zone
-XBT_PUBLIC(void) sg_platf_new_hostlink(HostLinkCreationArgs* h); // Add a host_link to the current Zone
-XBT_PUBLIC(void) sg_platf_new_link(LinkCreationArgs* link); // Add a link to the current Zone
-XBT_PUBLIC(void) sg_platf_new_peer(PeerCreationArgs* peer); // Add a peer to the current Zone
-XBT_PUBLIC(void) sg_platf_new_cluster(ClusterCreationArgs* clust); // Add a cluster to the current Zone
-XBT_PUBLIC(void) sg_platf_new_cabinet(CabinetCreationArgs* cabinet); // Add a cabinet to the current Zone
-XBT_PUBLIC(simgrid::kernel::routing::NetPoint*) // Add a router to the current Zone
-sg_platf_new_router(std::string, const char* coords);
+XBT_PUBLIC void sg_platf_new_host(sg_platf_host_cbarg_t host); // Add a host to the current Zone
+XBT_PUBLIC void sg_platf_new_hostlink(HostLinkCreationArgs* h); // Add a host_link to the current Zone
+XBT_PUBLIC void sg_platf_new_link(LinkCreationArgs* link); // Add a link to the current Zone
+XBT_PUBLIC void sg_platf_new_peer(PeerCreationArgs* peer); // Add a peer to the current Zone
+XBT_PUBLIC void sg_platf_new_cluster(ClusterCreationArgs* clust); // Add a cluster to the current Zone
+XBT_PUBLIC void sg_platf_new_cabinet(CabinetCreationArgs* cabinet); // Add a cabinet to the current Zone
+XBT_PUBLIC simgrid::kernel::routing::NetPoint* // Add a router to the current Zone
+ sg_platf_new_router(std::string, const char* coords);
-XBT_PUBLIC(void) sg_platf_new_route(RouteCreationArgs* route); // Add a route
-XBT_PUBLIC(void) sg_platf_new_bypassRoute(RouteCreationArgs* bypassroute); // Add a bypassRoute
+XBT_PUBLIC void sg_platf_new_route(RouteCreationArgs* route); // Add a route
+XBT_PUBLIC void sg_platf_new_bypassRoute(RouteCreationArgs* bypassroute); // Add a bypassRoute
-XBT_PUBLIC(void) sg_platf_new_trace(TraceCreationArgs* trace);
+XBT_PUBLIC void sg_platf_new_trace(TraceCreationArgs* trace);
-XBT_PUBLIC(void) sg_platf_new_storage(StorageCreationArgs* storage); // Add a storage to the current Zone
-XBT_PUBLIC(void) sg_platf_new_storage_type(StorageTypeCreationArgs* storage_type);
-XBT_PUBLIC(void) sg_platf_new_mount(MountCreationArgs* mount);
+XBT_PUBLIC void sg_platf_new_storage(StorageCreationArgs* storage); // Add a storage to the current Zone
+XBT_PUBLIC void sg_platf_new_storage_type(StorageTypeCreationArgs* storage_type);
+XBT_PUBLIC void sg_platf_new_mount(MountCreationArgs* mount);
-XBT_PUBLIC(void) sg_platf_new_actor(ActorCreationArgs* actor);
+XBT_PUBLIC void sg_platf_new_actor(ActorCreationArgs* actor);
XBT_PRIVATE void sg_platf_trace_connect(TraceConnectCreationArgs* trace_connect);
/* Prototypes of the functions offered by flex */
-XBT_PUBLIC(int) surf_parse_lex();
-XBT_PUBLIC(int) surf_parse_get_lineno();
-XBT_PUBLIC(FILE *) surf_parse_get_in();
-XBT_PUBLIC(FILE *) surf_parse_get_out();
-XBT_PUBLIC(int) surf_parse_get_leng();
-XBT_PUBLIC(char *) surf_parse_get_text();
-XBT_PUBLIC(void) surf_parse_set_lineno(int line_number);
-XBT_PUBLIC(void) surf_parse_set_in(FILE * in_str);
-XBT_PUBLIC(void) surf_parse_set_out(FILE * out_str);
-XBT_PUBLIC(int) surf_parse_get_debug();
-XBT_PUBLIC(void) surf_parse_set_debug(int bdebug);
-XBT_PUBLIC(int) surf_parse_lex_destroy();
+XBT_PUBLIC int surf_parse_lex();
+XBT_PUBLIC int surf_parse_get_lineno();
+XBT_PUBLIC FILE* surf_parse_get_in();
+XBT_PUBLIC FILE* surf_parse_get_out();
+XBT_PUBLIC int surf_parse_get_leng();
+XBT_PUBLIC char* surf_parse_get_text();
+XBT_PUBLIC void surf_parse_set_lineno(int line_number);
+XBT_PUBLIC void surf_parse_set_in(FILE* in_str);
+XBT_PUBLIC void surf_parse_set_out(FILE* out_str);
+XBT_PUBLIC int surf_parse_get_debug();
+XBT_PUBLIC void surf_parse_set_debug(int bdebug);
+XBT_PUBLIC int surf_parse_lex_destroy();
}
namespace simgrid {
#define _FLEXML_simgrid_H
/* XML application entry points. */
-XBT_PUBLIC(void) STag_surfxml_AS(void);
-XBT_PUBLIC(void) ETag_surfxml_AS(void);
-XBT_PUBLIC(void) STag_surfxml_ASroute(void);
-XBT_PUBLIC(void) ETag_surfxml_ASroute(void);
-XBT_PUBLIC(void) STag_surfxml_actor(void);
-XBT_PUBLIC(void) ETag_surfxml_actor(void);
-XBT_PUBLIC(void) STag_surfxml_argument(void);
-XBT_PUBLIC(void) ETag_surfxml_argument(void);
-XBT_PUBLIC(void) STag_surfxml_backbone(void);
-XBT_PUBLIC(void) ETag_surfxml_backbone(void);
-XBT_PUBLIC(void) STag_surfxml_bypassASroute(void);
-XBT_PUBLIC(void) ETag_surfxml_bypassASroute(void);
-XBT_PUBLIC(void) STag_surfxml_bypassRoute(void);
-XBT_PUBLIC(void) ETag_surfxml_bypassRoute(void);
-XBT_PUBLIC(void) STag_surfxml_bypassZoneRoute(void);
-XBT_PUBLIC(void) ETag_surfxml_bypassZoneRoute(void);
-XBT_PUBLIC(void) STag_surfxml_cabinet(void);
-XBT_PUBLIC(void) ETag_surfxml_cabinet(void);
-XBT_PUBLIC(void) STag_surfxml_cluster(void);
-XBT_PUBLIC(void) ETag_surfxml_cluster(void);
-XBT_PUBLIC(void) STag_surfxml_config(void);
-XBT_PUBLIC(void) ETag_surfxml_config(void);
-XBT_PUBLIC(void) STag_surfxml_host(void);
-XBT_PUBLIC(void) ETag_surfxml_host(void);
-XBT_PUBLIC(void) STag_surfxml_host___link(void);
-XBT_PUBLIC(void) ETag_surfxml_host___link(void);
-XBT_PUBLIC(void) STag_surfxml_include(void);
-XBT_PUBLIC(void) ETag_surfxml_include(void);
-XBT_PUBLIC(void) STag_surfxml_link(void);
-XBT_PUBLIC(void) ETag_surfxml_link(void);
-XBT_PUBLIC(void) STag_surfxml_link___ctn(void);
-XBT_PUBLIC(void) ETag_surfxml_link___ctn(void);
-XBT_PUBLIC(void) STag_surfxml_model___prop(void);
-XBT_PUBLIC(void) ETag_surfxml_model___prop(void);
-XBT_PUBLIC(void) STag_surfxml_mount(void);
-XBT_PUBLIC(void) ETag_surfxml_mount(void);
-XBT_PUBLIC(void) STag_surfxml_peer(void);
-XBT_PUBLIC(void) ETag_surfxml_peer(void);
-XBT_PUBLIC(void) STag_surfxml_platform(void);
-XBT_PUBLIC(void) ETag_surfxml_platform(void);
-XBT_PUBLIC(void) STag_surfxml_process(void);
-XBT_PUBLIC(void) ETag_surfxml_process(void);
-XBT_PUBLIC(void) STag_surfxml_prop(void);
-XBT_PUBLIC(void) ETag_surfxml_prop(void);
-XBT_PUBLIC(void) STag_surfxml_random(void);
-XBT_PUBLIC(void) ETag_surfxml_random(void);
-XBT_PUBLIC(void) STag_surfxml_route(void);
-XBT_PUBLIC(void) ETag_surfxml_route(void);
-XBT_PUBLIC(void) STag_surfxml_router(void);
-XBT_PUBLIC(void) ETag_surfxml_router(void);
-XBT_PUBLIC(void) STag_surfxml_storage(void);
-XBT_PUBLIC(void) ETag_surfxml_storage(void);
-XBT_PUBLIC(void) STag_surfxml_storage___type(void);
-XBT_PUBLIC(void) ETag_surfxml_storage___type(void);
-XBT_PUBLIC(void) STag_surfxml_trace(void);
-XBT_PUBLIC(void) ETag_surfxml_trace(void);
-XBT_PUBLIC(void) STag_surfxml_trace___connect(void);
-XBT_PUBLIC(void) ETag_surfxml_trace___connect(void);
-XBT_PUBLIC(void) STag_surfxml_zone(void);
-XBT_PUBLIC(void) ETag_surfxml_zone(void);
-XBT_PUBLIC(void) STag_surfxml_zoneRoute(void);
-XBT_PUBLIC(void) ETag_surfxml_zoneRoute(void);
+XBT_PUBLIC void STag_surfxml_AS(void);
+XBT_PUBLIC void ETag_surfxml_AS(void);
+XBT_PUBLIC void STag_surfxml_ASroute(void);
+XBT_PUBLIC void ETag_surfxml_ASroute(void);
+XBT_PUBLIC void STag_surfxml_actor(void);
+XBT_PUBLIC void ETag_surfxml_actor(void);
+XBT_PUBLIC void STag_surfxml_argument(void);
+XBT_PUBLIC void ETag_surfxml_argument(void);
+XBT_PUBLIC void STag_surfxml_backbone(void);
+XBT_PUBLIC void ETag_surfxml_backbone(void);
+XBT_PUBLIC void STag_surfxml_bypassASroute(void);
+XBT_PUBLIC void ETag_surfxml_bypassASroute(void);
+XBT_PUBLIC void STag_surfxml_bypassRoute(void);
+XBT_PUBLIC void ETag_surfxml_bypassRoute(void);
+XBT_PUBLIC void STag_surfxml_bypassZoneRoute(void);
+XBT_PUBLIC void ETag_surfxml_bypassZoneRoute(void);
+XBT_PUBLIC void STag_surfxml_cabinet(void);
+XBT_PUBLIC void ETag_surfxml_cabinet(void);
+XBT_PUBLIC void STag_surfxml_cluster(void);
+XBT_PUBLIC void ETag_surfxml_cluster(void);
+XBT_PUBLIC void STag_surfxml_config(void);
+XBT_PUBLIC void ETag_surfxml_config(void);
+XBT_PUBLIC void STag_surfxml_host(void);
+XBT_PUBLIC void ETag_surfxml_host(void);
+XBT_PUBLIC void STag_surfxml_host___link(void);
+XBT_PUBLIC void ETag_surfxml_host___link(void);
+XBT_PUBLIC void STag_surfxml_include(void);
+XBT_PUBLIC void ETag_surfxml_include(void);
+XBT_PUBLIC void STag_surfxml_link(void);
+XBT_PUBLIC void ETag_surfxml_link(void);
+XBT_PUBLIC void STag_surfxml_link___ctn(void);
+XBT_PUBLIC void ETag_surfxml_link___ctn(void);
+XBT_PUBLIC void STag_surfxml_model___prop(void);
+XBT_PUBLIC void ETag_surfxml_model___prop(void);
+XBT_PUBLIC void STag_surfxml_mount(void);
+XBT_PUBLIC void ETag_surfxml_mount(void);
+XBT_PUBLIC void STag_surfxml_peer(void);
+XBT_PUBLIC void ETag_surfxml_peer(void);
+XBT_PUBLIC void STag_surfxml_platform(void);
+XBT_PUBLIC void ETag_surfxml_platform(void);
+XBT_PUBLIC void STag_surfxml_process(void);
+XBT_PUBLIC void ETag_surfxml_process(void);
+XBT_PUBLIC void STag_surfxml_prop(void);
+XBT_PUBLIC void ETag_surfxml_prop(void);
+XBT_PUBLIC void STag_surfxml_random(void);
+XBT_PUBLIC void ETag_surfxml_random(void);
+XBT_PUBLIC void STag_surfxml_route(void);
+XBT_PUBLIC void ETag_surfxml_route(void);
+XBT_PUBLIC void STag_surfxml_router(void);
+XBT_PUBLIC void ETag_surfxml_router(void);
+XBT_PUBLIC void STag_surfxml_storage(void);
+XBT_PUBLIC void ETag_surfxml_storage(void);
+XBT_PUBLIC void STag_surfxml_storage___type(void);
+XBT_PUBLIC void ETag_surfxml_storage___type(void);
+XBT_PUBLIC void STag_surfxml_trace(void);
+XBT_PUBLIC void ETag_surfxml_trace(void);
+XBT_PUBLIC void STag_surfxml_trace___connect(void);
+XBT_PUBLIC void ETag_surfxml_trace___connect(void);
+XBT_PUBLIC void STag_surfxml_zone(void);
+XBT_PUBLIC void ETag_surfxml_zone(void);
+XBT_PUBLIC void STag_surfxml_zoneRoute(void);
+XBT_PUBLIC void ETag_surfxml_zoneRoute(void);
/* XML application data. */
typedef int AT_surfxml_AS_id;
XBT_PUBLIC_DATA(short int) surfxml_zoneRoute_symmetrical_isset;
/* XML application utilities. */
-XBT_PUBLIC(int) surfxml_element_context(int);
+XBT_PUBLIC int surfxml_element_context(int);
/* XML processor entry point. */
-XBT_PUBLIC(int) yylex(void);
+XBT_PUBLIC int yylex(void);
/* Flexml error handling function (useful only when -q flag passed to flexml) */
const char * surfxml_parse_err_msg(void);
/* automaton - representation of büchi automaton */
-/* Copyright (c) 2011-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2011-2018. 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. */
return ((int (*)(void)) function)();
}
-xbt_automaton_propositional_symbol_t xbt_automaton_propositional_symbol_new(xbt_automaton_t a, const char* id, int(*fct)(void)){
+xbt_automaton_propositional_symbol_t xbt_automaton_propositional_symbol_new(xbt_automaton_t a, const char* id,
+ int (*fct)(void))
+{
xbt_automaton_propositional_symbol_t prop_symb = xbt_new0(struct xbt_automaton_propositional_symbol, 1);
prop_symb->pred = xbt_strdup(id);
prop_symb->callback = &call_simple_function;
return prop_symb;
}
-XBT_PUBLIC(xbt_automaton_propositional_symbol_t) xbt_automaton_propositional_symbol_new_pointer(xbt_automaton_t a, const char* id, int* value)
+XBT_PUBLIC xbt_automaton_propositional_symbol_t xbt_automaton_propositional_symbol_new_pointer(xbt_automaton_t a,
+ const char* id,
+ int* value)
{
xbt_automaton_propositional_symbol_t prop_symb = xbt_new0(struct xbt_automaton_propositional_symbol, 1);
prop_symb->pred = xbt_strdup(id);
return prop_symb;
}
-XBT_PUBLIC(xbt_automaton_propositional_symbol_t) xbt_automaton_propositional_symbol_new_callback(
- xbt_automaton_t a, const char* id,
- xbt_automaton_propositional_symbol_callback_type callback,
- void* data, xbt_automaton_propositional_symbol_free_function_type free_function)
+XBT_PUBLIC xbt_automaton_propositional_symbol_t xbt_automaton_propositional_symbol_new_callback(
+ xbt_automaton_t a, const char* id, xbt_automaton_propositional_symbol_callback_type callback, void* data,
+ xbt_automaton_propositional_symbol_free_function_type free_function)
{
xbt_automaton_propositional_symbol_t prop_symb = xbt_new0(struct xbt_automaton_propositional_symbol, 1);
prop_symb->pred = xbt_strdup(id);
return prop_symb;
}
-XBT_PUBLIC(int) xbt_automaton_propositional_symbol_evaluate(xbt_automaton_propositional_symbol_t symbol)
+XBT_PUBLIC int xbt_automaton_propositional_symbol_evaluate(xbt_automaton_propositional_symbol_t symbol)
{
if (symbol->callback)
return (symbol->callback)(symbol->data);
return *(int*) symbol->data;
}
-XBT_PUBLIC(xbt_automaton_propositional_symbol_callback_type) xbt_automaton_propositional_symbol_get_callback(xbt_automaton_propositional_symbol_t symbol)
+XBT_PUBLIC xbt_automaton_propositional_symbol_callback_type
+xbt_automaton_propositional_symbol_get_callback(xbt_automaton_propositional_symbol_t symbol)
{
return symbol->callback;
}
-XBT_PUBLIC(void*) xbt_automaton_propositional_symbol_get_data(xbt_automaton_propositional_symbol_t symbol)
+XBT_PUBLIC void* xbt_automaton_propositional_symbol_get_data(xbt_automaton_propositional_symbol_t symbol)
{
return symbol->data;
}
-XBT_PUBLIC(const char*) xbt_automaton_propositional_symbol_get_name(xbt_automaton_propositional_symbol_t symbol)
+XBT_PUBLIC const char* xbt_automaton_propositional_symbol_get_name(xbt_automaton_propositional_symbol_t symbol)
{
return symbol->pred;
}
-/* Copyright (c) 2004-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2004-2018. 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. */
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_cfg, xbt, "configuration support");
XBT_EXPORT_NO_IMPORT(xbt_cfg_t) simgrid_config = nullptr;
-extern "C" {
- XBT_PUBLIC(void) sg_config_finalize();
-}
+extern "C" XBT_PUBLIC void sg_config_finalize();
namespace simgrid {
namespace config {
// ***** getConfig *****
-template<class T>
-XBT_PUBLIC(T const&) getConfig(const char* name)
+template <class T> XBT_PUBLIC T const& getConfig(const char* name)
{
return (*simgrid_config)[name].getValue<T>();
}
-template XBT_PUBLIC(int const&) getConfig<int>(const char* name);
-template XBT_PUBLIC(double const&) getConfig<double>(const char* name);
-template XBT_PUBLIC(bool const&) getConfig<bool>(const char* name);
-template XBT_PUBLIC(std::string const&) getConfig<std::string>(const char* name);
+template XBT_PUBLIC int const& getConfig<int>(const char* name);
+template XBT_PUBLIC double const& getConfig<double>(const char* name);
+template XBT_PUBLIC bool const& getConfig<bool>(const char* name);
+template XBT_PUBLIC std::string const& getConfig<std::string>(const char* name);
// ***** alias *****
// ***** declareFlag *****
-template<class T>
-XBT_PUBLIC(void) declareFlag(const char* name, const char* description,
- T value, std::function<void(const T&)> callback)
+template <class T>
+XBT_PUBLIC void declareFlag(const char* name, const char* description, T value, std::function<void(const T&)> callback)
{
if (simgrid_config == nullptr) {
simgrid_config = xbt_cfg_new();
name, description, std::move(value), std::move(callback));
}
-template XBT_PUBLIC(void) declareFlag(const char* name,
- const char* description, int value, std::function<void(int const &)> callback);
-template XBT_PUBLIC(void) declareFlag(const char* name,
- const char* description, double value, std::function<void(double const &)> callback);
-template XBT_PUBLIC(void) declareFlag(const char* name,
- const char* description, bool value, std::function<void(bool const &)> callback);
-template XBT_PUBLIC(void) declareFlag(const char* name,
- const char* description, std::string value, std::function<void(std::string const &)> callback);
-
+template XBT_PUBLIC void declareFlag(const char* name, const char* description, int value,
+ std::function<void(int const&)> callback);
+template XBT_PUBLIC void declareFlag(const char* name, const char* description, double value,
+ std::function<void(double const&)> callback);
+template XBT_PUBLIC void declareFlag(const char* name, const char* description, bool value,
+ std::function<void(bool const&)> callback);
+template XBT_PUBLIC void declareFlag(const char* name, const char* description, std::string value,
+ std::function<void(std::string const&)> callback);
}
}
-/* Copyright (c) 2007-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2007-2018. 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. */
*
* Programatically alter a category's parent (don't use).
*/
-XBT_PUBLIC(void) xbt_log_parent_set(xbt_log_category_t cat, xbt_log_category_t parent);
+XBT_PUBLIC void xbt_log_parent_set(xbt_log_category_t cat, xbt_log_category_t parent);
#endif
/* Remap a mmalloc region that was previously mapped. */
-XBT_PUBLIC( void *)__mmalloc_remap_core(xbt_mheap_t mdp);
+XBT_PUBLIC void* __mmalloc_remap_core(xbt_mheap_t mdp);
-XBT_PUBLIC( void *)mmorecore(struct mdesc *mdp, ssize_t size);
+XBT_PUBLIC void* mmorecore(struct mdesc* mdp, ssize_t size);
/** Thread-safety (if the mutex is already created)
*
ENDIF()
set(string1 "'s/extern *\\([^(]*\\)\\( \\|\\( \\*\\)\\)/XBT_PUBLIC_DATA(\\1\\3) /'")
- set(string2 "'s/XBT_PUBLIC_DATA(\\([^)]*\\)) *\\([^(]*\\)(/XBT_PUBLIC(\\1) \\2(/'")
+ set(string2 "'s/XBT_PUBLIC_DATA(\\([^)]*\\)) *\\([^(]*\\)(/XBT_PUBLIC \\1 \\2(/'")
set(string5 "'s/SET(DOCTYPE)/SET(ROOT_dax__adag)/'")
set(string9 "'s/#include <unistd.h>/#if defined(_WIN32)\\n# ifndef __STRICT_ANSI__\\n# include <io.h>\\n# include <process.h>\\n# endif\\n#else\\n# include <unistd.h>\\n#endif/g'")
set(string14 "'\\!^ \\* Generated [0-9/]\\{10\\} [0-9:]\\{8\\}\\.$$!d'")