SG_BEGIN_DECL()
-/*
- * Functions to manage tracing categories
- */
+/* 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 (void);
XBT_PUBLIC(void) TRACE_smpi_set_category(const char *category);
-/*
- * Functions to manage tracing marks (used for trace comparison experiments)
- */
+/* 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 (void);
-/*
- * Function used by graphicator (transform a SimGrid platform
- * file in a graphviz dot file with the network topology)
- */
+/* 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);
-/*
- * User-variables related functions
- */
+/* 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_sub_with_time (double time, const char *vm, const char *variable, double value);
XBT_PUBLIC(xbt_dynar_t) TRACE_get_vm_variables (void);
-
/* 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);
#define JEDULE_EVENTS_H_
#include "simgrid_config.h"
-
#include "xbt/dynar.h"
#include "xbt/dict.h"
-
#include "simgrid/jedule/jedule_platform.h"
-
#ifdef HAVE_JEDULE
-
SG_BEGIN_DECL()
struct jed_event {
typedef struct jed_event s_jed_event_t, *jed_event_t;
-/************************************************************/
-
void create_jed_event(jed_event_t *event, char *name, double start_time, double end_time, const char *type);
-
void jed_event_free(jed_event_t event);
-
void jed_event_add_resources(jed_event_t event, xbt_dynar_t host_selection);
-
void jed_event_add_characteristic(jed_event_t event, char *characteristic);
-
void jed_event_add_info(jed_event_t event, char *key, char *value);
SG_END_DECL()
-
#endif
#endif /* JEDULE_EVENTS_H_ */
#ifndef JEDULE_OUTPUT_H_
#define JEDULE_OUTPUT_H_
-#include "simgrid_config.h"
-
#include <stdio.h>
-
+#include "simgrid_config.h"
#include "jedule_events.h"
#include "jedule_platform.h"
#ifdef HAVE_JEDULE
-
SG_BEGIN_DECL()
extern xbt_dynar_t jedule_event_list;
-
void jedule_init_output(void);
-
void jedule_cleanup_output(void);
-
void jedule_store_event(jed_event_t event);
-
-void write_jedule_output(FILE *file, jedule_t jedule,
- xbt_dynar_t event_list, xbt_dict_t meta_info_dict);
+void write_jedule_output(FILE *file, jedule_t jedule, xbt_dynar_t event_list, xbt_dict_t meta_info_dict);
SG_END_DECL()
-
#endif
#endif /* JEDULE_OUTPUT_H_ */
#define JED_SIMGRID_PLATFORM_H_
#include "simgrid_config.h"
-
#include "xbt/dynar.h"
#include "xbt/dict.h"
#ifdef HAVE_JEDULE
-
SG_BEGIN_DECL()
-typedef struct jed_simgrid_container s_jed_simgrid_container_t,
- *jed_simgrid_container_t;
+typedef struct jed_simgrid_container s_jed_simgrid_container_t, *jed_simgrid_container_t;
struct jed_simgrid_container {
int is_lowest;
};
-
-/**
- * selection of a subset of resources from the original set
- *
- */
+/** selection of a subset of resources from the original set */
struct jed_res_subset {
jed_simgrid_container_t parent;
int start_idx; // start idx in resource_list of container
typedef struct jedule_struct s_jedule_t, *jedule_t;
-
-/*********************************************************/
-
void jed_create_jedule(jedule_t *jedule);
-
void jed_free_jedule(jedule_t jedule);
-
void jedule_add_meta_info(jedule_t jedule, char *key, char *value);
-
-void jed_simgrid_create_container(jed_simgrid_container_t *container,
- const char *name);
-
-void jed_simgrid_add_container(jed_simgrid_container_t parent,
- jed_simgrid_container_t child);
-
-void jed_simgrid_add_resources(jed_simgrid_container_t parent,
- xbt_dynar_t host_names);
+void jed_simgrid_create_container(jed_simgrid_container_t *container, const char *name);
+void jed_simgrid_add_container(jed_simgrid_container_t parent, jed_simgrid_container_t child);
+void jed_simgrid_add_resources(jed_simgrid_container_t parent, xbt_dynar_t host_names);
/**
- *
- * it is assumed that the host_names in the entire system are unique
- * that means that we don't need parent references
+ * it is assumed that the host_names in the entire system are unique that means that we don't need parent references
*
* subset_list must be allocated
* host_names is the list of host_names associated with an event
*/
-void jed_simgrid_get_resource_selection_by_hosts(xbt_dynar_t subset_list,
- xbt_dynar_t host_names);
+void jed_simgrid_get_resource_selection_by_hosts(xbt_dynar_t subset_list, xbt_dynar_t host_names);
/*
global:
hash host_id -> container
-
container:
hash host_id -> jed_host_id
-
list <- [ jed_host_ids ]
list <- sort( list )
list_chunks <- chunk( list ) -> [ 1, 3-5, 7-9 ]
-
*/
SG_END_DECL()
#ifdef HAVE_JEDULE
SG_BEGIN_DECL()
XBT_PUBLIC(void) jedule_log_sd_event(SD_task_t task);
-
XBT_PUBLIC(void) jedule_setup_platform(void);
-
XBT_PUBLIC(void) jedule_sd_init(void);
-
XBT_PUBLIC(void) jedule_sd_cleanup(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_ */
-
#endif
parameter(MPI_UNEQUAL=2)
parameter(MPI_CONGRUENT=3)
-
integer MPI_NULL_COPY_FN, MPI_NULL_DELETE_FN
parameter(MPI_NULL_COPY_FN =0)
parameter(MPI_NULL_DELETE_FN =0)
parameter(MPI_COMM_NULL_DUP_FN =0)
parameter(MPI_COMM_DUP_FN =0)
-
-
integer MPI_ROOT, MPI_INFO_NULL,MPI_COMM_TYPE_SHARED
parameter(MPI_ROOT=0)
parameter(MPI_INFO_NULL=0)
parameter(MPI_COMPLEX32=26)
parameter(MPI_PACKED=27)
-
-
! These should be ordered as in smpi_f77.c
integer MPI_OP_NULL,MPI_MAX, MPI_MIN, MPI_MAXLOC, MPI_MINLOC
integer MPI_SUM, MPI_PROD, MPI_LAND, MPI_LOR, MPI_LXOR, MPI_BAND
parameter(MPI_BAND=9)
parameter(MPI_BOR=10)
parameter(MPI_BXOR=11)
-
+
INTEGER MPI_ADDRESS_KIND, MPI_OFFSET_KIND
PARAMETER (MPI_ADDRESS_KIND=@CMAKE_SIZEOF_VOID_P@)
PARAMETER (MPI_OFFSET_KIND=@CMAKE_SIZEOF_VOID_P@)
#define MPI_T_ERR_PVAR_NO_STARTSTOP 72
#define MPI_T_ERR_PVAR_NO_ATOMIC 73
-
#define MPI_ERRCODES_IGNORE (int *)0
#define MPI_IDENT 0
#define MPI_SIMILAR 1
#define MPI_UNEQUAL 2
#define MPI_CONGRUENT 3
-
#define MPI_BSEND_OVERHEAD 0
/* Attribute keys */
#define MPI_DOUBLE_PRECISION MPI_DOUBLE
#define MPI_2DOUBLE_PRECISION MPI_2DOUBLE
-
-
-typedef void MPI_User_function(void *invec, void *inoutvec, int *len,
- MPI_Datatype * datatype);
+typedef void MPI_User_function(void *invec, void *inoutvec, int *len, MPI_Datatype * datatype);
struct s_smpi_mpi_op;
typedef struct s_smpi_mpi_op *MPI_Op;
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_Init_thread, (int *argc, char ***argv, int required, int *provided));
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_Abort, (MPI_Comm comm, int errorcode));
MPI_CALL(XBT_PUBLIC(int), MPI_Get_address, (void *location, MPI_Aint * address));
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_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_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_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_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_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_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_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_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_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_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_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_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_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_Testall,
- (int count, MPI_Request* requests, int* flag,
- MPI_Status* statuses));
-MPI_CALL(XBT_PUBLIC(int), MPI_Op_create,
- (MPI_User_function * function, int commute,
- MPI_Op * op));
+MPI_CALL(XBT_PUBLIC(int), MPI_Type_contiguous, (int count, MPI_Datatype old_type, MPI_Datatype* newtype));
+MPI_CALL(XBT_PUBLIC(int), MPI_Testall, (int count, MPI_Request* requests, int* flag, MPI_Status* statuses));
+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_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,
+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(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(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_Get_processor_name, (char *name, int *resultlen));
-MPI_CALL(XBT_PUBLIC(int), MPI_Get_count,
- (MPI_Status * status, MPI_Datatype datatype,
- int *count));
+MPI_CALL(XBT_PUBLIC(int), MPI_Get_count, (MPI_Status * status, MPI_Datatype datatype, int *count));
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_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, (MPI_Comm comm, MPI_Group group, 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(int), MPI_Send_init,
- (void *buf, int count, MPI_Datatype datatype,
- int dst, int tag, 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_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_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_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_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_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_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_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_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_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_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_Testsome,
- (int incount, MPI_Request requests[],
- int *outcount, int *indices,
+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_Bcast,
- (void *buf, int count, MPI_Datatype datatype,
- int root, MPI_Comm comm));
+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,
+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_Reduce,
- (void *sendbuf, void *recvbuf, int count,
- MPI_Datatype datatype, MPI_Op op, int root,
+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_Allreduce,
- (void *sendbuf, void *recvbuf, int count,
- MPI_Datatype datatype, MPI_Op op,
+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_Scan,
- (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_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_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_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(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_Reduce_local,(void *inbuf, void *inoutbuf, int count,
- MPI_Datatype datatype, MPI_Op op));
+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_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(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_Reduce_local,(void *inbuf, void *inoutbuf, int count, MPI_Datatype datatype, MPI_Op op));
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_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_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_get_group,(MPI_Win win, MPI_Group * group));
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_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_Alloc_mem, (MPI_Aint size, MPI_Info info, void *baseptr));
MPI_CALL(XBT_PUBLIC(int), MPI_Free_mem, (void *base));
MPI_CALL(XBT_PUBLIC(MPI_Fint), MPI_Errhandler_c2f,(MPI_Errhandler errhandler));
MPI_CALL(XBT_PUBLIC(int), MPI_Pack_size, (int incount, MPI_Datatype datatype, MPI_Comm comm, int* size));
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_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_map, (MPI_Comm comm_old, int ndims, int* dims, int* periods, int* newrank));
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_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_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_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_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_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_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_Unpack, (void* inbuf, int insize, int* position, void* outbuf, int outcount, MPI_Datatype type, MPI_Comm comm));
+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_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_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_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_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_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_Issend, (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_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_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_Keyval_create, (MPI_Copy_function* copy_fn, MPI_Delete_function* delete_fn, int* keyval, void* extra_state));
+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_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_Test_cancelled, (MPI_Status* status, int* flag));
-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, (void* inbuf, int incount, MPI_Datatype type, void* outbuf, int outcount,
+ int* position, MPI_Comm comm));
MPI_CALL(XBT_PUBLIC(int), MPI_Get_elements, (MPI_Status* status, MPI_Datatype datatype, int* elements));
MPI_CALL(XBT_PUBLIC(int), MPI_Dims_create, (int nnodes, int ndims, int* dims));
MPI_CALL(XBT_PUBLIC(int), MPI_Initialized, (int* flag));
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_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));
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_resized ,(MPI_Datatype oldtype,MPI_Aint lb, MPI_Aint extent, MPI_Datatype *newtype));
-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_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_resized ,(MPI_Datatype oldtype,MPI_Aint lb, MPI_Aint extent,
+ MPI_Datatype *newtype));
+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_Exscan,(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm));
+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_Exscan,(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op,
+ MPI_Comm comm));
MPI_CALL(XBT_PUBLIC(int), MPI_Comm_set_name, (MPI_Comm comm, char* name));
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, (MPI_Comm comm, MPI_Comm * newcomm));
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_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_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_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_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_complete,(MPI_Win win));
MPI_CALL(XBT_PUBLIC(int), MPI_Win_lock,(int lock_type, int rank, int assert, MPI_Win win));
XBT_PUBLIC(int) smpi_gettimeofday(struct timeval *tv, void* tz);
XBT_PUBLIC(unsigned long long) smpi_rastro_resolution (void);
XBT_PUBLIC(unsigned long long) smpi_rastro_timestamp (void);
-XBT_PUBLIC(void) smpi_sample_1(int global, const char *file, int line,
- int iters, double threshold);
+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);
#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_free(void *data);
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);
SG_END_DECL();
#include "xbt/ex.h"
SG_BEGIN_DECL()
-
/**
* @addtogroup XBT_error
* @brief Those are the SimGrid version of the good ol' assert macro.
*
- * You can pass them a format message and arguments, just as if it where a
- * printf.
+ * You can pass them a format message and arguments, just as if it where a printf.
* It is converted to a XBT_CRITICAL logging request.
- * Be careful: the boolean expression that you want to test should not have
- * side effects, because assertions are disabled at compile time if NDEBUG
- * is set.
+ * Be careful: the boolean expression that you want to test should not have side effects, because assertions are
+ * disabled at compile time if NDEBUG is set.
*
* @{
*/
#ifdef NDEBUG
#define xbt_assert(...) ((void)0)
#else
- /** @brief The condition which failed will be displayed.
+ /** @brief The condition which failed will be displayed.
@hideinitializer */
#define xbt_assert(...) \
_XBT_IF_ONE_ARG(_xbt_assert_ARG1, _xbt_assert_ARGN, __VA_ARGS__)(__VA_ARGS__)
#endif
/** @} */
- SG_END_DECL()
+SG_END_DECL()
#endif /* _XBT_ASSERTS_H */
typedef struct xbt_automaton_exp_label* xbt_automaton_exp_label_t;
-
typedef struct xbt_automaton_transition {
xbt_automaton_state_t src;
xbt_automaton_state_t dst;
typedef struct xbt_automaton_transition* xbt_automaton_transition_t;
-
typedef struct xbt_automaton_propositional_symbol s_xbt_automaton_propositional_symbol;
typedef struct xbt_automaton_propositional_symbol* xbt_automaton_propositional_symbol_t;
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_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_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_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(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(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()
-
#endif
/*
* Expands to `one' if there is only one argument for the variadic part.
* Otherwise, expands to `more'.
- * Works with up to 63 arguments, which is the maximum mandated by the C99
- * standard.
+ * Works with up to 63 arguments, which is the maximum mandated by the C99 standard.
*/
#define _XBT_IF_ONE_ARG(one, more, ...) \
_XBT_IF_ONE_ARG_(__VA_ARGS__, \
*
* Rational of XBT_PUBLIC:
* * This is for library symbols visible from the application-land.
- * Basically, any symbols defined in the include/directory must be
- * like this (plus some other globals).
+ * Basically, any symbols defined in the include/directory must be like this (plus some other globals).
*
* UNIX coders should just think of it as a special way to say "extern".
*
- * * If you build the DLL, define the DLL_EXPORT symbol so that all symbols
- * actually get exported by this file.
- *
- * * If you link your application against the DLL or if you do a UNIX build,
- * don't do anything special. This file will do the right thing for you
- * by default.
+ * * If you build the DLL, define the DLL_EXPORT symbol so that all symbols actually get exported by this file.
*
+ * * If you link your application against the DLL or if you do a UNIX build, don't do anything special. This file
+ * will do the right thing for you by default.
*
* Rational of XBT_EXPORT_NO_IMPORT: (windows-only)
* * Symbols which must be exported in the DLL, but not imported from it.
*
- * * This is obviously useful for initialized globals (which cannot be
- * extern or similar).
- * * This is also used in the log mechanism where a macro creates the
- * variable automatically. When the macro is called from within SimGrid,
- * the symbol must be exported, but when called from within the client
- * code, it must not try to retrieve the symbol from the DLL since it's
- * not in there.
+ * * This is obviously useful for initialized globals (which cannot be extern or similar).
+ * * This is also used in the log mechanism where a macro creates the variable automatically. When the macro is
+ * called from within SimGrid, the symbol must be exported, but when called from within the client code, it must
+ * not try to retrieve the symbol from the DLL since it's not in there.
*
* Rational of XBT_IMPORT_NO_EXPORT: (windows-only)
- * * Symbols which must be imported from the DLL, but not explicitly
- * exported from it.
+ * * Symbols which must be imported from the DLL, but not explicitly exported from it.
*
- * * The root log category is already exported, but not imported explicitly
- * when creating a subcategory since we cannot import the parent category
- * to deal with the fact that the parent may be in application space, not
- * DLL space.
+ * * The root log category is already exported, but not imported explicitly when creating a subcategory since we
+ * cannot import the parent category to deal with the fact that the parent may be in application space, not DLL
+ * space.
*/
/* Build the DLL */
* @brief Changing the configuration of SimGrid components (grounding feature)
*
* All modules of the SimGrid toolkit can be configured with this API.
- * User modules and libraries can also use these facilities to handle
- * their own configuration.
+ * User modules and libraries can also use these facilities to handle their own configuration.
*
- * A configuration set contain several \e variables which have a unique name
- * in the set and can take a given type of value. For example, it may
- * contain a \a size variable, accepting \e int values.
+ * A configuration set contain several \e variables which have a unique name in the set and can take a given type of
+ * value. For example, it may contain a \a size variable, accepting \e int values.
*
* It is impossible to set a value to a variable which has not been registered before.
- * Usually, the module registers all the options it accepts in the configuration set,
- * during its initialization and user code then set and unset values.
+ * Usually, the module registers all the options it accepts in the configuration set, during its initialization and
+ * user code then set and unset values.
*
- * The easiest way to register a variable is to use the xbt_str_register_str function,
- * which accepts a string representation of the config element descriptor. The syntax
- * is the following: \verbatim <name>:<min nb>_to_<max nb>_<type>\endverbatim
+ * The easiest way to register a variable is to use the xbt_str_register_str function, which accepts a string
+ * representation of the config element descriptor. The syntax is the following:
+ * \verbatim <name>:<min nb>_to_<max nb>_<type>\endverbatim
*
- * For example, <tt>size:1_to_1_int</tt> describes a variable called \e size which
- * must take exactly one value, and the value being an integer. Set the maximum to 0 to
- * disable the upper bound on data count.
+ * For example, <tt>size:1_to_1_int</tt> describes a variable called \e size which must take exactly one value, and
+ * the value being an integer. Set the maximum to 0 to disable the upper bound on data count.
*
- * Another example could be <tt>outputfiles:0_to_10_string</tt> which describes a variable
- * called \e outputfiles and which can take between 0 and 10 strings as value.
+ * Another example could be <tt>outputfiles:0_to_10_string</tt> which describes a variable called \e outputfiles and
+ * which can take between 0 and 10 strings as value.
*
* To some extend, configuration sets can be seen as typed hash structures.
*
- *
* \section XBT_cfg_ex Example of use
*
* \dontinclude config.c
* \skip dyn
* \until cfg_free
*
- * All those functions throws mismatch_error if asked to deal with an
- * unregistered variable.
+ * All those functions throws mismatch_error if asked to deal with an unregistered variable.
* \skip myset
* \until cfg_free
- *
*/
/** @defgroup XBT_cfg_use User interface: changing values
* @ingroup XBT_config
*
- * This is the only interface you should use unless you want to let your
- * own code become configurable with this.
+ * This is the only interface you should use unless you want to let your own code become configurable with this.
*
- * If the variable accept at most one value, those functions replace the
- * current value with the provided one. If max>1, the provided value is
- * appended to the list.
+ * If the variable accept at most one value, those functions replace the current value with the provided one. If max>1,
+ * the provided value is appended to the list.
*
- * string values are strdup'ed before use, so you can (and should) free
- * your copy
+ * string values are strdup'ed before use, so you can (and should) free your copy
*
* @{
*/
XBT_PUBLIC(void) xbt_cfg_set_vargs(xbt_cfg_t cfg, const char *name, va_list pa);
XBT_PUBLIC(void) xbt_cfg_set_parse(xbt_cfg_t cfg, const char *options);
-
-/*
- Set the value of the cell \a name in \a cfg with the provided value.
- */
+/* Set the value of the cell \a name in \a cfg with the provided value.*/
XBT_PUBLIC(void) xbt_cfg_set_int(xbt_cfg_t cfg, const char *name, int val);
XBT_PUBLIC(void) xbt_cfg_set_double(xbt_cfg_t cfg, const char *name, double val);
XBT_PUBLIC(void) xbt_cfg_set_string(xbt_cfg_t cfg, const char *name, const char *val);
/** @brief possible content of each configuration cell */
typedef enum {
- xbt_cfgelm_int = 0,
- /**< int */
- xbt_cfgelm_double,
- /**< double */
- xbt_cfgelm_string,
- /**< char* */
- xbt_cfgelm_boolean, /**< int */
+ xbt_cfgelm_int = 0, /**< int */
+ xbt_cfgelm_double, /**< double */
+ xbt_cfgelm_string, /**< char* */
+ xbt_cfgelm_boolean, /**< int */
xbt_cfgelm_alias, /**< redirection from a deprecated name to a better one */
//! @cond
xbt_cfgelm_any, /* not shown to users to prevent errors */
} e_xbt_cfgelm_type_t;
/** Boolean possible values **/
-
struct xbt_boolean_couple {
const char *true_val;
const char *false_val;
typedef void (*xbt_cfg_cb_t) (const char *, int);
XBT_PUBLIC(xbt_cfg_t) xbt_cfg_new(void);
-XBT_PUBLIC(void) xbt_cfg_cpy(xbt_cfg_t tocopy, /* OUT */
- xbt_cfg_t * whereto);
+XBT_PUBLIC(void) xbt_cfg_cpy(xbt_cfg_t tocopy, /* OUT */xbt_cfg_t * whereto);
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
*
- * This how to add new variables to an existing configuration set. Use it to make your code
- * configurable.
+ * This how to add new variables to an existing configuration set. Use it to make your code configurable.
*
* @{
*/
/** @defgroup XBT_cfg_get Getting the stored values
* @ingroup XBT_config
*
- * This is how to retrieve the values stored in the configuration set. This is only
- * intended to configurable code, naturally.
+ * This is how to retrieve the values stored in the configuration set. This is only intended to configurable code,
+ * naturally.
*
- * Note that those function return a pointer to the values actually stored
- * in the set. Do not modify them unless you really know what you're doing.
- * Likewise, do not free the strings after use, they are not copy of the data,
- * but the data themselves.
+ * Note that those function return a pointer to the values actually stored in the set. Do not modify them unless you
+ * really know what you're doing. Likewise, do not free the strings after use, they are not copy of the data, but the
+ * data themselves.
*
* @{
*/
typedef void (*ts_test_cb_t) (void);
/* test suite operations */
-XBT_PUBLIC(xbt_test_suite_t) xbt_test_suite_new(const char *name,
- const char *fmt, ...);
-XBT_PUBLIC(xbt_test_suite_t) xbt_test_suite_by_name(const char *name,
- const char *fmt, ...);
+XBT_PUBLIC(xbt_test_suite_t) xbt_test_suite_new(const char *name, 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_dump(xbt_test_suite_t suite);
-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(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.
/* Cleanup the mess */
XBT_PUBLIC(void) xbt_test_exit(void);
-
/**
* @addtogroup XBT_cunit
* @brief Unit testing implementation (see @ref inside_tests_add_units)
*
- * This module is mainly intended to allow the tests of SimGrid
- * itself and may lack the level of genericity that you would expect
- * as a user. Only use it in external projects at your own risk (but
- * it work rather well for us). We play with the idea of migrating
- * to an external solution for our unit tests, possibly offering
- * more features, but having absolutely no dependencies is a nice
- * feature of SimGrid (and this code is sufficient to cover our
- * needs, actually, so why should we bother switching?)
+ * This module is mainly intended to allow the tests of SimGrid itself and may lack the level of genericity that you
+ * would expect as a user. Only use it in external projects at your own risk (but it works rather well for us). We play
+ * with the idea of migrating to an external solution for our unit tests, possibly offering more features, but having
+ * absolutely no dependencies is a nice feature of SimGrid (and this code is sufficient to cover our needs, actually,
+ * so why should we bother switching?)
*
* Unit testing is not intended to write integration tests.
* Please refer to \ref inside_tests_add_integration for that instead.
- *
- *
*
* @{
*/
/** @brief Provide informations about the suite declared in this file
* @hideinitializer
*
- * Actually, this macro is only used by the script extracting the test
- * units, but that should be transparent for you.
+ * Actually, this macro is only used by the script extracting the test units, but that should be transparent for you.
*
- * @param suite_name the short name of this suite, to be used in the --tests argument of testall afterward. Avoid spaces and any other strange chars
+ * @param suite_name the short name of this suite, to be used in the --tests argument of testall afterward. Avoid
+ * spaces and any other strange chars
* @param suite_title instructive title that testall should display when your suite is run
*/
#define XBT_TEST_SUITE(suite_name,suite_title)
#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__)
* @hideinitializer
*
* - If provided a uniq parameter, this is assumed to be a condition that is expected to be true
- * - If provided more parameters, the first one is a condition, and the other ones are printf-like arguments that are to be displayed when the condition fails.
+ * - If provided more parameters, the first one is a condition, and the other ones are printf-like arguments that are
+ * to be displayed when the condition fails.
*/
#define xbt_test_assert(...) _XBT_IF_ONE_ARG(_xbt_test_assert_ARG1, \
_xbt_test_assert_ARGN, \
/** @addtogroup XBT_dict
* @brief The dictionary data structure (comparable to hash tables)
*
- * This section describes the API to a dictionary structure that
- * associates as string to a void* key. It provides the same
- * functionality than an hash table.
+ * This section describes the API to a dictionary structure that associates as string to a void* key. It provides the
+ * same functionality than an hash table.
*
* Here is a little example of use:
*/
/** \brief Dictionary data type (opaque structure) */
-
typedef struct s_xbt_dict *xbt_dict_t;
typedef struct s_xbt_dictelm *xbt_dictelm_t;
typedef struct s_xbt_dictelm {
* @{
*/
-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_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_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;
/** @defgroup XBT_dict_curs Cursors on dictionaries
* @ingroup XBT_dict
*
- * Don't get impressed, there is a lot of functions here, but traversing a
- * dictionary is immediate with the xbt_dict_foreach macro.
+ * Don't get impressed, there is a lot of functions here, but traversing a dictionary is immediate with the
+ * xbt_dict_foreach macro.
* You only need the other functions in rare cases (they are not used directly in SG itself).
*
- * Here is an example (assuming that the dictionary contains strings, ie
- * that the <tt>data</tt> argument of xbt_dict_set was always a null-terminated char*):
+ * Here is an example (assuming that the dictionary contains strings, i.e., that the <tt>data</tt> argument of
+ * xbt_dict_set was always a null-terminated char*):
\verbatim xbt_dict_cursor_t cursor=NULL;
char *key,*data;
*
* @{ */
- /** @brief Cursor on dictionaries (opaque type) */
+/** @brief Cursor on dictionaries (opaque type) */
typedef struct s_xbt_dict_cursor *xbt_dict_cursor_t;
static inline xbt_dictelm_t xbt_dict_cursor_get_elm(xbt_dict_cursor_t cursor) {
xbt_dictelm_t xbt_dict_cursor_get_elm(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_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_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_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(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
*
* These are the SimGrid version of the dynamically size arrays, which all C programmer recode one day or another.
*
- * For performance concerns, the content of DynArr must be homogeneous (in
- * contrary to dictionnaries -- see the \ref XBT_dict section). You thus
- * have to provide the function which will be used to free the content at
+ * For performance concerns, the content of DynArr must be homogeneous (in contrary to dictionnaries -- see the
+ * \ref XBT_dict section). You thus have to provide the function which will be used to free the content at
* structure creation (of type void_f_ppvoid_t or void_f_pvoid_t).
*
* \section XBT_dynar_exscal Example with scalar
* \skip end_of_doxygen
* \until }
*
- * Note that if you use dynars to store pointed data, the
- * xbt_dynar_search(), xbt_dynar_search_or_negative() and
- * xbt_dynar_member() won't be for you. Instead of comparing
- * your pointed elements, they compare the pointer to them. See
- * the documentation of xbt_dynar_search() for more info.
- *
+ * Note that if you use dynars to store pointed data, the xbt_dynar_search(), xbt_dynar_search_or_negative() and
+ * xbt_dynar_member() won't be for you. Instead of comparing your pointed elements, they compare the pointer to them.
+ * See the documentation of xbt_dynar_search() for more info.
*/
/** @defgroup XBT_dynar_cons Dynar constructor and destructor
* @ingroup XBT_dynar
/** \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(xbt_dynar_t) xbt_dynar_new(const unsigned long elm_size, 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_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_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(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(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(void) xbt_dynar_three_way_partition(xbt_dynar_t const dynar,
- int_f_pvoid_t color);
-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_three_way_partition(xbt_dynar_t const dynar, int_f_pvoid_t color);
+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(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_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_map(const xbt_dynar_t dynar, void_f_pvoid_t const op);
/** @} */
/** @defgroup XBT_dynar_ctn Direct manipulation to the dynars content
* @{
*/
-XBT_PUBLIC(void *) xbt_dynar_set_at_ptr(const xbt_dynar_t dynar,
- const unsigned long idx);
-XBT_PUBLIC(void *) xbt_dynar_get_ptr(const xbt_dynar_t dynar,
- const unsigned long idx);
-XBT_PUBLIC(void *) xbt_dynar_insert_at_ptr(xbt_dynar_t const dynar,
- const int idx);
+XBT_PUBLIC(void *) xbt_dynar_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
* @ingroup XBT_dynar
*
- * While the other functions use a memcpy to retrieve the content into the
- * user provided area, those ones use a regular affectation. It only works
- * for scalar values, but should be a little faster.
+ * While the other functions use a memcpy to retrieve the content into the user provided area, those ones use a
+ * regular affectation. It only works for scalar values, but should be a little faster.
*
* @{
*/
/** @defgroup XBT_dynar_cursor Cursors on dynar
* @ingroup XBT_dynar
*
- * Cursors are used to iterate over the structure. Never add elements to the
- * DynArr during the traversal. To remove elements, use the
- * xbt_dynar_cursor_rm() function.
+ * Cursors are used to iterate over the structure. Never add elements to the DynArr during the traversal. To remove
+ * elements, use the xbt_dynar_cursor_rm() function.
*
- * Do not call these function directly, but only within the xbt_dynar_foreach
- * macro.
+ * Do not call these function directly, but only within the xbt_dynar_foreach macro.
*
* @{
*/
-XBT_PUBLIC(void) xbt_dynar_cursor_rm(xbt_dynar_t dynar,
- unsigned int *const cursor);
+XBT_PUBLIC(void) xbt_dynar_cursor_rm(xbt_dynar_t dynar, unsigned int *const cursor);
/*
* \warning DO NOT USE THIS STRUCTURE DIRECTLY! Instead, use the public interface:
void_f_pvoid_t free_f;
} s_xbt_dynar_t;
-static XBT_INLINE int
-_xbt_dynar_cursor_get(const xbt_dynar_t dynar,
- unsigned int idx, void *const dst)
+static XBT_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;
}
// XBT_DEBUG("Cash out cursor on %p at %u", (void *) dynar, *idx);
- memcpy(dst, ((char *) dynar->data) + idx * dynar->elmsize,
- dynar->elmsize);
+ memcpy(dst, ((char *) dynar->data) + idx * dynar->elmsize, dynar->elmsize);
return TRUE;
}
-
-
/** @brief Iterates over the whole dynar.
*
* @param _dynar what to iterate over
}
\endcode
*
- * Note that underneath, that's a simple for loop with no real black
- * magic involved. It's perfectly safe to interrupt a foreach with a
- * break or a return statement.
+ * Note that underneath, that's a simple for loop with no real black magic involved. It's perfectly safe to interrupt
+ * a foreach with a break or a return statement.
*/
#define xbt_dynar_foreach(_dynar,_cursor,_data) \
for ( (_cursor) = 0 ; \
#define SIMGRId_XBT_DYNAR_HPP
#include <boost/range/iterator_range.hpp>
-
#include <xbt/asserts.h>
#include <xbt/dynar.h>
}
}
-
#endif
-/* str.h - XBT string related functions. */
-
/* Copyright (c) 2007-2015. The SimGrid Team.
* All rights reserved. */
XBT_PUBLIC(char *) xbt_dirname(const char *path);
XBT_PUBLIC(char *) xbt_basename(const char *path);
-
/**@}*/
SG_END_DECL()
/* @brief heap datatype */
typedef struct xbt_heap *xbt_heap_t;
-XBT_PUBLIC(xbt_heap_t) xbt_heap_new(int init_size,
- void_f_pvoid_t const free_func);
+XBT_PUBLIC(xbt_heap_t) xbt_heap_new(int init_size, void_f_pvoid_t const free_func);
XBT_PUBLIC(void) xbt_heap_free(xbt_heap_t H);
XBT_PUBLIC(int) xbt_heap_size(xbt_heap_t H);
XBT_PUBLIC(double) xbt_heap_maxkey(xbt_heap_t H);
XBT_PUBLIC(void *) xbt_heap_maxcontent(xbt_heap_t H);
-XBT_PUBLIC(void) xbt_heap_set_update_callback(xbt_heap_t H,
- void (*update_callback) (void
- *,
- int));
+XBT_PUBLIC(void) xbt_heap_set_update_callback(xbt_heap_t H, void (*update_callback) (void*, int));
XBT_PUBLIC(void *) xbt_heap_remove(xbt_heap_t H, int i);
XBT_PUBLIC(void ) xbt_heap_update(xbt_heap_t H, int i, double key);
*
* * the element itself is represented aby the xbt_dictelm_t;
*
- * * the element can store any number of associated facets/data structures
- * (corresponding to the different layers of SimGrid or its extensions)
- * in ((void**)dictelt->content)[level];
+ * * the element can store any number of associated facets/data structures (corresponding to the different layers of
+ * SimGrid or its extensions) in ((void**)dictelt->content)[level];
*
* * each level is allocated in the lib with `xbt_lib_add_level`.
*
XBT_PUBLIC(xbt_lib_t) xbt_lib_new(void);
XBT_PUBLIC(void) xbt_lib_free(xbt_lib_t * lib);
XBT_PUBLIC(int) xbt_lib_add_level(xbt_lib_t lib, void_f_pvoid_t free_f);
-XBT_PUBLIC(void) xbt_lib_set(xbt_lib_t lib, const char *name, int level,
- void *obj);
+XBT_PUBLIC(void) xbt_lib_set(xbt_lib_t lib, const char *name, int level, void *obj);
XBT_PUBLIC(void) xbt_lib_unset(xbt_lib_t lib, const char *key, int level, int invoke_callback);
-XBT_PUBLIC(void *) xbt_lib_get_or_null(xbt_lib_t lib, const char *name,
- int level);
+XBT_PUBLIC(void *) xbt_lib_get_or_null(xbt_lib_t lib, const char *name, int level);
XBT_PUBLIC(xbt_dictelm_t) xbt_lib_get_elm_or_null(xbt_lib_t lib, const char *key);
XBT_PUBLIC(void *) xbt_lib_get_level(xbt_dictelm_t elm, int level);
XBT_PUBLIC(void) xbt_lib_remove(xbt_lib_t lib, const char *key);
/** @addtogroup XBT_log
* @brief A generic logging facility in the spirit of log4j (grounding feature)
*
- *
*/
/** \defgroup XBT_log_cats Existing log categories
* \ingroup XBT_log
* \brief (automatically extracted)
- *
+ *
* This is the list of all existing log categories in SimGrid.
- * This list was automatically extracted from the source code by
- * the tools/doxygen/xbt_log_extract_hierarchy.pl utility.
- *
- * You can thus be certain that it is uptodate, but it may somehow
- * lack a final manual touch.
+ * This list is automatically extracted from the source code by the tools/doxygen/xbt_log_extract_hierarchy.pl utility.
+ *
+ * You can thus be certain that it is uptodate, but it may somehow lack a final manual touch.
* Anyway, nothing's perfect ;)
*/
//! @endcond
} e_xbt_log_priority_t;
-
/*
* define NLOG to disable at compilation time any logging request
* define NDEBUG to disable at compilation time any logging request of priority below VERBOSE
*/
-
/**
* @def XBT_LOG_STATIC_THRESHOLD
* @ingroup XBT_log
*
- * All logging requests with priority < XBT_LOG_STATIC_THRESHOLD are disabled at
- * compile time, i.e., compiled out.
+ * All logging requests with priority < XBT_LOG_STATIC_THRESHOLD are disabled at compile time, i.e., compiled out.
*/
#ifdef NLOG
# define XBT_LOG_STATIC_THRESHOLD xbt_log_priority_infinite
/* The root of the category hierarchy. */
#define XBT_LOG_ROOT_CAT root
-/* The whole tree of categories is connected by setting the address of the
- * parent category as a field of the child one. This is normally done at the
- * first use of the category.
+/* The whole tree of categories is connected by setting the address of the parent category as a field of the child one.
+ * This is normally done at the first use of the category.
*
- * It is however necessary to make this connections as early as possible, if we
- * want the category to be listed by --help-log-categories.
+ * It is however necessary to make this connections as early as possible, if we want the category to be listed by
+ * --help-log-categories.
*
- * When possible, the initializations takes place automatically before the start
- * of main(). It's the case when compiling with gcc.
+ * When possible, the initializations takes place automatically before the start of main(). It's the case when
+ * compiling with gcc.
*
- * For the other cases, you can use the XBT_LOG_CONNECT(cat) macro to force
- * early initialization. See, for example, in xbt/log.c, the function
- * xbt_log_connect_categories().
+ * For the other cases, you can use the XBT_LOG_CONNECT(cat) macro to force early initialization. See, for example,
+ * in xbt/log.c, the function xbt_log_connect_categories().
*/
#define XBT_LOG_CONNECT(cat) \
} else ((void)0)
/* XBT_LOG_NEW_SUBCATEGORY_helper:
- * Implementation of XBT_LOG_NEW_SUBCATEGORY, which must declare "extern parent" in addition
- * to avoid an extra declaration of root when XBT_LOG_NEW_SUBCATEGORY is called by
- * XBT_LOG_NEW_CATEGORY */
+ * Implementation of XBT_LOG_NEW_SUBCATEGORY, which must declare "extern parent" in addition to avoid an extra
+ * declaration of root when XBT_LOG_NEW_SUBCATEGORY is called by XBT_LOG_NEW_CATEGORY */
#define XBT_LOG_NEW_SUBCATEGORY_helper(catName, parent, desc) \
SG_BEGIN_DECL() \
extern void _XBT_LOGV_CTOR(catName)(void) _XBT_LOGV_CTOR_ATTRIBUTE; \
# define XBT_LOG_NEW_CATEGORY(catName,desc) \
XBT_LOG_NEW_SUBCATEGORY_helper(catName, XBT_LOG_ROOT_CAT, desc)
-
/**
* \ingroup XBT_log
* \param cname name of the cat
* \param desc string describing the purpose of this category
* \hideinitializer
*
- * Creates a new subcategory of the root category and makes it the default
- * (used by macros that don't explicitly specify a category).
+ * Creates a new subcategory of the root category and makes it the default (used by macros that don't explicitly
+ * specify a category).
*/
# define XBT_LOG_NEW_DEFAULT_CATEGORY(cname,desc) \
XBT_LOG_NEW_CATEGORY(cname,desc); \
* \param cname name of the cat
* \hideinitializer
*
- * Indicates that a category you'll use in this file (to get subcategories of it,
- * for example) really lives in another file.
+ * Indicates that a category you'll use in this file (e.g., to get subcategories of it) really lives in another file.
*/
#define XBT_LOG_EXTERNAL_CATEGORY(cname) \
XBT_PUBLIC(void) xbt_log_control_set(const char *cs);
/* Forward declarations */
-typedef struct xbt_log_appender_s s_xbt_log_appender_t,
- *xbt_log_appender_t;
+typedef struct xbt_log_appender_s s_xbt_log_appender_t, *xbt_log_appender_t;
typedef struct xbt_log_layout_s s_xbt_log_layout_t, *xbt_log_layout_t;
typedef struct xbt_log_event_s s_xbt_log_event_t, *xbt_log_event_t;
-typedef struct xbt_log_category_s s_xbt_log_category_t,
- *xbt_log_category_t;
+typedef struct xbt_log_category_s s_xbt_log_category_t, *xbt_log_category_t;
-/*
- * Do NOT access any members of this structure directly. FIXME: move to private?
- */
+/* Do NOT access any members of this structure directly. FIXME: move to private? */
struct xbt_log_category_s {
xbt_log_category_t parent;
*
* 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
* \param cat the category (not only its name, but the variable)
* \param app the appender
*
- * Programatically sets the category's appender.
- * (the prefered interface is throught xbt_log_control_set())
- *
+ * 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)
* \param lay the layout
*
- * Programatically sets the category's layout.
- * (the prefered interface is throught xbt_log_control_set())
- *
+ * 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
* \param cat the category (not only its name, but the variable)
* \param additivity whether logging actions must be passed to parent.
*
- * Programatically sets whether the logging actions must be passed to
- * the parent category.
- * (the prefered interface is throught xbt_log_control_set())
- *
+ * 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
*
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_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_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);
#else
-// If we `dllexport` the root log category, MinGW does not want us to
-// take its address with the error:
+// If we `dllexport` the root log category, MinGW does not want us to take its address with the error:
// > initializer element is not constant
// When using auto-import, MinGW is happy.
// We should handle this for non-root log categories as well.
* \hideinitializer
*
* Returns true if the given priority is enabled for the category.
- * If you have expensive expressions that are computed outside of the log
- * command and used only within it, you should make its evaluation conditional
- * using this macro.
+ * If you have expensive expressions that are computed outside of the log command and used only within it, you should
+ * make its evaluation conditional using this macro.
*/
#define XBT_LOG_ISENABLED(catName, priority) \
_XBT_LOG_ISENABLEDV(_XBT_LOGV(catName), priority)
* Internal Macros
* Some kludge macros to ease maintenance. See how they're used below.
*
- * IMPLEMENTATION NOTE: To reduce the parameter passing overhead of an enabled
- * message, the many parameters passed to the logging function are packed in a
- * structure. Since these values will be usually be passed to at least 3
- * functions, this is a win.
- * It also allows adding new values (such as a timestamp) without breaking
- * code.
+ * IMPLEMENTATION NOTE: To reduce the parameter passing overhead of an enabled message, the many parameters passed to
+ * the logging function are packed in a structure. Since these values will be usually be passed to at least 3 functions,
+ * this is a win.
+ * It also allows adding new values (such as a timestamp) without breaking code.
* Setting the LogEvent's valist member is done inside _log_logEvent.
*/
#define _XBT_MALLOCATOR_H
#include "xbt/function_types.h"
-#include "xbt/misc.h" /* SG_BEGIN_DECL */
-
+#include "xbt/misc.h"
SG_BEGIN_DECL()
/** @addtogroup XBT_mallocator
* @brief The mallocator system
*
* This section describes the API to a mallocator.
- * A mallocator allows you to recycle the objects you don't need anymore
- * instead of freeing them. A mallocator is a stack which stores the unused objects
- * or a given type. If you often need to malloc() / free() objects of a certain
- * type, you should use a mallocator and call \a xbt_mallocator_get() and
- * \a xbt_mallocator_release() instead of malloc() and free().
+ * A mallocator allows you to recycle the objects you don't need anymore instead of freeing them. A mallocator is a
+ * stack which stores the unused objects or a given type. If you often need to malloc() / free() objects of a certain
+ * type, you should use a mallocator and call \a xbt_mallocator_get() and \a xbt_mallocator_release() instead of
+ * malloc() and free().
*
- * When you release an object, it is not freed but it is stored
- * into the mallocator (unless the mallocator is full). And when you want to get a
- * new object, the object is just extracted from the mallocator. No malloc() is
- * done, unless there is no more object in the mallocator.
+ * When you release an object, it is not freed but it is stored into the mallocator (unless the mallocator is full).
+ * And when you want to get a new object, the object is just extracted from the mallocator. No malloc() is done,
+ * unless there is no more object in the mallocator.
*/
/** @defgroup XBT_mallocator_cons Mallocator constructor and destructor
* @ingroup XBT_mallocator
*/
/** \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,
+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(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_release(xbt_mallocator_t mallocator, void *object);
XBT_PUBLIC(void) xbt_mallocator_initialization_is_done(int protect);
/** @} */
* @hideinitializer */
#define xbt_matrix_get_as(mat,l,c,type) *(type*)xbt_matrix_get_ptr(mat,l,c)
-XBT_PUBLIC(xbt_matrix_t) xbt_matrix_new(int lines, int rows,
- const unsigned long elmsize,
- void_f_pvoid_t const free_f);
-XBT_PUBLIC(xbt_matrix_t) xbt_matrix_new_sub(xbt_matrix_t from,
- int lsize, int rsize,
- int lpos, int rpos,
+XBT_PUBLIC(xbt_matrix_t) xbt_matrix_new(int lines, int rows, const unsigned long elmsize, void_f_pvoid_t const free_f);
+XBT_PUBLIC(xbt_matrix_t) xbt_matrix_new_sub(xbt_matrix_t from, int lsize, int rsize, int lpos, int rpos,
pvoid_f_pvoid_t const cpy_f);
XBT_PUBLIC(void) xbt_matrix_free(xbt_matrix_t matrix);
XBT_PUBLIC(void) xbt_matrix_free_voidp(void *d);
-XBT_PUBLIC(void) xbt_matrix_copy_values(xbt_matrix_t dest,
- xbt_matrix_t src,
- unsigned int lsize,
- unsigned int rsize,
- unsigned int lpos_dst,
- unsigned int rpos_dst,
- unsigned int lpos_src,
- unsigned int rpos_src,
- pvoid_f_pvoid_t const cpy_f);
+XBT_PUBLIC(void) xbt_matrix_copy_values(xbt_matrix_t dest, xbt_matrix_t src, unsigned int lsize, unsigned int rsize,
+ unsigned int lpos_dst, unsigned int rpos_dst, unsigned int lpos_src,
+ unsigned int rpos_src, pvoid_f_pvoid_t const cpy_f);
-XBT_PUBLIC(void) xbt_matrix_dump(xbt_matrix_t matrix, const char *name,
- int coords, void_f_pvoid_t display_fun);
+XBT_PUBLIC(void) xbt_matrix_dump(xbt_matrix_t matrix, const char *name, int coords, void_f_pvoid_t display_fun);
XBT_PUBLIC(void) xbt_matrix_dump_display_double(void *d);
-
XBT_PUBLIC(xbt_matrix_t) xbt_matrix_double_new_zeros(int lines, int rows);
XBT_PUBLIC(xbt_matrix_t) xbt_matrix_double_new_id(int lines, int rows);
XBT_PUBLIC(xbt_matrix_t) xbt_matrix_double_new_seq(int lines, int rows);
-XBT_PUBLIC(void) xbt_matrix_double_addmult(xbt_matrix_t A, xbt_matrix_t B,
- /*OUT*/ xbt_matrix_t C);
+XBT_PUBLIC(void) xbt_matrix_double_addmult(xbt_matrix_t A, xbt_matrix_t B, /*OUT*/ xbt_matrix_t C);
SG_END_DECL()
#endif /* XBT_MATRIX_H */
SIMGRID_VERSION_MAJOR and friends give the version numbers of the used header files */
XBT_PUBLIC(void) sg_version(int *major,int *minor,int *patch);
-/** Helps ensuring that the header version (SIMGRID_VERSION_MAJOR and friends) and the dynamic library version do match. */
+/** 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);
/** Contains all the parameters we got from the command line */
SG_BEGIN_DECL()
-/* Datatype representing a separate heap. The whole point of the mmalloc module
- * is to allow several such heaps in the process. It thus works by redefining
- * all the classical memory management functions (malloc and friends) with an
+/* Datatype representing a separate heap. The whole point of the mmalloc module is to allow several such heaps in the
+ * process. It thus works by redefining all the classical memory management functions (malloc and friends) with an
* extra first argument: the heap in which the memory is to be taken.
*
* The heap structure itself is an opaque object that shouldnt be messed with.
/* 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. */
-
+/* 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);
/* Free a block allocated by `mmalloc', `mrealloc' or `mcalloc'. */
int mmalloc_compare_heap(mc_snapshot_t snapshot1, mc_snapshot_t snapshot2);
int mmalloc_linear_compare_heap(xbt_mheap_t heap1, xbt_mheap_t heap2);
int init_heap_information(xbt_mheap_t heap1, xbt_mheap_t heap2, xbt_dynar_t to_ignore1, xbt_dynar_t to_ignore2);
-int compare_heap_area(int process_index, const void *area1, const void* area2, mc_snapshot_t snapshot1, mc_snapshot_t snapshot2, xbt_dynar_t previous, mc_type_t type, int pointer_level);
+int compare_heap_area(int process_index, const void *area1, const void* area2, mc_snapshot_t snapshot1,
+ mc_snapshot_t snapshot2, xbt_dynar_t previous, mc_type_t type, int pointer_level);
void reset_heap_information(void);
size_t mmalloc_get_bytes_used(xbt_mheap_t);
* \ingroup XBT_misc
* \brief Parallel map.
*
- * A function is applied to all elements of a dynar in parallel with n worker
- * threads.
+ * A function is applied to all elements of a dynar in parallel with n worker threads.
* The worker threads are persistent until the destruction of the parmap.
*
- * If there are more than n elements in the dynar, the worker threads are
- * allowed to fetch themselves remaining work with xbt_parmap_next() and
- * execute it.
+ * If there are more than n elements in the dynar, the worker threads are allowed to fetch themselves remaining work
+ * with xbt_parmap_next() and execute it.
*
* \{
*/
/** \brief Parallel map data type (opaque type) */
typedef struct s_xbt_parmap *xbt_parmap_t;
-/**
- * \brief Synchronization mode of the worker threads of a parmap.
- */
+/** \brief Synchronization mode of the worker threads of a parmap. */
typedef enum {
XBT_PARMAP_POSIX, /**< use POSIX synchronization primitives */
XBT_PARMAP_FUTEX, /**< use Linux futex system call */
XBT_PARMAP_DEFAULT /**< futex if available, posix otherwise */
} e_xbt_parmap_mode_t;
-XBT_PUBLIC(xbt_parmap_t) xbt_parmap_new(unsigned int num_workers,
- e_xbt_parmap_mode_t mode);
+XBT_PUBLIC(xbt_parmap_t) xbt_parmap_new(unsigned int num_workers, e_xbt_parmap_mode_t mode);
XBT_PUBLIC(void) xbt_parmap_destroy(xbt_parmap_t parmap);
-
-XBT_PUBLIC(void) xbt_parmap_apply(xbt_parmap_t parmap,
- void_f_pvoid_t fun,
- xbt_dynar_t data);
+XBT_PUBLIC(void) xbt_parmap_apply(xbt_parmap_t parmap, void_f_pvoid_t fun, xbt_dynar_t data);
XBT_PUBLIC(void*) xbt_parmap_next(xbt_parmap_t parmap);
#ifdef HAVE_MC
-XBT_PUBLIC(xbt_parmap_t) xbt_parmap_mc_new(unsigned int num_workers,
- e_xbt_parmap_mode_t mode);
+XBT_PUBLIC(xbt_parmap_t) xbt_parmap_mc_new(unsigned int num_workers, e_xbt_parmap_mode_t mode);
-XBT_PUBLIC(int) xbt_parmap_mc_apply(xbt_parmap_t parmap,
- int_f_pvoid_pvoid_t fun,
- void *data,
- unsigned int length,
+XBT_PUBLIC(int) xbt_parmap_mc_apply(xbt_parmap_t parmap, int_f_pvoid_pvoid_t fun, void *data, unsigned int length,
void* ref_snapshot);
#endif
/** \} */
SG_END_DECL()
-
#endif
XBT_PUBLIC(const char **) xbt_replay_reader_get(xbt_replay_reader_t reader);
XBT_PUBLIC(void) xbt_replay_reader_free(xbt_replay_reader_t *reader);
+XBT_PUBLIC(void) xbt_replay_action_register(const char *action_name, action_fun function);
XBT_PUBLIC(int) xbt_replay_action_runner(int argc, char *argv[]);
XBT_PUBLIC(int) _xbt_replay_is_active(void);
-
XBT_PUBLIC(int) _xbt_replay_action_init(void);
XBT_PUBLIC(void) _xbt_replay_action_exit(void);
-XBT_PUBLIC(void) xbt_replay_action_register(const char *action_name, action_fun function);
-
SG_END_DECL()
#endif /* XBT_REPLAY_H */
/** @addtogroup XBT_str
* @brief String manipulation functions
*
- * This module defines several string related functions. Looking at the diversity of string
- * manipulation functions that are provided, you can see that several SimGrid core developers
- * actually like Perl.
+ * This module defines several string related functions. Looking at the diversity of string manipulation functions that
+ * are provided, you can see that several SimGrid core developers actually like Perl.
* @{
*/
SG_BEGIN_DECL()
-/**
- ** Buffer code
- **/
+/** Buffer code **/
typedef struct {
char *data;
int used, size;
} s_xbt_strbuff_t, *xbt_strbuff_t;
-
XBT_PUBLIC(void) xbt_strbuff_empty(xbt_strbuff_t b);
XBT_PUBLIC(xbt_strbuff_t) xbt_strbuff_new(void);
XBT_PUBLIC(xbt_strbuff_t) xbt_strbuff_new_from(const char *s);
XBT_PUBLIC(void) xbt_strbuff_append(xbt_strbuff_t b, const char *toadd);
XBT_PUBLIC(void) xbt_strbuff_chomp(xbt_strbuff_t b);
XBT_PUBLIC(void) xbt_strbuff_trim(xbt_strbuff_t b);
-XBT_PUBLIC(void) xbt_strbuff_varsubst(xbt_strbuff_t b,
- xbt_dict_t patterns);
+XBT_PUBLIC(void) xbt_strbuff_varsubst(xbt_strbuff_t b, xbt_dict_t patterns);
SG_END_DECL()
#endif
/* 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. */
-/* Warning, this module is done to be efficient and performs tons of
- cast and dirty things. So avoid using it unless you really know
- what you are doing. */
+/* Warning, this module is done to be efficient and performs tons of cast and dirty things. So avoid using it unless
+ * you really know what you are doing. */
#ifndef _XBT_SWAG_H
#define _XBT_SWAG_H
* @addtogroup XBT_swag
* @brief a O(1) set based on linked lists
*
- * Warning, this module is done to be efficient and performs tons of
- * cast and dirty things. So make sure you know what you are doing while using it.
- * It is basically a fifo but with restrictions so that
- * it can be used as a set. Any operation (add, remove, belongs) is O(1) and
- * no call to malloc/free is done.
+ * Warning, this module is done to be efficient and performs tons of cast and dirty things. So make sure you know what
+ * you are doing while using it.
+ * It is basically a fifo but with restrictions so that it can be used as a set. Any operation (add, remove, belongs)
+ * is O(1) and no call to malloc/free is done.
*
*/
/** @defgroup XBT_swag_type Swag types
Specific set.
-
- These typedefs are public so that the compiler can
- do his job but believe me, you don't want to try to play with
+ These typedefs are public so that the compiler can do his job but believe me, you don't want to try to play with
those structs directly. Use them as an abstract datatype.
*/
/* @{ */
} s_xbt_swag_hookup_t;
/**< This type should be added to a type that is to be used in a swag.
*
- * Whenever a new object with this struct is created, all fields have
- * to be set to NULL
+ * Whenever a new object with this struct is created, all fields have to be set to NULL
*
* Here is an example like that :
*/
typedef s_xbt_swag_hookup_t *xbt_swag_hookup_t;
-
typedef struct xbt_swag {
void *head;
void *tail;
return (swag->head);
}
-
/**
* \brief Offset computation
* \arg var a variable of type <tt>struct</tt> something
* \return the offset of \a field in <tt>struct</tt> something.
* @hideinitializer
*
- * It is very similar to offsetof except that is done at runtime and that
- * you have to declare a variable. Why defining such a macro then ?
- * Because it is portable...
+ * It is very similar to offsetof except that is done at runtime and that you have to declare a variable. Why defining
+ * such a macro then ? Because it is portable...
*/
#define xbt_swag_offset(var,field) ((char *)&( (var).field ) - (char *)&(var))
/* @} */
* @hideinitializer
You can safely modify the \a swag while using this loop.
- Well, safely... Err. You can remove \a obj without having any
- trouble at least. */
+ Well, safely... Err. You can remove \a obj without having any trouble at least. */
#ifndef __cplusplus
/** @brief Blocks onto the given condition variable */
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. a timeout exception is raised if it was impossible to acquire it in the given time frame */
-XBT_PUBLIC(void) xbt_cond_timedwait(xbt_cond_t cond,
- xbt_mutex_t mutex, double delay);
+/** @brief Blocks onto the given condition variable, but only for the given amount of time. a timeout exception is
+ * raised if it was impossible to acquire it in the given time frame */
+XBT_PUBLIC(void) 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);
/** @brief Broadcasts the given mutex variable */
/** @brief Destroys the given mutex variable */
XBT_PUBLIC(void) xbt_cond_destroy(xbt_cond_t cond);
-
#define XBT_BARRIER_SERIAL_PROCESS -1
typedef struct s_xbt_bar_ *xbt_bar_t;
XBT_PUBLIC(xbt_bar_t) xbt_barrier_init( unsigned int count);
* @brief Kill the program with an error message
* \param ... a format string and its arguments
*
- * Things are so messed up that the only thing to do now, is to stop the
- * program.
+ * Things are so messed up that the only thing to do now, is to stop the program.
*
- * The message is handled by a CRITICAL logging request, and may consist of a
- * format string with arguments.
+ * The message is handled by a CRITICAL logging request, and may consist of a format string with arguments.
*/
#define xbt_die(...) \
do { \
/** @addtogroup XBT_thread
* @brief Thread portability layer
*
- * This section describes the thread portability layer. It defines types and
- * functions very close to the pthread API, but it's portable to windows too.
+ * This section describes the thread portability layer. It defines types and functions very close to the pthread API,
+ * but it's portable to windows too.
*
* @{
*/
/** \brief Thread data type (opaque structure) */
typedef struct xbt_os_thread_ *xbt_os_thread_t;
-
#ifdef _XBT_WIN32 /* defined if this is a windows system, 32bits or 64bits) */
#include <windows.h>
typedef DWORD xbt_os_thread_key_t;
* when used with tesh, mmalloc *must* be mutex protected and resistant to forks.
* This functionality is the only way to get it working (by ensuring that the mutex is consistently released on forks)
*/
-XBT_PUBLIC(int) xbt_os_thread_atfork(void (*prepare)(void),
- void (*parent)(void),
- void (*child)(void));
+XBT_PUBLIC(int) xbt_os_thread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void));
XBT_PUBLIC(int) xbt_os_get_numcores(void);
-XBT_PUBLIC(xbt_os_thread_t) xbt_os_thread_create(const char *name,
- pvoid_f_pvoid_t start_routine,
- void *param,
+XBT_PUBLIC(xbt_os_thread_t) xbt_os_thread_create(const char *name, pvoid_f_pvoid_t start_routine, void *param,
void *data);
//#define CORE_BINDING //Uncomment this to enable binding of threads to physical cores. Only Linux.
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_join(xbt_os_thread_t thread, void **thread_return);
XBT_PUBLIC(void) xbt_os_thread_yield(void);
XBT_PUBLIC(void) xbt_os_thread_cancel(xbt_os_thread_t thread);
XBT_PUBLIC(void *) xbt_os_thread_getparam(void);
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_timedacquire(xbt_os_mutex_t mutex,
- double delay);
+XBT_PUBLIC(void) xbt_os_mutex_timedacquire(xbt_os_mutex_t mutex, double delay);
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(void) xbt_os_rmutex_release(xbt_os_rmutex_t rmutex);
XBT_PUBLIC(void) xbt_os_rmutex_destroy(xbt_os_rmutex_t rmutex);
-
- /** \brief Thread condition data type (opaque structure) */
+/** \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_timedwait(xbt_os_cond_t cond,
- xbt_os_mutex_t mutex, double delay);
+XBT_PUBLIC(void) xbt_os_cond_wait(xbt_os_cond_t cond, xbt_os_mutex_t mutex);
+XBT_PUBLIC(void) xbt_os_cond_timedwait(xbt_os_cond_t cond, xbt_os_mutex_t mutex, double delay);
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) */
+/** \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_destroy(xbt_os_sem_t sem);
XBT_PUBLIC(void) xbt_os_sem_get_value(xbt_os_sem_t sem, int *svalue);
-
/** @} */
SG_END_DECL()
