From 4bb73cb3914b5f7b77a9ec1f8abe728e637cc016 Mon Sep 17 00:00:00 2001 From: Arnaud Giersch Date: Tue, 13 Mar 2018 15:30:12 +0100 Subject: [PATCH] Define XBT_PUBLIC without parameter, just like XBT_PRIVATE. Requested in commit 680abdb047c1a66d3ccc14cad518117773c3cc8c. --- doc/Doxyfile.in | 2 +- include/simgrid/forward.h | 4 +- include/simgrid/host.h | 64 +- include/simgrid/instr.h | 104 +- include/simgrid/jedule/jedule_sd_binding.h | 10 +- include/simgrid/kernel/future.hpp | 4 +- include/simgrid/link.h | 22 +- include/simgrid/modelchecker.h | 22 +- include/simgrid/msg.h | 358 +++---- include/simgrid/plugins/dvfs.h | 4 +- include/simgrid/plugins/energy.h | 20 +- include/simgrid/plugins/file_system.h | 42 +- include/simgrid/plugins/live_migration.h | 31 +- include/simgrid/plugins/load.h | 14 +- include/simgrid/s4u/Activity.hpp | 10 +- include/simgrid/s4u/Actor.hpp | 70 +- include/simgrid/s4u/Comm.hpp | 6 +- include/simgrid/s4u/ConditionVariable.hpp | 4 +- include/simgrid/s4u/Engine.hpp | 8 +- include/simgrid/s4u/Exec.hpp | 8 +- include/simgrid/s4u/Host.hpp | 4 +- include/simgrid/s4u/Storage.hpp | 6 +- include/simgrid/s4u/forward.hpp | 14 +- include/simgrid/simdag.h | 109 +- include/simgrid/simix.h | 245 +++-- include/simgrid/simix.hpp | 24 +- include/simgrid/simix/blocking_simcall.hpp | 6 +- include/simgrid_config.h.in | 6 +- include/smpi/smpi.h | 998 +++++++++--------- include/xbt/RngStream.h | 34 +- include/xbt/automaton.h | 91 +- include/xbt/backtrace.h | 12 +- include/xbt/backtrace.hpp | 10 +- include/xbt/base.h | 12 +- include/xbt/config.h | 56 +- include/xbt/config.hpp | 41 +- include/xbt/cunit.h | 24 +- include/xbt/dict.h | 70 +- include/xbt/dynar.h | 76 +- include/xbt/ex.h | 8 +- include/xbt/ex.hpp | 4 +- include/xbt/graph.h | 32 +- include/xbt/log.h | 24 +- include/xbt/log.hpp | 9 +- include/xbt/mallocator.h | 14 +- include/xbt/misc.h | 8 +- include/xbt/mmalloc.h | 18 +- include/xbt/module.h | 4 +- include/xbt/replay.hpp | 8 +- include/xbt/str.h | 16 +- include/xbt/string.hpp | 6 +- include/xbt/synchro.h | 24 +- include/xbt/sysdep.h | 10 +- include/xbt/virtu.h | 6 +- include/xbt/xbt_os_thread.h | 69 +- include/xbt/xbt_os_time.h | 32 +- src/include/instr/instr_interface.h | 10 +- src/include/mc/mc.h | 22 +- src/include/simgrid/sg_config.h | 6 +- src/include/surf/surf.hpp | 56 +- src/instr/instr_private.hpp | 10 +- src/kernel/activity/ActivityImpl.hpp | 6 +- src/kernel/activity/MutexImpl.hpp | 4 +- src/kernel/context/Context.hpp | 12 +- src/kernel/lmm/maxmin.hpp | 31 +- src/kernel/routing/NetPoint.hpp | 4 +- src/mc/checker/Checker.hpp | 9 +- src/mc/mc_ignore.h | 4 +- src/mc/remote/Client.hpp | 4 +- src/msg/msg_process.cpp | 17 +- src/s4u/s4u_actor.cpp | 4 +- src/simdag/dax_dtd.h | 24 +- src/simix/libsmx.cpp | 4 +- src/simix/smx_global.cpp | 2 +- src/simix/smx_private.hpp | 6 +- .../colls/smpi_mvapich2_selector_stampede.hpp | 4 +- src/smpi/include/private.hpp | 2 +- src/smpi/include/smpi_coll.hpp | 6 +- src/smpi/include/smpi_utils.hpp | 2 +- src/smpi/internals/smpi_bench.cpp | 6 +- src/smpi/internals/smpi_dvfs.cpp | 12 +- src/surf/cpu_interface.hpp | 4 +- src/surf/ns3/ns3_simulator.hpp | 8 +- src/surf/surf_interface.hpp | 2 +- src/surf/surf_private.hpp | 2 +- src/surf/trace_mgr.hpp | 10 +- src/surf/xml/platf.hpp | 36 +- src/surf/xml/platf_private.hpp | 64 +- src/surf/xml/simgrid_dtd.h | 128 +-- src/xbt/automaton/automaton.c | 26 +- src/xbt/config.cpp | 39 +- src/xbt/log_private.h | 4 +- src/xbt/mmalloc/mmprivate.h | 4 +- tools/cmake/MaintainerMode.cmake | 2 +- 94 files changed, 1772 insertions(+), 1761 deletions(-) diff --git a/doc/Doxyfile.in b/doc/Doxyfile.in index c40b913ced..07d802a65e 100644 --- a/doc/Doxyfile.in +++ b/doc/Doxyfile.in @@ -1453,7 +1453,7 @@ INCLUDE_FILE_PATTERNS = # 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" \ diff --git a/include/simgrid/forward.h b/include/simgrid/forward.h index 8e83f4a421..170910ddfd 100644 --- a/include/simgrid/forward.h +++ b/include/simgrid/forward.h @@ -22,8 +22,8 @@ class ContextFactory; namespace activity { class ActivityImpl; using ActivityImplPtr = boost::intrusive_ptr; - 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; diff --git a/include/simgrid/host.h b/include/simgrid/host.h index 60696b6496..109540cdbd 100644 --- a/include/simgrid/host.h +++ b/include/simgrid/host.h @@ -1,4 +1,4 @@ -/* 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 @@ -16,12 +16,12 @@ 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 @@ -29,11 +29,11 @@ XBT_PUBLIC(size_t) sg_host_count(); * \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. @@ -42,14 +42,14 @@ XBT_PUBLIC(void*) sg_host_extension_get(sg_host_t host, size_t rank); * \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 ============== @@ -59,7 +59,7 @@ XBT_PUBLIC(const char*) sg_host_get_name(sg_host_t host); * * 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 * @@ -67,9 +67,9 @@ XBT_PUBLIC(void*) sg_host_user(sg_host_t host); * * 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 @@ -77,7 +77,7 @@ XBT_PUBLIC(void) sg_host_user_destroy(sg_host_t host); * \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 @@ -85,18 +85,18 @@ XBT_PUBLIC(xbt_dict_t) sg_host_get_mounted_storage_list(sg_host_t host); * \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 @@ -104,31 +104,31 @@ XBT_PUBLIC(int) sg_host_core_count(sg_host_t host); * \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 @@ -137,7 +137,7 @@ XBT_PUBLIC(int) sg_host_is_off(sg_host_t host); * \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 @@ -147,7 +147,7 @@ XBT_PUBLIC(xbt_dict_t) sg_host_get_properties(sg_host_t host); * \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 @@ -157,13 +157,13 @@ XBT_PUBLIC(const char*) sg_host_get_property_value(sg_host_t host, const char* n * \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_ */ diff --git a/include/simgrid/instr.h b/include/simgrid/instr.h index 80cb7355df..d36c6cec5f 100644 --- a/include/simgrid/instr.h +++ b/include/simgrid/instr.h @@ -1,4 +1,4 @@ -/* 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 @@ -13,70 +13,74 @@ 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() diff --git a/include/simgrid/jedule/jedule_sd_binding.h b/include/simgrid/jedule/jedule_sd_binding.h index 909ad6caec..969cdfdfa2 100644 --- a/include/simgrid/jedule/jedule_sd_binding.h +++ b/include/simgrid/jedule/jedule_sd_binding.h @@ -1,4 +1,4 @@ -/* 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 @@ -12,10 +12,10 @@ #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_ */ diff --git a/include/simgrid/kernel/future.hpp b/include/simgrid/kernel/future.hpp index 7ecfacab94..f0c8cacb4e 100644 --- a/include/simgrid/kernel/future.hpp +++ b/include/simgrid/kernel/future.hpp @@ -1,4 +1,4 @@ -/* 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 @@ -48,7 +48,7 @@ public: FutureStateBase(FutureStateBase const&) = delete; FutureStateBase& operator=(FutureStateBase const&) = delete; - XBT_PUBLIC(void) schedule(simgrid::xbt::Task&& job); + XBT_PUBLIC void schedule(simgrid::xbt::Task&& job); void set_exception(std::exception_ptr exception) { diff --git a/include/simgrid/link.h b/include/simgrid/link.h index 9dea554807..e3c465df13 100644 --- a/include/simgrid/link.h +++ b/include/simgrid/link.h @@ -1,6 +1,6 @@ /* 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 @@ -14,16 +14,16 @@ /* 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_ */ diff --git a/include/simgrid/modelchecker.h b/include/simgrid/modelchecker.h index 5ccaed2997..547f9fd237 100644 --- a/include/simgrid/modelchecker.h +++ b/include/simgrid/modelchecker.h @@ -22,15 +22,15 @@ 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 @@ -39,17 +39,17 @@ extern XBT_PUBLIC(int) _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 diff --git a/include/simgrid/msg.h b/include/simgrid/msg.h index 420a9b2713..119905759d 100644 --- a/include/simgrid/msg.h +++ b/include/simgrid/msg.h @@ -130,7 +130,7 @@ typedef enum { /** @} */ /************************** 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 @@ -146,55 +146,52 @@ XBT_PUBLIC(void) MSG_config(const char *key, const char *value); 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) @@ -202,142 +199,133 @@ XBT_ATTRIB_DEPRECATED_v320("Use MSG_host_get_speed(): v3.20 will drop MSG_host_g 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 ************************************/ @@ -347,12 +335,12 @@ XBT_PUBLIC(const char *) MSG_task_get_category (msg_task_t task); * 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 @@ -360,13 +348,13 @@ XBT_PUBLIC(void) MSG_action_exit(); */ 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 @@ -375,9 +363,9 @@ XBT_PUBLIC(int) MSG_sem_would_block(msg_sem_t sem); #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 @@ -388,56 +376,56 @@ XBT_PUBLIC(int) MSG_barrier_wait(msg_bar_t bar); * */ -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 code, void* data, msg_host_t host, - std::map* properties); +XBT_PUBLIC msg_process_t MSG_process_create_from_stdfunc(const char* name, std::function code, void* data, + msg_host_t host, + std::map* properties); #endif #endif diff --git a/include/simgrid/plugins/dvfs.h b/include/simgrid/plugins/dvfs.h index 57726ed496..bd856b9002 100644 --- a/include/simgrid/plugins/dvfs.h +++ b/include/simgrid/plugins/dvfs.h @@ -1,4 +1,4 @@ -/* 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 @@ -12,7 +12,7 @@ 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() diff --git a/include/simgrid/plugins/energy.h b/include/simgrid/plugins/energy.h index 285345b12b..3cfe6e7b9c 100644 --- a/include/simgrid/plugins/energy.h +++ b/include/simgrid/plugins/energy.h @@ -1,4 +1,4 @@ -/* 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. */ @@ -11,17 +11,17 @@ 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) diff --git a/include/simgrid/plugins/file_system.h b/include/simgrid/plugins/file_system.h index 41363fd1ce..cee6835de9 100644 --- a/include/simgrid/plugins/file_system.h +++ b/include/simgrid/plugins/file_system.h @@ -12,30 +12,30 @@ 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) diff --git a/include/simgrid/plugins/live_migration.h b/include/simgrid/plugins/live_migration.h index 3a5107af29..a75cac28be 100644 --- a/include/simgrid/plugins/live_migration.h +++ b/include/simgrid/plugins/live_migration.h @@ -12,23 +12,22 @@ 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() diff --git a/include/simgrid/plugins/load.h b/include/simgrid/plugins/load.h index 5b7f903ada..d6d09b9c35 100644 --- a/include/simgrid/plugins/load.h +++ b/include/simgrid/plugins/load.h @@ -1,4 +1,4 @@ -/* 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 @@ -12,12 +12,12 @@ 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) diff --git a/include/simgrid/s4u/Activity.hpp b/include/simgrid/s4u/Activity.hpp index 5e801f4b23..905daa334a 100644 --- a/include/simgrid/s4u/Activity.hpp +++ b/include/simgrid/s4u/Activity.hpp @@ -1,4 +1,4 @@ -/* 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. */ @@ -20,11 +20,11 @@ namespace s4u { */ 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; diff --git a/include/simgrid/s4u/Actor.hpp b/include/simgrid/s4u/Actor.hpp index 2a77e8e3cb..b4cdc75136 100644 --- a/include/simgrid/s4u/Actor.hpp +++ b/include/simgrid/s4u/Actor.hpp @@ -1,4 +1,4 @@ -/* 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. */ @@ -156,8 +156,8 @@ public: 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 */ @@ -290,11 +290,11 @@ public: * @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 inline void sleep_for(std::chrono::duration duration) { @@ -315,76 +315,76 @@ XBT_ATTRIB_DEPRECATED_v320("Use sleep_for(): v3.20 will turn this warning into a } /** 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); } /** @} */ diff --git a/include/simgrid/s4u/Comm.hpp b/include/simgrid/s4u/Comm.hpp index 7c615fe215..36a4308b44 100644 --- a/include/simgrid/s4u/Comm.hpp +++ b/include/simgrid/s4u/Comm.hpp @@ -1,4 +1,4 @@ -/* 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. */ @@ -25,8 +25,8 @@ XBT_PUBLIC_CLASS Comm : public Activity { 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(); diff --git a/include/simgrid/s4u/ConditionVariable.hpp b/include/simgrid/s4u/ConditionVariable.hpp index 85f4c47d94..5efc7f9bc8 100644 --- a/include/simgrid/s4u/ConditionVariable.hpp +++ b/include/simgrid/s4u/ConditionVariable.hpp @@ -40,8 +40,8 @@ public: 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; static Ptr createConditionVariable(); diff --git a/include/simgrid/s4u/Engine.hpp b/include/simgrid/s4u/Engine.hpp index ba591487ca..570900a43a 100644 --- a/include/simgrid/s4u/Engine.hpp +++ b/include/simgrid/s4u/Engine.hpp @@ -138,16 +138,16 @@ private: /** Callback fired when the platform is created (ie, the xml file parsed), * right before the actual simulation starts. */ -extern XBT_PUBLIC(xbt::signal) onPlatformCreated; +extern XBT_PUBLIC xbt::signal onPlatformCreated; /** Callback fired when the main simulation loop ends, just before MSG_run (or similar) ends */ -extern XBT_PUBLIC(xbt::signal) onSimulationEnd; +extern XBT_PUBLIC xbt::signal onSimulationEnd; /** Callback fired when the time jumps into the future */ -extern XBT_PUBLIC(xbt::signal) onTimeAdvance; +extern XBT_PUBLIC xbt::signal onTimeAdvance; /** Callback fired when the time cannot jump because of inter-actors deadlock */ -extern XBT_PUBLIC(xbt::signal) onDeadlock; +extern XBT_PUBLIC xbt::signal onDeadlock; template XBT_PRIVATE void netzoneByTypeRecursive(s4u::NetZone* current, std::vector* whereto) { diff --git a/include/simgrid/s4u/Exec.hpp b/include/simgrid/s4u/Exec.hpp index 650ea7f798..9566d53c85 100644 --- a/include/simgrid/s4u/Exec.hpp +++ b/include/simgrid/s4u/Exec.hpp @@ -1,4 +1,4 @@ -/* 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. */ @@ -19,9 +19,9 @@ XBT_PUBLIC_CLASS Exec : public Activity { 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; diff --git a/include/simgrid/s4u/Host.hpp b/include/simgrid/s4u/Host.hpp index 986744b8a4..d1b329b634 100644 --- a/include/simgrid/s4u/Host.hpp +++ b/include/simgrid/s4u/Host.hpp @@ -1,4 +1,4 @@ -/* 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. */ @@ -20,7 +20,7 @@ namespace simgrid { namespace xbt { -extern template class XBT_PUBLIC() Extendable; +extern template class XBT_PUBLIC Extendable; } namespace s4u { diff --git a/include/simgrid/s4u/Storage.hpp b/include/simgrid/s4u/Storage.hpp index fd86ba2db6..7dd83dbe20 100644 --- a/include/simgrid/s4u/Storage.hpp +++ b/include/simgrid/s4u/Storage.hpp @@ -1,4 +1,4 @@ -/* 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 @@ -17,11 +17,11 @@ namespace simgrid { namespace xbt { -extern template class XBT_PUBLIC() Extendable; +extern template class XBT_PUBLIC Extendable; } namespace s4u { -XBT_PUBLIC(void) getStorageList(std::map* whereTo); +XBT_PUBLIC void getStorageList(std::map* whereTo); XBT_PUBLIC_CLASS Storage : public simgrid::xbt::Extendable { diff --git a/include/simgrid/s4u/forward.hpp b/include/simgrid/s4u/forward.hpp index e55df1f363..233e195a11 100644 --- a/include/simgrid/s4u/forward.hpp +++ b/include/simgrid/s4u/forward.hpp @@ -1,4 +1,4 @@ -/* 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. */ @@ -15,19 +15,19 @@ namespace s4u { class Activity; class Actor; using ActorPtr = boost::intrusive_ptr; -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; -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; -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; diff --git a/include/simgrid/simdag.h b/include/simgrid/simdag.h index 4c044a517f..9194eabe67 100644 --- a/include/simgrid/simdag.h +++ b/include/simgrid/simdag.h @@ -70,46 +70,45 @@ typedef enum { * @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. * @@ -128,9 +127,9 @@ XBT_PUBLIC(void) SD_task_schedulel(SD_task_t task, int count, ...); * @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 *******************************************/ @@ -147,17 +146,17 @@ XBT_PUBLIC(int) SD_task_dependency_exists(SD_task_t src, SD_task_t dst); 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 */ @@ -200,7 +199,7 @@ SG_END_DECL() #ifdef __cplusplus namespace simgrid { namespace sd { -XBT_PUBLIC(std::set*) simulate(double how_long); +XBT_PUBLIC std::set* simulate(double how_long); } } #endif diff --git a/include/simgrid/simix.h b/include/simgrid/simix.h index 3d145b9895..5c2e970c05 100644 --- a/include/simgrid/simix.h +++ b/include/simgrid/simix.h @@ -74,61 +74,57 @@ extern int smx_context_guard_size_was_set; 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() @@ -139,35 +135,34 @@ XBT_PUBLIC(void) SIMIX_process_set_function(const char* process_host, * 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* properties, - smx_actor_t parent_process); +XBT_PUBLIC smx_actor_t SIMIX_process_attach(const char* name, void* data, const char* hostname, + std::map* 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 */ @@ -176,112 +171,112 @@ XBT_PUBLIC(void) SIMIX_comm_finish(smx_activity_t synchro); /* 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* 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* 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() diff --git a/include/simgrid/simix.hpp b/include/simgrid/simix.hpp index f21fa3d539..0eb3375afc 100644 --- a/include/simgrid/simix.hpp +++ b/include/simgrid/simix.hpp @@ -1,4 +1,4 @@ -/* 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 @@ -15,7 +15,7 @@ #include #include -XBT_PUBLIC(void) simcall_run_kernel(std::function const& code); +XBT_PUBLIC void simcall_run_kernel(std::function const& code); /** Execute some code in the kernel and block * @@ -26,7 +26,7 @@ XBT_PUBLIC(void) simcall_run_kernel(std::function const& code); * * @ref simix::kernelSync() is a higher level wrapper for this. */ -XBT_PUBLIC(void) simcall_run_blocking(std::function const& code); +XBT_PUBLIC void simcall_run_blocking(std::function const& code); template inline void simcall_run_kernel(F& f) @@ -69,10 +69,10 @@ typename std::result_of::type kernelImmediate(F&& code) return result.get(); } -XBT_PUBLIC(const std::vector&) process_get_runnable(); +XBT_PUBLIC const std::vector& process_get_runnable(); -XBT_PUBLIC(void) set_maestro(std::function code); -XBT_PUBLIC(void) create_maestro(std::function code); +XBT_PUBLIC void set_maestro(std::function code); +XBT_PUBLIC void create_maestro(std::function code); // What's executed as SIMIX actor code: typedef std::function ActorCode; @@ -80,7 +80,7 @@ typedef std::function ActorCode; // Create ActorCode based on argv: typedef std::function 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 * @@ -108,14 +108,12 @@ typedef smx_actor_t (*smx_creation_func_t)( /* props */ std::map*, /* 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 code, void* data, sg_host_t host, - std::map* properties); +XBT_PUBLIC smx_actor_t simcall_process_create(const char* name, std::function code, void* data, sg_host_t host, + std::map* properties); -XBT_PUBLIC(smx_timer_t) SIMIX_timer_set(double date, simgrid::xbt::Task callback); +XBT_PUBLIC smx_timer_t SIMIX_timer_set(double date, simgrid::xbt::Task callback); template inline smx_timer_t SIMIX_timer_set(double date, F callback) diff --git a/include/simgrid/simix/blocking_simcall.hpp b/include/simgrid/simix/blocking_simcall.hpp index 8cd2eee73f..ccfc8a1e5a 100644 --- a/include/simgrid/simix/blocking_simcall.hpp +++ b/include/simgrid/simix/blocking_simcall.hpp @@ -1,4 +1,4 @@ -/* 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 @@ -19,12 +19,12 @@ #include #include -XBT_PUBLIC(void) simcall_run_blocking(std::function const& code); +XBT_PUBLIC void simcall_run_blocking(std::function 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. diff --git a/include/simgrid_config.h.in b/include/simgrid_config.h.in index f2517b4f3a..e82560f88e 100644 --- a/include/simgrid_config.h.in +++ b/include/simgrid_config.h.in @@ -1,6 +1,6 @@ /* 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. */ @@ -20,10 +20,10 @@ 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() diff --git a/include/smpi/smpi.h b/include/smpi/smpi.h index 490a9e7b11..324f0923e8 100644 --- a/include/smpi/smpi.h +++ b/include/smpi/smpi.h @@ -378,283 +378,291 @@ typedef int MPI_Win_delete_attr_function(MPI_Win win, int keyval, void* attribut 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 @@ -704,215 +712,242 @@ XBT_PUBLIC_DATA(MPI_Errhandler*) MPI_ERRORS_RETURN; 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__); \ @@ -923,40 +958,41 @@ XBT_PUBLIC(void) smpi_trace_set_call_location__(const char *file, int* 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; \ @@ -1022,7 +1058,7 @@ SG_END_DECL() #ifdef __cplusplus #include -XBT_PUBLIC(int) smpi_is_shared(void* ptr, std::vector>& private_blocks, size_t* offset); +XBT_PUBLIC int smpi_is_shared(void* ptr, std::vector>& private_blocks, size_t* offset); std::vector> shift_and_frame_private_blocks(const std::vector> vec, size_t offset, size_t buff_size); diff --git a/include/xbt/RngStream.h b/include/xbt/RngStream.h index 06ade631f9..ffed6ac680 100644 --- a/include/xbt/RngStream.h +++ b/include/xbt/RngStream.h @@ -1,4 +1,4 @@ -/* 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 @@ -23,22 +23,22 @@ struct RngStream_InfoState { 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(); diff --git a/include/xbt/automaton.h b/include/xbt/automaton.h index a0f9013d79..f76712c0f6 100644 --- a/include/xbt/automaton.h +++ b/include/xbt/automaton.h @@ -60,57 +60,58 @@ typedef struct xbt_automaton_propositional_symbol* xbt_automaton_propositional_s 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() diff --git a/include/xbt/backtrace.h b/include/xbt/backtrace.h index dd4fb3d7ed..6367997f40 100644 --- a/include/xbt/backtrace.h +++ b/include/xbt/backtrace.h @@ -1,4 +1,4 @@ -/* 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 @@ -14,19 +14,19 @@ SG_BEGIN_DECL() 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() diff --git a/include/xbt/backtrace.hpp b/include/xbt/backtrace.hpp index ca3f282e52..754bd5fb22 100644 --- a/include/xbt/backtrace.hpp +++ b/include/xbt/backtrace.hpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2005-2019. The SimGrid Team. +/* Copyright (c) 2005-2018. The SimGrid Team. * All rights reserved. */ #ifndef SIMGRIX_XBT_BACKTRACE_HPP @@ -20,18 +20,16 @@ namespace xbt { * * Return the origin string if this fails. */ -XBT_PUBLIC() std::unique_ptr demangle(const char* name); +XBT_PUBLIC std::unique_ptr demangle(const char* name); /** Get the current backtrace */ -XBT_PUBLIC(std::vector) backtrace(); +XBT_PUBLIC std::vector backtrace(); /* Translate the backtrace in a human friendly form * * Try ro resolve symbols and source code location. */ -XBT_PUBLIC(std::vector) resolveBacktrace( - xbt_backtrace_location_t const* loc, std::size_t count); - +XBT_PUBLIC std::vector resolveBacktrace(xbt_backtrace_location_t const* loc, std::size_t count); } } diff --git a/include/xbt/base.h b/include/xbt/base.h index 64864667a3..e0ab2066df 100644 --- a/include/xbt/base.h +++ b/include/xbt/base.h @@ -156,8 +156,7 @@ /* 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 @@ -166,8 +165,7 @@ /* 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 @@ -175,8 +173,7 @@ # 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 @@ -184,8 +181,7 @@ # 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 diff --git a/include/xbt/config.h b/include/xbt/config.h index 4ad8e1f809..c5f9480ba0 100644 --- a/include/xbt/config.h +++ b/include/xbt/config.h @@ -1,7 +1,7 @@ /* 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. */ @@ -67,26 +67,26 @@ typedef void* xbt_cfg_t; 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); /* @} */ @@ -97,13 +97,13 @@ 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 @@ -112,14 +112,16 @@ XBT_PUBLIC(void) xbt_cfg_dump(const char *name, const char *indent, xbt_cfg_t cf * * @{ */ -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 @@ -135,9 +137,9 @@ XBT_PUBLIC(void) xbt_cfg_help(); * @{ */ -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); /** @} */ diff --git a/include/xbt/config.hpp b/include/xbt/config.hpp index d457e57a4e..5585106c7b 100644 --- a/include/xbt/config.hpp +++ b/include/xbt/config.hpp @@ -1,4 +1,4 @@ -/* 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. */ @@ -52,13 +52,12 @@ inline std::string to_string(std::string&& value) // Get config -template -XBT_PUBLIC(T const&) getConfig(const char* name); +template XBT_PUBLIC T const& getConfig(const char* name); -extern template XBT_PUBLIC(int const&) getConfig(const char* name); -extern template XBT_PUBLIC(double const&) getConfig(const char* name); -extern template XBT_PUBLIC(bool const&) getConfig(const char* name); -extern template XBT_PUBLIC(std::string const&) getConfig(const char* name); +extern template XBT_PUBLIC int const& getConfig(const char* name); +extern template XBT_PUBLIC double const& getConfig(const char* name); +extern template XBT_PUBLIC bool const& getConfig(const char* name); +extern template XBT_PUBLIC std::string const& getConfig(const char* name); // Register: @@ -69,22 +68,22 @@ extern template XBT_PUBLIC(std::string const&) getConfig(const char * @param value Initial/default value * @param callback called with the option value */ -template -XBT_PUBLIC(void) declareFlag(const char* name, const char* description, - T value, std::function callback = std::function()); - -extern template XBT_PUBLIC(void) declareFlag(const char* name, - const char* description, int value, std::function callback); -extern template XBT_PUBLIC(void) declareFlag(const char* name, - const char* description, double value, std::function callback); -extern template XBT_PUBLIC(void) declareFlag(const char* name, - const char* description, bool value, std::function callback); -extern template XBT_PUBLIC(void) declareFlag(const char* name, - const char* description, std::string value, std::function callback); +template +XBT_PUBLIC void declareFlag(const char* name, const char* description, T value, + std::function callback = std::function()); + +extern template XBT_PUBLIC void declareFlag(const char* name, const char* description, int value, + std::function callback); +extern template XBT_PUBLIC void declareFlag(const char* name, const char* description, double value, + std::function callback); +extern template XBT_PUBLIC void declareFlag(const char* name, const char* description, bool value, + std::function callback); +extern template XBT_PUBLIC void declareFlag(const char* name, const char* description, std::string value, + std::function 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 names) @@ -238,6 +237,6 @@ public: } } -XBT_PUBLIC(std::string) xbt_cfg_get_string(const char* name); +XBT_PUBLIC std::string xbt_cfg_get_string(const char* name); #endif diff --git a/include/xbt/cunit.h b/include/xbt/cunit.h index 24b4449f54..0edb99d701 100644 --- a/include/xbt/cunit.h +++ b/include/xbt/cunit.h @@ -1,6 +1,6 @@ /* 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. */ @@ -27,8 +27,8 @@ typedef struct s_xbt_test_unit *xbt_test_unit_t; 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. @@ -46,11 +46,11 @@ XBT_PUBLIC(void) xbt_test_suite_push(xbt_test_suite_t suite, const char *name, t * * 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 @@ -96,9 +96,9 @@ XBT_PUBLIC(void) xbt_test_exit(); #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__) @@ -124,12 +124,12 @@ XBT_PUBLIC(void) _xbt_test_log(const char *file, int line, const char *fmt, ...) #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(); /** @} */ diff --git a/include/xbt/dict.h b/include/xbt/dict.h index 30f9ec32f1..3c27e58838 100644 --- a/include/xbt/dict.h +++ b/include/xbt/dict.h @@ -55,9 +55,9 @@ typedef struct s_xbt_dictelm { 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 @@ -68,24 +68,24 @@ XBT_PUBLIC(unsigned int) xbt_dict_size(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); +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 @@ -95,10 +95,10 @@ XBT_PUBLIC(int) xbt_dict_is_empty(xbt_dict_t dict); * * @{ */ -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; @@ -135,19 +135,19 @@ static inline xbt_dictelm_t xbt_dict_cursor_get_elm(xbt_dict_cursor_t cursor) { 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 diff --git a/include/xbt/dynar.h b/include/xbt/dynar.h index 5484ccdc41..89e9597022 100644 --- a/include/xbt/dynar.h +++ b/include/xbt/dynar.h @@ -1,6 +1,6 @@ /* 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. */ @@ -64,14 +64,14 @@ SG_BEGIN_DECL() /** \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 @@ -80,21 +80,21 @@ XBT_PUBLIC(void) xbt_dynar_dump(xbt_dynar_t dynar); * @{ */ -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 @@ -103,10 +103,10 @@ XBT_PUBLIC(void *) xbt_dynar_to_array (xbt_dynar_t dynar); * @{ */ -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 @@ -115,11 +115,11 @@ XBT_PUBLIC(void) xbt_dynar_merge(xbt_dynar_t *d1, xbt_dynar_t *d2); * @{ */ -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 @@ -130,11 +130,11 @@ XBT_PUBLIC(void) xbt_dynar_map(const xbt_dynar_t dynar, void_f_pvoid_t const op) * @{ */ -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 @@ -187,7 +187,7 @@ XBT_PUBLIC(void *) xbt_dynar_pop_ptr(xbt_dynar_t const dynar); * @{ */ -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: @@ -205,7 +205,7 @@ typedef struct xbt_dynar_s { 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; diff --git a/include/xbt/ex.h b/include/xbt/ex.h index f8751366f7..5a4e63efbf 100644 --- a/include/xbt/ex.h +++ b/include/xbt/ex.h @@ -51,13 +51,13 @@ SG_BEGIN_DECL() /** 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 @@ -95,7 +95,7 @@ XBT_ATTRIB_NORETURN XBT_PUBLIC(void) #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() diff --git a/include/xbt/ex.hpp b/include/xbt/ex.hpp index 4208eead89..e4958f9d25 100644 --- a/include/xbt/ex.hpp +++ b/include/xbt/ex.hpp @@ -25,9 +25,7 @@ * * @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("") diff --git a/include/xbt/graph.h b/include/xbt/graph.h index 91ad42fe8f..5346279b79 100644 --- a/include/xbt/graph.h +++ b/include/xbt/graph.h @@ -1,4 +1,4 @@ -/* 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. */ @@ -50,24 +50,24 @@ typedef struct xbt_graph { } 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 */ diff --git a/include/xbt/log.h b/include/xbt/log.h index 7819e7e904..5c4c61a7e2 100644 --- a/include/xbt/log.h +++ b/include/xbt/log.h @@ -218,7 +218,7 @@ typedef enum { /* 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; @@ -264,7 +264,7 @@ struct xbt_log_event_s { * * 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 @@ -273,7 +273,7 @@ XBT_PUBLIC(void) xbt_log_threshold_set(xbt_log_category_t cat, e_xbt_log_priorit * * 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) @@ -281,7 +281,7 @@ XBT_PUBLIC(void) xbt_log_appender_set(xbt_log_category_t cat, xbt_log_appender_t * * 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 @@ -291,23 +291,23 @@ XBT_PUBLIC(void) xbt_log_layout_set(xbt_log_category_t cat, xbt_log_layout_t lay * 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); diff --git a/include/xbt/log.hpp b/include/xbt/log.hpp index 6dbf711f5f..4b4826c3e5 100644 --- a/include/xbt/log.hpp +++ b/include/xbt/log.hpp @@ -1,4 +1,4 @@ -/* 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. */ @@ -16,11 +16,8 @@ namespace xbt { * * @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(); } } diff --git a/include/xbt/mallocator.h b/include/xbt/mallocator.h index d0b0f36130..d6107d4bf9 100644 --- a/include/xbt/mallocator.h +++ b/include/xbt/mallocator.h @@ -1,6 +1,6 @@ /* 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 @@ -33,9 +33,9 @@ SG_BEGIN_DECL() */ /** \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 */ @@ -44,10 +44,10 @@ XBT_PUBLIC(void) xbt_mallocator_free(xbt_mallocator_t mallocator); * * @{ */ -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() diff --git a/include/xbt/misc.h b/include/xbt/misc.h index dc19d77d9b..8c133be84c 100644 --- a/include/xbt/misc.h +++ b/include/xbt/misc.h @@ -1,6 +1,6 @@ /* 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 @@ -24,7 +24,7 @@ XBT_PUBLIC_DATA(int) xbt_pagesize; 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; @@ -37,12 +37,12 @@ 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() diff --git a/include/xbt/mmalloc.h b/include/xbt/mmalloc.h index a8b49c46f4..eff59a07dd 100644 --- a/include/xbt/mmalloc.h +++ b/include/xbt/mmalloc.h @@ -1,4 +1,4 @@ -/* 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 @@ -31,29 +31,29 @@ typedef struct mdesc s_xbt_mheap_t; 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); diff --git a/include/xbt/module.h b/include/xbt/module.h index ba5b03ffa9..353baade42 100644 --- a/include/xbt/module.h +++ b/include/xbt/module.h @@ -1,6 +1,6 @@ /* 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. */ @@ -12,7 +12,7 @@ SG_BEGIN_DECL() -XBT_PUBLIC(void) xbt_init(int *argc, char **argv); +XBT_PUBLIC void xbt_init(int* argc, char** argv); SG_END_DECL() diff --git a/include/xbt/replay.hpp b/include/xbt/replay.hpp index a969fbc8ad..bad7a8573b 100644 --- a/include/xbt/replay.hpp +++ b/include/xbt/replay.hpp @@ -1,6 +1,6 @@ /* 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 @@ -22,7 +22,7 @@ typedef std::vector ReplayAction; static std::unordered_map*> 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 @@ -30,8 +30,8 @@ XBT_PUBLIC(int) replay_runner(int argc, char* argv[]); 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() diff --git a/include/xbt/str.h b/include/xbt/str.h index 8068459aed..31b2fa12d3 100644 --- a/include/xbt/str.h +++ b/include/xbt/str.h @@ -1,6 +1,6 @@ /* 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 @@ -26,14 +26,14 @@ SG_BEGIN_DECL() * @{ */ -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 @@ -41,7 +41,7 @@ XBT_PUBLIC(double) xbt_str_parse_double(const char* str, const char* error_msg); /** * @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 */ diff --git a/include/xbt/string.hpp b/include/xbt/string.hpp index 0cc1c4899a..15bf86d824 100644 --- a/include/xbt/string.hpp +++ b/include/xbt/string.hpp @@ -1,4 +1,4 @@ -/* 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. */ @@ -300,13 +300,13 @@ typedef std::string string; * * @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); } } diff --git a/include/xbt/synchro.h b/include/xbt/synchro.h index e5f7d066d8..3a990f18e9 100644 --- a/include/xbt/synchro.h +++ b/include/xbt/synchro.h @@ -1,6 +1,6 @@ /* 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. */ @@ -29,10 +29,10 @@ SG_BEGIN_DECL() 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. @@ -40,13 +40,13 @@ XBT_PUBLIC(void) xbt_mutex_acquire(xbt_mutex_t mutex); * \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 @@ -54,19 +54,19 @@ XBT_PUBLIC(void) xbt_mutex_destroy(xbt_mutex_t mutex); 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); /** @} */ diff --git a/include/xbt/sysdep.h b/include/xbt/sysdep.h index 3cbeb656c0..d0b94e7bcb 100644 --- a/include/xbt/sysdep.h +++ b/include/xbt/sysdep.h @@ -2,7 +2,7 @@ /* 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 @@ -31,7 +31,7 @@ SG_BEGIN_DECL() * @{ */ /** @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 @@ -71,7 +71,7 @@ static XBT_ALWAYS_INLINE char *xbt_strdup(const char *s) { 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 */ @@ -114,9 +114,9 @@ static XBT_ALWAYS_INLINE void *xbt_realloc(void *p, size_t s) { #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() diff --git a/include/xbt/virtu.h b/include/xbt/virtu.h index bb4bad248f..ef604516e4 100644 --- a/include/xbt/virtu.h +++ b/include/xbt/virtu.h @@ -1,6 +1,6 @@ /* 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. */ @@ -15,9 +15,9 @@ 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; diff --git a/include/xbt/xbt_os_thread.h b/include/xbt/xbt_os_thread.h index 23b8fc8339..f0e976b2ef 100644 --- a/include/xbt/xbt_os_thread.h +++ b/include/xbt/xbt_os_thread.h @@ -1,6 +1,6 @@ /* 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. */ @@ -24,50 +24,51 @@ typedef pthread_key_t xbt_os_thread_key_t; * @{ */ -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); /** @} */ diff --git a/include/xbt/xbt_os_time.h b/include/xbt/xbt_os_time.h index e7b2c244c7..074218bab8 100644 --- a/include/xbt/xbt_os_time.h +++ b/include/xbt/xbt_os_time.h @@ -1,6 +1,6 @@ /* 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. */ @@ -17,27 +17,27 @@ SG_BEGIN_DECL() * * 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() diff --git a/src/include/instr/instr_interface.h b/src/include/instr/instr_interface.h index a3262e054a..e31aea68b6 100644 --- a/src/include/instr/instr_interface.h +++ b/src/include/instr/instr_interface.h @@ -1,4 +1,4 @@ -/* 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. */ @@ -10,10 +10,10 @@ 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() diff --git a/src/include/mc/mc.h b/src/include/mc/mc.h index 49e0f09826..3119413da9 100644 --- a/src/include/mc/mc.h +++ b/src/include/mc/mc.h @@ -1,4 +1,4 @@ -/* 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. */ @@ -25,17 +25,17 @@ 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; @@ -55,13 +55,13 @@ XBT_PRIVATE void _mc_cfg_cb_comms_determinism(const char *name); 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() diff --git a/src/include/simgrid/sg_config.h b/src/include/simgrid/sg_config.h index 304b7b65bd..f185d514b1 100644 --- a/src/include/simgrid/sg_config.h +++ b/src/include/simgrid/sg_config.h @@ -1,4 +1,4 @@ -/* 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. */ @@ -16,8 +16,8 @@ XBT_PUBLIC_DATA(xbt_cfg_t) simgrid_config; 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() diff --git a/src/include/surf/surf.hpp b/src/include/surf/surf.hpp index 84b8c16bd2..a6b24d481b 100644 --- a/src/include/surf/surf.hpp +++ b/src/include/surf/surf.hpp @@ -58,8 +58,8 @@ struct surf_model_description { }; 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 */ @@ -73,7 +73,7 @@ XBT_PUBLIC(void) model_help(const char* category, s_surf_model_description_t* ta * @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); /** @@ -82,7 +82,7 @@ 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); /** @@ -91,7 +91,7 @@ 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] @@ -100,7 +100,7 @@ XBT_PUBLIC(int) surf_model_running_action_set_size(simgrid::kernel::resource::Mo * @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); /** @} */ @@ -127,14 +127,14 @@ XBT_PUBLIC_DATA(surf_cpu_model_t) surf_cpu_model_vm; * * 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). @@ -169,7 +169,7 @@ XBT_PUBLIC_DATA(surf_network_model_t) surf_network_model; * * \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. @@ -179,7 +179,7 @@ XBT_PUBLIC(void) surf_network_model_init_SMPI(); * * \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' @@ -189,7 +189,7 @@ XBT_PUBLIC(void) surf_network_model_init_IB(); * * \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' @@ -200,7 +200,7 @@ XBT_PUBLIC(void) surf_network_model_init_LegrandVelho(); * * \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 @@ -208,7 +208,7 @@ XBT_PUBLIC(void) surf_network_model_init_Constant(); * 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 @@ -218,7 +218,7 @@ XBT_PUBLIC(void) surf_network_model_init_CM02(); * * \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 @@ -231,7 +231,7 @@ XBT_PUBLIC(void) surf_network_model_init_NS3(); * * 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 @@ -244,7 +244,7 @@ XBT_PUBLIC(void) surf_network_model_init_Reno(); * * 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 @@ -257,7 +257,7 @@ XBT_PUBLIC(void) surf_network_model_init_Reno2(); * * 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 @@ -267,7 +267,7 @@ XBT_PUBLIC_DATA(s_surf_model_description_t) surf_network_model_description[]; /** \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. @@ -290,7 +290,7 @@ XBT_PUBLIC_DATA(surf_host_model_t) surf_host_model; * * 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 @@ -300,7 +300,7 @@ XBT_PUBLIC(void) surf_host_model_init_compound(); * 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 @@ -308,7 +308,7 @@ XBT_PUBLIC(void) surf_host_model_init_current_default(); * 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 @@ -323,7 +323,7 @@ XBT_PUBLIC_DATA(s_surf_model_description_t) surf_host_model_description[]; * 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 **************************/ @@ -337,14 +337,14 @@ XBT_PUBLIC(void) surf_vm_model_init_HL13(); * * \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 @@ -356,14 +356,14 @@ XBT_PUBLIC(void) surf_presolve(); * 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 @@ -372,10 +372,10 @@ XBT_PUBLIC(double) surf_get_clock(); * * \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 **********/ diff --git a/src/instr/instr_private.hpp b/src/instr/instr_private.hpp index 75690784bf..6e3af5519e 100644 --- a/src/instr/instr_private.hpp +++ b/src/instr/instr_private.hpp @@ -213,11 +213,11 @@ XBT_PRIVATE bool TRACE_display_sizes(); 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, diff --git a/src/kernel/activity/ActivityImpl.hpp b/src/kernel/activity/ActivityImpl.hpp index 24f6e483bc..21192104a5 100644 --- a/src/kernel/activity/ActivityImpl.hpp +++ b/src/kernel/activity/ActivityImpl.hpp @@ -1,4 +1,4 @@ -/* 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. */ @@ -32,8 +32,8 @@ namespace activity { virtual void post() =0; // What to do when a simcall terminates // boost::intrusive_ptr 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}; diff --git a/src/kernel/activity/MutexImpl.hpp b/src/kernel/activity/MutexImpl.hpp index 1274e793ef..fb90e8ebea 100644 --- a/src/kernel/activity/MutexImpl.hpp +++ b/src/kernel/activity/MutexImpl.hpp @@ -1,4 +1,4 @@ -/* 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. */ @@ -14,7 +14,7 @@ namespace simgrid { namespace kernel { namespace activity { -class XBT_PUBLIC() MutexImpl { +class XBT_PUBLIC MutexImpl { public: MutexImpl(); ~MutexImpl(); diff --git a/src/kernel/context/Context.hpp b/src/kernel/context/Context.hpp index 7b53ca9556..96997034f7 100644 --- a/src/kernel/context/Context.hpp +++ b/src/kernel/context/Context.hpp @@ -1,4 +1,4 @@ -/* 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. */ @@ -153,8 +153,8 @@ extern "C" { XBT_PRIVATE void SIMIX_context_mod_init(); XBT_PRIVATE void SIMIX_context_mod_exit(); -XBT_PUBLIC(smx_context_t) -SIMIX_context_new(std::function code, void_pfn_smxprocess_t cleanup_func, smx_actor_t simix_process); +XBT_PUBLIC smx_context_t SIMIX_context_new(std::function code, void_pfn_smxprocess_t cleanup_func, + smx_actor_t simix_process); #ifndef WIN32 XBT_PUBLIC_DATA(char sigsegv_stack[SIGSTKSZ]); @@ -173,15 +173,15 @@ 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(); } diff --git a/src/kernel/lmm/maxmin.hpp b/src/kernel/lmm/maxmin.hpp index d0930c0b55..db0a09805d 100644 --- a/src/kernel/lmm/maxmin.hpp +++ b/src/kernel/lmm/maxmin.hpp @@ -138,29 +138,28 @@ namespace lmm { * @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 diff --git a/src/kernel/routing/NetPoint.hpp b/src/kernel/routing/NetPoint.hpp index 0a4827427d..ee02d4a7b7 100644 --- a/src/kernel/routing/NetPoint.hpp +++ b/src/kernel/routing/NetPoint.hpp @@ -1,4 +1,4 @@ -/* 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. */ @@ -54,6 +54,6 @@ private: } } -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_ */ diff --git a/src/mc/checker/Checker.hpp b/src/mc/checker/Checker.hpp index d69ba2455f..c0ea47c07a 100644 --- a/src/mc/checker/Checker.hpp +++ b/src/mc/checker/Checker.hpp @@ -1,4 +1,4 @@ -/* 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 @@ -64,10 +64,9 @@ protected: 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); } } diff --git a/src/mc/mc_ignore.h b/src/mc/mc_ignore.h index 58f1795577..f146f50e53 100644 --- a/src/mc/mc_ignore.h +++ b/src/mc/mc_ignore.h @@ -1,4 +1,4 @@ -/* 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. */ @@ -12,7 +12,7 @@ #include /* 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 diff --git a/src/mc/remote/Client.hpp b/src/mc/remote/Client.hpp index dc10fd8c40..1d4cd21ece 100644 --- a/src/mc/remote/Client.hpp +++ b/src/mc/remote/Client.hpp @@ -1,4 +1,4 @@ -/* 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 @@ -26,7 +26,7 @@ namespace mc { * * 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 instance_; diff --git a/src/msg/msg_process.cpp b/src/msg/msg_process.cpp index 78ea89df16..a366f62ecc 100644 --- a/src/msg/msg_process.cpp +++ b/src/msg/msg_process.cpp @@ -1,4 +1,4 @@ -/* 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. */ @@ -272,7 +272,8 @@ msg_error_t MSG_process_set_data(msg_process_t process, void *data) * \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; } @@ -481,21 +482,23 @@ void MSG_process_on_exit(int_f_pvoid_pvoid_t fun, void *data) { * \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(); } @@ -503,14 +506,14 @@ XBT_PUBLIC(void) MSG_process_daemonize(msg_process_t process) /** @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); } diff --git a/src/s4u/s4u_actor.cpp b/src/s4u/s4u_actor.cpp index 10be2246fa..b9957b2186 100644 --- a/src/s4u/s4u_actor.cpp +++ b/src/s4u/s4u_actor.cpp @@ -1,4 +1,4 @@ -/* 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. */ @@ -257,7 +257,7 @@ void yield() 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) diff --git a/src/simdag/dax_dtd.h b/src/simdag/dax_dtd.h index 5552c33ca7..2763df185d 100644 --- a/src/simdag/dax_dtd.h +++ b/src/simdag/dax_dtd.h @@ -48,16 +48,16 @@ #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; @@ -188,10 +188,10 @@ XBT_PUBLIC_DATA(AT_dax__uses_type) AX_dax__uses_type; 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); diff --git a/src/simix/libsmx.cpp b/src/simix/libsmx.cpp index 15f0a2ea90..9f692a557a 100644 --- a/src/simix/libsmx.cpp +++ b/src/simix/libsmx.cpp @@ -5,7 +5,7 @@ /* */ /* 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. */ @@ -259,7 +259,7 @@ void simcall_process_set_kill_time(smx_actor_t process, double kill_time) * \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); } diff --git a/src/simix/smx_global.cpp b/src/simix/smx_global.cpp index 2a650eb844..887a2fb4eb 100644 --- a/src/simix/smx_global.cpp +++ b/src/simix/smx_global.cpp @@ -176,7 +176,7 @@ namespace simix { simgrid::xbt::signal onDeadlock; -XBT_PUBLIC(void) set_maestro(std::function code) +XBT_PUBLIC void set_maestro(std::function code) { maestro_code = std::move(code); } diff --git a/src/simix/smx_private.hpp b/src/simix/smx_private.hpp index 8bbb7ecad9..7764500538 100644 --- a/src/simix/smx_private.hpp +++ b/src/simix/smx_private.hpp @@ -1,4 +1,4 @@ -/* 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. */ @@ -20,7 +20,7 @@ namespace simgrid { 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; @@ -68,7 +68,7 @@ extern "C" { XBT_PUBLIC_DATA(std::unique_ptr) simix_global; -XBT_PUBLIC(void) SIMIX_clean(); +XBT_PUBLIC void SIMIX_clean(); /******************************** Exceptions *********************************/ /** @brief Ask to the provided ActorImpl to raise the provided exception */ diff --git a/src/smpi/colls/smpi_mvapich2_selector_stampede.hpp b/src/smpi/colls/smpi_mvapich2_selector_stampede.hpp index 24cdf97b2a..60f251c2d3 100644 --- a/src/smpi/colls/smpi_mvapich2_selector_stampede.hpp +++ b/src/smpi/colls/smpi_mvapich2_selector_stampede.hpp @@ -2,7 +2,7 @@ /* 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. */ @@ -16,7 +16,7 @@ #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; diff --git a/src/smpi/include/private.hpp b/src/smpi/include/private.hpp index 09594c2374..ad5ae02cae 100644 --- a/src/smpi/include/private.hpp +++ b/src/smpi/include/private.hpp @@ -432,7 +432,7 @@ extern std::unordered_map location2speedup; /** @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 { diff --git a/src/smpi/include/smpi_coll.hpp b/src/smpi/include/smpi_coll.hpp index 99a7377644..9dfb2e3fb1 100644 --- a/src/smpi/include/smpi_coll.hpp +++ b/src/smpi/include/smpi_coll.hpp @@ -1,5 +1,5 @@ /*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 @@ -90,8 +90,8 @@ struct s_mpi_coll_description_t { 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 diff --git a/src/smpi/include/smpi_utils.hpp b/src/smpi/include/smpi_utils.hpp index 038a40b5f0..dca417d67f 100644 --- a/src/smpi/include/smpi_utils.hpp +++ b/src/smpi/include/smpi_utils.hpp @@ -19,6 +19,6 @@ struct s_smpi_factor_t { }; } -XBT_PUBLIC(std::vector) parse_factor(std::string smpi_coef_string); +XBT_PUBLIC std::vector parse_factor(std::string smpi_coef_string); #endif diff --git a/src/smpi/internals/smpi_bench.cpp b/src/smpi/internals/smpi_bench.cpp index 96b381881e..d0ccc26e96 100644 --- a/src/smpi/internals/smpi_bench.cpp +++ b/src/smpi/internals/smpi_bench.cpp @@ -1,4 +1,4 @@ -/* 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. */ @@ -30,13 +30,13 @@ double smpi_host_speed; 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); diff --git a/src/smpi/internals/smpi_dvfs.cpp b/src/smpi/internals/smpi_dvfs.cpp index 2d0ffd22e5..8fe3b4e702 100644 --- a/src/smpi/internals/smpi_dvfs.cpp +++ b/src/smpi/internals/smpi_dvfs.cpp @@ -1,4 +1,4 @@ -/* 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. */ @@ -87,31 +87,31 @@ struct doublecomplex { 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(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(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(*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(smpi_get_host_consumed_energy()); diff --git a/src/surf/cpu_interface.hpp b/src/surf/cpu_interface.hpp index 7e5db4e0b6..fb3f15528b 100644 --- a/src/surf/cpu_interface.hpp +++ b/src/surf/cpu_interface.hpp @@ -1,4 +1,4 @@ -/* 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. */ @@ -146,7 +146,7 @@ public: */ 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) diff --git a/src/surf/ns3/ns3_simulator.hpp b/src/surf/ns3/ns3_simulator.hpp index 602f0b9304..edb6fc7c8b 100644 --- a/src/surf/ns3/ns3_simulator.hpp +++ b/src/surf/ns3/ns3_simulator.hpp @@ -28,11 +28,11 @@ public: ns3::Ptr 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 { diff --git a/src/surf/surf_interface.hpp b/src/surf/surf_interface.hpp index 385a234718..07c50578e5 100644 --- a/src/surf/surf_interface.hpp +++ b/src/surf/surf_interface.hpp @@ -64,7 +64,7 @@ static inline int double_equals(double value1, double value2, double precision) } 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. diff --git a/src/surf/surf_private.hpp b/src/surf/surf_private.hpp index 1d460ff07b..b1f9e7c111 100644 --- a/src/surf/surf_private.hpp +++ b/src/surf/surf_private.hpp @@ -38,7 +38,7 @@ XBT_PRIVATE int __surf_is_absolute_file_path(const char* file_path); 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(); diff --git a/src/surf/trace_mgr.hpp b/src/surf/trace_mgr.hpp index 36ce190459..acac83b815 100644 --- a/src/surf/trace_mgr.hpp +++ b/src/surf/trace_mgr.hpp @@ -1,4 +1,4 @@ -/* 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. */ @@ -29,12 +29,12 @@ typedef s_tmgr_trace_event_t* tmgr_trace_event_t; * 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 { diff --git a/src/surf/xml/platf.hpp b/src/surf/xml/platf.hpp index 7b1c5b4f18..c30139c158 100644 --- a/src/surf/xml/platf.hpp +++ b/src/surf/xml/platf.hpp @@ -1,4 +1,4 @@ -/* 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. */ @@ -11,23 +11,23 @@ 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 diff --git a/src/surf/xml/platf_private.hpp b/src/surf/xml/platf_private.hpp index 2a62c6db05..456a10a0be 100644 --- a/src/surf/xml/platf_private.hpp +++ b/src/surf/xml/platf_private.hpp @@ -1,6 +1,6 @@ /* 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 @@ -187,46 +187,46 @@ public: 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 { diff --git a/src/surf/xml/simgrid_dtd.h b/src/surf/xml/simgrid_dtd.h index 3883f562c9..801cab37c0 100644 --- a/src/surf/xml/simgrid_dtd.h +++ b/src/surf/xml/simgrid_dtd.h @@ -48,68 +48,68 @@ #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; @@ -735,10 +735,10 @@ XBT_PUBLIC_DATA(AT_surfxml_zoneRoute_symmetrical) AX_surfxml_zoneRoute_symmetric 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); diff --git a/src/xbt/automaton/automaton.c b/src/xbt/automaton/automaton.c index 9fde6edb14..377992aa9b 100644 --- a/src/xbt/automaton/automaton.c +++ b/src/xbt/automaton/automaton.c @@ -1,6 +1,6 @@ /* 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. */ @@ -212,7 +212,9 @@ static int call_simple_function(void* function) 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; @@ -222,7 +224,9 @@ xbt_automaton_propositional_symbol_t xbt_automaton_propositional_symbol_new(xbt_ 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); @@ -233,10 +237,9 @@ XBT_PUBLIC(xbt_automaton_propositional_symbol_t) xbt_automaton_propositional_sym 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); @@ -247,7 +250,7 @@ XBT_PUBLIC(xbt_automaton_propositional_symbol_t) xbt_automaton_propositional_sym 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); @@ -255,17 +258,18 @@ XBT_PUBLIC(int) xbt_automaton_propositional_symbol_evaluate(xbt_automaton_propos 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; } diff --git a/src/xbt/config.cpp b/src/xbt/config.cpp index cb26929e8c..242483ba4f 100644 --- a/src/xbt/config.cpp +++ b/src/xbt/config.cpp @@ -1,4 +1,4 @@ -/* 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. */ @@ -30,9 +30,7 @@ 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 { @@ -379,16 +377,15 @@ void Config::help() // ***** getConfig ***** -template -XBT_PUBLIC(T const&) getConfig(const char* name) +template XBT_PUBLIC T const& getConfig(const char* name) { return (*simgrid_config)[name].getValue(); } -template XBT_PUBLIC(int const&) getConfig(const char* name); -template XBT_PUBLIC(double const&) getConfig(const char* name); -template XBT_PUBLIC(bool const&) getConfig(const char* name); -template XBT_PUBLIC(std::string const&) getConfig(const char* name); +template XBT_PUBLIC int const& getConfig(const char* name); +template XBT_PUBLIC double const& getConfig(const char* name); +template XBT_PUBLIC bool const& getConfig(const char* name); +template XBT_PUBLIC std::string const& getConfig(const char* name); // ***** alias ***** @@ -399,9 +396,8 @@ void alias(const char* realname, const char* aliasname) // ***** declareFlag ***** -template -XBT_PUBLIC(void) declareFlag(const char* name, const char* description, - T value, std::function callback) +template +XBT_PUBLIC void declareFlag(const char* name, const char* description, T value, std::function callback) { if (simgrid_config == nullptr) { simgrid_config = xbt_cfg_new(); @@ -411,15 +407,14 @@ XBT_PUBLIC(void) declareFlag(const char* name, const char* description, name, description, std::move(value), std::move(callback)); } -template XBT_PUBLIC(void) declareFlag(const char* name, - const char* description, int value, std::function callback); -template XBT_PUBLIC(void) declareFlag(const char* name, - const char* description, double value, std::function callback); -template XBT_PUBLIC(void) declareFlag(const char* name, - const char* description, bool value, std::function callback); -template XBT_PUBLIC(void) declareFlag(const char* name, - const char* description, std::string value, std::function callback); - +template XBT_PUBLIC void declareFlag(const char* name, const char* description, int value, + std::function callback); +template XBT_PUBLIC void declareFlag(const char* name, const char* description, double value, + std::function callback); +template XBT_PUBLIC void declareFlag(const char* name, const char* description, bool value, + std::function callback); +template XBT_PUBLIC void declareFlag(const char* name, const char* description, std::string value, + std::function callback); } } diff --git a/src/xbt/log_private.h b/src/xbt/log_private.h index 7946e17ced..e5095be5b4 100644 --- a/src/xbt/log_private.h +++ b/src/xbt/log_private.h @@ -1,4 +1,4 @@ -/* 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. */ @@ -26,6 +26,6 @@ struct xbt_log_layout_s { * * 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 diff --git a/src/xbt/mmalloc/mmprivate.h b/src/xbt/mmalloc/mmprivate.h index 640e09fe28..e42acccd59 100644 --- a/src/xbt/mmalloc/mmprivate.h +++ b/src/xbt/mmalloc/mmprivate.h @@ -281,9 +281,9 @@ XBT_PUBLIC_DATA( struct mdesc ) *__mmalloc_default_mdp; /* 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) * diff --git a/tools/cmake/MaintainerMode.cmake b/tools/cmake/MaintainerMode.cmake index 14a4c81248..680eb7bfec 100644 --- a/tools/cmake/MaintainerMode.cmake +++ b/tools/cmake/MaintainerMode.cmake @@ -158,7 +158,7 @@ if(enable_maintainer_mode AND NOT WIN32) 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 /#if defined(_WIN32)\\n# ifndef __STRICT_ANSI__\\n# include \\n# include \\n# endif\\n#else\\n# include \\n#endif/g'") set(string14 "'\\!^ \\* Generated [0-9/]\\{10\\} [0-9:]\\{8\\}\\.$$!d'") -- 2.20.1