From: degomme Date: Sun, 29 May 2016 13:50:55 +0000 (+0200) Subject: some more files for sonar X-Git-Tag: v3_14~1124 X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/commitdiff_plain/de5e36cc7e45014c43cf9290b5ac8380072d69ad some more files for sonar --- diff --git a/examples/smpi/replay/replay.tesh b/examples/smpi/replay/replay.tesh index d2ffb964f6..2ef38c6a71 100644 --- a/examples/smpi/replay/replay.tesh +++ b/examples/smpi/replay/replay.tesh @@ -231,8 +231,8 @@ $ ../../smpi_script/bin/smpirun -ext smpi_replay --log=replay.thresh:critical -- > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/model' to 'SMPI' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/TCP-gamma' to '4194304' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'smpi/cpu-threshold' to '-1' -> [Tremblay:0:(1) 0.164463] [smpi_replay/VERBOSE] 0 send 1 1e6 0.164463 > [Jupiter:1:(2) 0.164463] [smpi_replay/VERBOSE] 1 recv 0 1e6 0.164463 +> [Tremblay:0:(1) 0.164463] [smpi_replay/VERBOSE] 0 send 1 1e6 0.164463 > [Jupiter:1:(2) 13.271310] [smpi_replay/VERBOSE] 1 compute 1e9 13.106847 > [Jupiter:1:(2) 13.271310] [smpi_replay/VERBOSE] 1 Isend 0 1e6 0.000000 > [Jupiter:1:(2) 13.271310] [smpi_replay/VERBOSE] 1 Irecv 0 1e6 0.000000 @@ -253,8 +253,8 @@ $ ../../smpi_script/bin/smpirun -ext smpi_replay --log=replay.thresh:critical -- > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/model' to 'SMPI' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/TCP-gamma' to '4194304' > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'smpi/cpu-threshold' to '-1' -> [Tremblay:0:(1) 1.491472] [smpi_replay/VERBOSE] 0 send 1 1e7 1.491472 > [Jupiter:1:(2) 1.491472] [smpi_replay/VERBOSE] 1 recv 0 1e7 1.491472 +> [Tremblay:0:(1) 1.491472] [smpi_replay/VERBOSE] 0 send 1 1e7 1.491472 > [Tremblay:0:(1) 1.493448] [smpi_replay/VERBOSE] 0 barrier 0.001976 > [Jupiter:1:(2) 1.494910] [smpi_replay/VERBOSE] 1 barrier 0.003438 > [Fafard:2:(3) 1.495424] [smpi_replay/VERBOSE] 2 barrier 1.495424 diff --git a/examples/smpi/replay_multiple/replay_multiple.tesh b/examples/smpi/replay_multiple/replay_multiple.tesh index ee4943e8c5..568cdd6971 100644 --- a/examples/smpi/replay_multiple/replay_multiple.tesh +++ b/examples/smpi/replay_multiple/replay_multiple.tesh @@ -8,8 +8,9 @@ $ ./replay_multiple description_file ${srcdir:=.}/../../platforms/small_platform > [0.000000] [msg_test/INFO] Initializing instance 1 of size 32 > [0.000000] [msg_test/INFO] Initializing instance 2 of size 32 > [0.000000] [smpi_kernel/INFO] You did not set the power of the host running the simulation. The timings will certainly not be accurate. Use the option "--cfg=smpi/running-power:" to set its value.Check http://simgrid.org/simgrid/latest/doc/options.html#options_smpi_bench for more information. -> [Jupiter:2:(52) 1140688.626959] [smpi_replay/INFO] Simulation time 1124371.274298 -> [1140688.626959] [msg_test/INFO] Simulation time 1.14069e+06 +> [Jupiter:2:(52) 1140688.585057] [smpi_replay/INFO] Simulation time 1124371.232395 +> [1140688.585057] [msg_test/INFO] Simulation time 1.14069e+06 + diff --git a/src/smpi/instr_smpi.cpp b/src/smpi/instr_smpi.cpp index e69f0ded3a..36ee8d52aa 100644 --- a/src/smpi/instr_smpi.cpp +++ b/src/smpi/instr_smpi.cpp @@ -75,7 +75,7 @@ static const char *instr_find_color (const char *state) const char *current = smpi_colors[i]; while ((current != NULL)){ if (strcmp (state, current) == 0 //exact match - || strstr(target, current) ){//as substring + || strstr(target, current) != 0 ){//as substring ret = smpi_colors[i+1]; break; } @@ -156,7 +156,8 @@ static void cleanup_extra_data (instr_extra_data extra){ void TRACE_internal_smpi_set_category (const char *category) { - if (!TRACE_smpi_is_enabled()) return; + if (!TRACE_smpi_is_enabled()) + return; //declare category TRACE_category (category); @@ -171,7 +172,8 @@ void TRACE_internal_smpi_set_category (const char *category) const char *TRACE_internal_smpi_get_category (void) { - if (!TRACE_smpi_is_enabled()) return NULL; + if (!TRACE_smpi_is_enabled()) + return NULL; char processid[INSTR_DEFAULT_STR_SIZE]; snprintf (processid, INSTR_DEFAULT_STR_SIZE, "%p", SIMIX_process_self()); @@ -192,7 +194,8 @@ void TRACE_smpi_release(void) void TRACE_smpi_init(int rank) { - if (!TRACE_smpi_is_enabled()) return; + if (!TRACE_smpi_is_enabled()) + return; char str[INSTR_DEFAULT_STR_SIZE]; smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE); @@ -210,7 +213,8 @@ void TRACE_smpi_init(int rank) void TRACE_smpi_finalize(int rank) { - if (!TRACE_smpi_is_enabled()) return; + if (!TRACE_smpi_is_enabled()) + return; char str[INSTR_DEFAULT_STR_SIZE]; container_t container = PJ_container_get(smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE)); @@ -231,12 +235,13 @@ void TRACE_smpi_collective_in(int rank, int root, const char *operation, instr_e type_t type = PJ_type_get ("MPI_STATE", container->type); const char *color = instr_find_color (operation); val_t value = PJ_value_get_or_new (operation, color, type); - new_pajePushStateWithExtra (SIMIX_get_clock(), container, type, value, (void*)extra); + new_pajePushStateWithExtra (SIMIX_get_clock(), container, type, value, static_cast(extra)); } void TRACE_smpi_collective_out(int rank, int root, const char *operation) { - if (!TRACE_smpi_is_enabled()) return; + if (!TRACE_smpi_is_enabled()) + return; char str[INSTR_DEFAULT_STR_SIZE]; smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE); @@ -249,9 +254,8 @@ void TRACE_smpi_collective_out(int rank, int root, const char *operation) void TRACE_smpi_computing_init(int rank) { //first use, initialize the color in the trace - //TODO : check with lucas and Pierre how to generalize this approach - //to avoid unnecessary access to the color array - if (!TRACE_smpi_is_enabled() || !TRACE_smpi_is_computing()) return; + if (!TRACE_smpi_is_enabled() || !TRACE_smpi_is_computing()) + return; char str[INSTR_DEFAULT_STR_SIZE]; smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE); @@ -275,12 +279,13 @@ void TRACE_smpi_computing_in(int rank, instr_extra_data extra) container_t container = PJ_container_get (str); type_t type = PJ_type_get ("MPI_STATE", container->type); val_t value = PJ_value_get_or_new ("computing", NULL, type); - new_pajePushStateWithExtra (SIMIX_get_clock(), container, type, value, (void*)extra); + new_pajePushStateWithExtra (SIMIX_get_clock(), container, type, value, static_cast(extra)); } void TRACE_smpi_computing_out(int rank) { - if (!TRACE_smpi_is_enabled()|| !TRACE_smpi_is_computing()) return; + if (!TRACE_smpi_is_enabled()|| !TRACE_smpi_is_computing()) + return; char str[INSTR_DEFAULT_STR_SIZE]; smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE); container_t container = PJ_container_get (str); @@ -290,10 +295,9 @@ void TRACE_smpi_computing_out(int rank) void TRACE_smpi_sleeping_init(int rank) { - //first use, initialize the color in the trace - //TODO : check with lucas and Pierre how to generalize this approach - //to avoid unnecessary access to the color array - if (!TRACE_smpi_is_enabled() || !TRACE_smpi_is_sleeping()) return; + //first use, initialize the color in the trace + if (!TRACE_smpi_is_enabled() || !TRACE_smpi_is_sleeping()) + return; char str[INSTR_DEFAULT_STR_SIZE]; smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE); @@ -317,12 +321,13 @@ void TRACE_smpi_sleeping_in(int rank, instr_extra_data extra) container_t container = PJ_container_get (str); type_t type = PJ_type_get ("MPI_STATE", container->type); val_t value = PJ_value_get_or_new ("sleeping", NULL, type); - new_pajePushStateWithExtra (SIMIX_get_clock(), container, type, value, (void*)extra); + new_pajePushStateWithExtra (SIMIX_get_clock(), container, type, value, static_cast(extra)); } void TRACE_smpi_sleeping_out(int rank) { - if (!TRACE_smpi_is_enabled()|| !TRACE_smpi_is_sleeping()) return; + if (!TRACE_smpi_is_enabled()|| !TRACE_smpi_is_sleeping()) + return; char str[INSTR_DEFAULT_STR_SIZE]; smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE); container_t container = PJ_container_get (str); @@ -343,12 +348,13 @@ void TRACE_smpi_testing_in(int rank, instr_extra_data extra) container_t container = PJ_container_get (str); type_t type = PJ_type_get ("MPI_STATE", container->type); val_t value = PJ_value_get_or_new ("test", NULL, type); - new_pajePushStateWithExtra (SIMIX_get_clock(), container, type, value, (void*)extra); + new_pajePushStateWithExtra (SIMIX_get_clock(), container, type, value, static_cast(extra)); } void TRACE_smpi_testing_out(int rank) { - if (!TRACE_smpi_is_enabled()) return; + if (!TRACE_smpi_is_enabled()) + return; char str[INSTR_DEFAULT_STR_SIZE]; smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE); container_t container = PJ_container_get (str); @@ -369,12 +375,13 @@ void TRACE_smpi_ptp_in(int rank, int src, int dst, const char *operation, instr_ type_t type = PJ_type_get ("MPI_STATE", container->type); const char *color = instr_find_color (operation); val_t value = PJ_value_get_or_new (operation, color, type); - new_pajePushStateWithExtra (SIMIX_get_clock(), container, type, value, (void*)extra); + new_pajePushStateWithExtra (SIMIX_get_clock(), container, type, value, static_cast(extra)); } void TRACE_smpi_ptp_out(int rank, int src, int dst, const char *operation) { - if (!TRACE_smpi_is_enabled()) return; + if (!TRACE_smpi_is_enabled()) + return; char str[INSTR_DEFAULT_STR_SIZE]; smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE); @@ -386,7 +393,8 @@ void TRACE_smpi_ptp_out(int rank, int src, int dst, const char *operation) void TRACE_smpi_send(int rank, int src, int dst, int size) { - if (!TRACE_smpi_is_enabled()) return; + if (!TRACE_smpi_is_enabled()) + return; char key[INSTR_DEFAULT_STR_SIZE] = {0}; TRACE_smpi_put_key(src, dst, key, INSTR_DEFAULT_STR_SIZE); @@ -401,7 +409,8 @@ void TRACE_smpi_send(int rank, int src, int dst, int size) void TRACE_smpi_recv(int rank, int src, int dst) { - if (!TRACE_smpi_is_enabled()) return; + if (!TRACE_smpi_is_enabled()) + return; char key[INSTR_DEFAULT_STR_SIZE] = {0}; TRACE_smpi_get_key(src, dst, key, INSTR_DEFAULT_STR_SIZE); diff --git a/src/smpi/private.h b/src/smpi/private.h index fd70eba61a..323252218a 100644 --- a/src/smpi/private.h +++ b/src/smpi/private.h @@ -194,7 +194,7 @@ XBT_PRIVATE void smpi_global_init(void); XBT_PRIVATE void smpi_global_destroy(void); XBT_PRIVATE double smpi_mpi_wtime(void); -XBT_PRIVATE int is_datatype_valid(MPI_Datatype datatype); +XBT_PRIVATE bool is_datatype_valid(MPI_Datatype datatype); XBT_PRIVATE size_t smpi_datatype_size(MPI_Datatype datatype); XBT_PRIVATE MPI_Aint smpi_datatype_lb(MPI_Datatype datatype); @@ -237,7 +237,7 @@ XBT_PRIVATE void smpi_empty_status(MPI_Status * status); XBT_PRIVATE MPI_Op smpi_op_new(MPI_User_function * function, int commute); XBT_PRIVATE int smpi_op_is_commute(MPI_Op op); XBT_PRIVATE void smpi_op_destroy(MPI_Op op); -XBT_PRIVATE void smpi_op_apply(MPI_Op op, void *invec, void *inoutvec, int *len, MPI_Datatype * datatype); +XBT_PRIVATE void smpi_op_apply(MPI_Op op, const void *invec, void *inoutvec, int *len, MPI_Datatype * datatype); XBT_PRIVATE MPI_Group smpi_group_new(int size); XBT_PRIVATE MPI_Group smpi_group_copy(MPI_Group origin); diff --git a/src/smpi/smpi_base.cpp b/src/smpi/smpi_base.cpp index 9ad417780f..f2f102b0f4 100644 --- a/src/smpi/smpi_base.cpp +++ b/src/smpi/smpi_base.cpp @@ -420,7 +420,7 @@ void smpi_mpi_start(MPI_Request request) sleeptime = ((request->flags & ISEND) != 0)? smpi_ois(request->size) : smpi_os(request->size); } - if(sleeptime != 0.0){ + if(sleeptime >= 0.0){ simcall_process_sleep(sleeptime); XBT_DEBUG("sending size of %zu : sleep %f ", request->size, smpi_os(request->size)); } diff --git a/src/smpi/smpi_bench.cpp b/src/smpi/smpi_bench.cpp index de5c96e275..b321e241ec 100644 --- a/src/smpi/smpi_bench.cpp +++ b/src/smpi/smpi_bench.cpp @@ -155,7 +155,7 @@ static size_t shm_size(int fd) { if(fstat(fd, &st) < 0) { xbt_die("Could not stat fd %d: %s", fd, strerror(errno)); } - return (size_t)st.st_size; + return static_cast(st.st_size); } #ifndef WIN32 @@ -164,10 +164,8 @@ static void* shm_map(int fd, size_t size, shared_data_key_type* data) { char loc[PTR_STRLEN]; shared_metadata_t meta; - if(size > shm_size(fd)) { - if(ftruncate(fd, (off_t)size) < 0) { + if(size > shm_size(fd) && (ftruncate(fd, static_cast(size)) < 0)) { xbt_die("Could not truncate fd %d to %zu: %s", fd, size, strerror(errno)); - } } mem = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); @@ -255,7 +253,6 @@ void smpi_bench_end(void) double speedup = 1; xbt_os_timer_t timer = smpi_process_timer(); xbt_os_threadtimer_stop(timer); -// smpi_switch_data_segment(smpi_process_count()); if (smpi_process_get_sampling()) { XBT_CRITICAL("Cannot do recursive benchmarks."); XBT_CRITICAL("Are you trying to make a call to MPI within a SMPI_SAMPLE_ block?"); @@ -304,12 +301,12 @@ static unsigned int private_sleep(double secs) unsigned int smpi_sleep(unsigned int secs) { - return private_sleep((double)secs); + return private_sleep(static_cast(secs)); } int smpi_usleep(useconds_t usecs) { - return (int)private_sleep((double)usecs / 1000000.0); + return static_cast(private_sleep(static_cast(usecs) / 1000000.0)); } int smpi_gettimeofday(struct timeval *tv, void* tz) @@ -318,11 +315,11 @@ int smpi_gettimeofday(struct timeval *tv, void* tz) smpi_bench_end(); now = SIMIX_get_clock(); if (tv) { - tv->tv_sec = (time_t)now; + tv->tv_sec = static_cast(now); #ifdef WIN32 - tv->tv_usec = (useconds_t)((now - tv->tv_sec) * 1e6); + tv->tv_usec = static_cast((now - tv->tv_sec) * 1e6); #else - tv->tv_usec = (suseconds_t)((now - tv->tv_sec) * 1e6); + tv->tv_usec = static_cast((now - tv->tv_sec) * 1e6); #endif } smpi_bench_begin(); @@ -335,7 +332,7 @@ unsigned long long smpi_rastro_resolution (void) smpi_bench_end(); double resolution = (1/sg_surf_precision); smpi_bench_begin(); - return (unsigned long long)resolution; + return static_cast(resolution); } unsigned long long smpi_rastro_timestamp (void) @@ -346,7 +343,7 @@ unsigned long long smpi_rastro_timestamp (void) unsigned long long sec = (unsigned long long)now; unsigned long long pre = (now - sec) * smpi_rastro_resolution(); smpi_bench_begin(); - return (unsigned long long)sec * smpi_rastro_resolution() + pre; + return static_cast(sec) * smpi_rastro_resolution() + pre; } /* ****************************** Functions related to the SMPI_SAMPLE_ macros ************************************/ @@ -390,14 +387,14 @@ void smpi_sample_1(int global, const char *file, int line, int iters, double thr smpi_bench_end(); /* Take time from previous, unrelated computation into account */ smpi_process_set_sampling(1); - if (!samples) + if (samples==NULL) samples = xbt_dict_new_homogeneous(free); data = static_cast(xbt_dict_get_or_null(samples, loc)); - if (!data) { + if (data==NULL) { xbt_assert(threshold>0 || iters>0, "You should provide either a positive amount of iterations to bench, or a positive maximal stderr (or both)"); - data = (local_data_t *) xbt_new(local_data_t, 1); + data = static_cast( xbt_new(local_data_t, 1)); data->count = 0; data->sum = 0.0; data->sum_pow2 = 0.0; @@ -476,10 +473,10 @@ void smpi_sample_3(int global, const char *file, int line) sample = xbt_os_timer_elapsed(smpi_process_timer()); data->sum += sample; data->sum_pow2 += sample * sample; - n = (double)data->count; + n = static_cast(data->count); data->mean = data->sum / n; data->relstderr = sqrt((data->sum_pow2 / n - data->mean * data->mean) / n) / data->mean; - if (!sample_enough_benchs(data)) { + if (sample_enough_benchs(data)==0) { data->mean = sample; // Still in benching process; We want sample_2 to simulate the exact time of this loop // occurrence before leaving, not the mean over the history } @@ -507,12 +504,10 @@ void *smpi_shared_malloc(size_t size, const char *file, int line) snprintf(shmname, 31, "/shmalloc%p", &*data); fd = shm_open(shmname, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); if (fd < 0) { - switch(errno) { - case EEXIST: - xbt_die("Please cleanup /dev/shm/%s", shmname); - default: - xbt_die("An unhandled error occurred while opening %s. shm_open: %s", shmname, strerror(errno)); - } + if(errno==EEXIST) + xbt_die("Please cleanup /dev/shm/%s", shmname); + else + xbt_die("An unhandled error occurred while opening %s. shm_open: %s", shmname, strerror(errno)); } data->second.fd = fd; data->second.count = 1; @@ -569,7 +564,7 @@ int smpi_shared_known_call(const char* func, const char* input) xbt_ex_t ex; int known = 0; - if (!calls) { + if (calls==NULL) { calls = xbt_dict_new_homogeneous(NULL); } TRY { @@ -591,11 +586,11 @@ void* smpi_shared_get_call(const char* func, const char* input) { char* loc = bprintf("%s:%s", func, input); void* data; - if(!calls) { + if(calls==NULL) { calls = xbt_dict_new_homogeneous(NULL); } data = xbt_dict_get(calls, loc); - free(loc); + xbt_free(loc); return data; } @@ -606,7 +601,7 @@ void* smpi_shared_set_call(const char* func, const char* input, void* data) { calls = xbt_dict_new_homogeneous(NULL); } xbt_dict_set(calls, loc, data, NULL); - free(loc); + xbt_free(loc); return data; } @@ -671,7 +666,7 @@ void smpi_initialize_global_memory_segments(){ } smpi_privatisation_regions = - (smpi_privatisation_region_t) malloc(smpi_process_count() * sizeof(struct s_smpi_privatisation_region)); + static_cast( xbt_malloc(smpi_process_count() * sizeof(struct s_smpi_privatisation_region))); for (int i=0; i< smpi_process_count(); i++){ //create SIMIX_process_count() mappings of this size with the same data inside diff --git a/src/smpi/smpi_c99.cpp b/src/smpi/smpi_c99.cpp index 15e49df534..689ac88f00 100644 --- a/src/smpi/smpi_c99.cpp +++ b/src/smpi/smpi_c99.cpp @@ -17,14 +17,14 @@ static xbt_dynar_t registered_static_stack = NULL; void smpi_register_static(void* arg, void_f_pvoid_t free_fn) { s_smpi_static_t elm = { arg, free_fn }; - if (!registered_static_stack) + if (registered_static_stack==NULL) registered_static_stack = xbt_dynar_new(sizeof(s_smpi_static_t), NULL); xbt_dynar_push_as(registered_static_stack, s_smpi_static_t, elm); } void smpi_free_static(void) { - while (!xbt_dynar_is_empty(registered_static_stack)) { + while (xbt_dynar_is_empty(registered_static_stack)==0) { s_smpi_static_t elm = xbt_dynar_pop_as(registered_static_stack, s_smpi_static_t); elm.free_fn(elm.ptr); diff --git a/src/smpi/smpi_comm.cpp b/src/smpi/smpi_comm.cpp index ffc2d3c69e..ec94c1e1c7 100644 --- a/src/smpi/smpi_comm.cpp +++ b/src/smpi/smpi_comm.cpp @@ -39,8 +39,8 @@ typedef struct s_smpi_mpi_communicator { static int smpi_compare_rankmap(const void *a, const void *b) { - const int* x = (const int*)a; - const int* y = (const int*)b; + const int* x = static_cast(a); + const int* y = static_cast(b); if (x[1] < y[1]) { return -1; @@ -91,25 +91,7 @@ int smpi_comm_dup(MPI_Comm comm, MPI_Comm* newcomm){ MPI_Group cp=smpi_group_copy(smpi_comm_group(comm)); (*newcomm) = smpi_comm_new(cp, smpi_comm_topo(comm)); int ret = MPI_SUCCESS; - //todo: faire en sorte que ça fonctionne avec un communicator dupliqué (refaire un init_smp ?) - - /* MPI_Comm tmp=smpi_comm_get_intra_comm(comm); - if( tmp != MPI_COMM_NULL) - smpi_comm_set_intra_comm((*newcomm), smpi_comm_dup(tmp)); - tmp=smpi_comm_get_leaders_comm(comm); - if( tmp != MPI_COMM_NULL) - smpi_comm_set_leaders_comm((*newcomm), smpi_comm_dup(tmp)); - if(comm->non_uniform_map !=NULL){ - (*newcomm)->non_uniform_map= - xbt_malloc(smpi_comm_size(comm->leaders_comm)*sizeof(int)); - memcpy((*newcomm)->non_uniform_map, - comm->non_uniform_map,smpi_comm_size(comm->leaders_comm)*sizeof(int) ); - } - if(comm->leaders_map !=NULL){ - (*newcomm)->leaders_map=xbt_malloc(smpi_comm_size(comm)*sizeof(int)); - memcpy((*newcomm)->leaders_map, - comm->leaders_map,smpi_comm_size(comm)*sizeof(int) ); - }*/ + if(comm->attributes !=NULL){ (*newcomm)->attributes=xbt_dict_new(); xbt_dict_cursor_t cursor = NULL; @@ -119,8 +101,8 @@ int smpi_comm_dup(MPI_Comm comm, MPI_Comm* newcomm){ void* value_out; xbt_dict_foreach(comm->attributes, cursor, key, value_in){ smpi_comm_key_elem elem = - static_cast(xbt_dict_get_or_null_ext(smpi_comm_keyvals, (const char*)key, sizeof(int))); - if(elem && elem->copy_fn!=MPI_NULL_COPY_FN){ + static_cast(xbt_dict_get_or_null_ext(smpi_comm_keyvals, reinterpret_cast(key), sizeof(int))); + if(elem!=NULL && elem->copy_fn!=MPI_NULL_COPY_FN){ ret = elem->copy_fn(comm, *key, NULL, value_in, &value_out, &flag ); if(ret!=MPI_SUCCESS){ smpi_comm_destroy(*newcomm); @@ -128,7 +110,7 @@ int smpi_comm_dup(MPI_Comm comm, MPI_Comm* newcomm){ return ret; } if(flag) - xbt_dict_set_ext((*newcomm)->attributes, (const char*)key, sizeof(int),value_out, NULL); + xbt_dict_set_ext((*newcomm)->attributes, reinterpret_cast(key), sizeof(int),value_out, NULL); } } } @@ -167,7 +149,7 @@ void smpi_comm_get_name (MPI_Comm comm, char* name, int* len) if (comm == MPI_COMM_UNINITIALIZED) comm = smpi_process_comm_world(); if(comm == MPI_COMM_WORLD) { - strcpy(name, "WORLD"); + strncpy(name, "WORLD",5); *len = 5; } else { *len = snprintf(name, MPI_MAX_NAME_STRING, "%p", comm); @@ -233,7 +215,8 @@ MPI_Comm smpi_comm_split(MPI_Comm comm, int color, int key) MPI_Group* group_snd; MPI_Request* requests; - group_root = group_out = NULL; + group_root = NULL; + group_out = NULL; group = smpi_comm_group(comm); rank = smpi_comm_rank(comm); size = smpi_comm_size(comm); @@ -253,46 +236,46 @@ MPI_Comm smpi_comm_split(MPI_Comm comm, int color, int key) group_snd = xbt_new(MPI_Group, size); rankmap = xbt_new(int, 2 * size); for(i = 0; i < size; i++) { - if(recvbuf[2 * i] == MPI_UNDEFINED) { - continue; - } - count = 0; - for(j = i + 1; j < size; j++) { - if(recvbuf[2 * i] == recvbuf[2 * j]) { - recvbuf[2 * j] = MPI_UNDEFINED; - rankmap[2 * count] = j; - rankmap[2 * count + 1] = recvbuf[2 * j + 1]; - count++; + if(recvbuf[2 * i] != MPI_UNDEFINED) { + + count = 0; + for(j = i + 1; j < size; j++) { + if(recvbuf[2 * i] == recvbuf[2 * j]) { + recvbuf[2 * j] = MPI_UNDEFINED; + rankmap[2 * count] = j; + rankmap[2 * count + 1] = recvbuf[2 * j + 1]; + count++; + } } - } - /* Add self in the group */ - recvbuf[2 * i] = MPI_UNDEFINED; - rankmap[2 * count] = i; - rankmap[2 * count + 1] = recvbuf[2 * i + 1]; - count++; - qsort(rankmap, count, 2 * sizeof(int), &smpi_compare_rankmap); - group_out = smpi_group_new(count); - if(i == 0) { - group_root = group_out; /* Save root's group */ - } - for(j = 0; j < count; j++) { - index = smpi_group_index(group, rankmap[2 * j]); - smpi_group_set_mapping(group_out, index, j); - } - requests = xbt_new(MPI_Request, count); - reqs = 0; - for(j = 0; j < count; j++) { - if(rankmap[2 * j] != 0) { - group_snd[reqs]=smpi_group_copy(group_out); - requests[reqs] = smpi_mpi_isend(&(group_snd[reqs]), 1, MPI_PTR, rankmap[2 * j], system_tag, comm); - reqs++; + /* Add self in the group */ + recvbuf[2 * i] = MPI_UNDEFINED; + rankmap[2 * count] = i; + rankmap[2 * count + 1] = recvbuf[2 * i + 1]; + count++; + qsort(rankmap, count, 2 * sizeof(int), &smpi_compare_rankmap); + group_out = smpi_group_new(count); + if(i == 0) { + group_root = group_out; /* Save root's group */ } + for(j = 0; j < count; j++) { + index = smpi_group_index(group, rankmap[2 * j]); + smpi_group_set_mapping(group_out, index, j); + } + requests = xbt_new(MPI_Request, count); + reqs = 0; + for(j = 0; j < count; j++) { + if(rankmap[2 * j] != 0) { + group_snd[reqs]=smpi_group_copy(group_out); + requests[reqs] = smpi_mpi_isend(&(group_snd[reqs]), 1, MPI_PTR, rankmap[2 * j], system_tag, comm); + reqs++; + } + } + if(i != 0) { + smpi_group_destroy(group_out); + } + smpi_mpi_waitall(reqs, requests, MPI_STATUS_IGNORE); + xbt_free(requests); } - if(i != 0) { - smpi_group_destroy(group_out); - } - smpi_mpi_waitall(reqs, requests, MPI_STATUS_IGNORE); - xbt_free(requests); } xbt_free(recvbuf); xbt_free(rankmap); @@ -303,7 +286,7 @@ MPI_Comm smpi_comm_split(MPI_Comm comm, int color, int key) smpi_mpi_recv(&group_out, 1, MPI_PTR, 0, system_tag, comm, MPI_STATUS_IGNORE); } /* otherwise, exit with group_out == NULL */ } - return group_out ? smpi_comm_new(group_out, NULL) : MPI_COMM_NULL; + return group_out!=NULL ? smpi_comm_new(group_out, NULL) : MPI_COMM_NULL; } void smpi_comm_use(MPI_Comm comm){ @@ -321,8 +304,8 @@ void smpi_comm_cleanup_attributes(MPI_Comm comm){ int flag; xbt_dict_foreach(comm->attributes, cursor, key, value){ smpi_comm_key_elem elem = - static_cast(xbt_dict_get_or_null(smpi_comm_keyvals, (const char*)key)); - if(elem && elem->delete_fn) + static_cast(xbt_dict_get_or_null(smpi_comm_keyvals, reinterpret_cast(key))); + if(elem!=NULL && elem->delete_fn) elem->delete_fn(comm, *key, value, &flag); } xbt_dict_free(&comm->attributes); @@ -355,10 +338,10 @@ void smpi_comm_unuse(MPI_Comm comm){ static int compare_ints (const void *a, const void *b) { - const int *da = (const int *) a; - const int *db = (const int *) b; + const int *da = static_cast(a); + const int *db = static_cast(b); - return (*da > *db) - (*da < *db); + return static_cast(*da > *db) - static_cast(*da < *db); } void smpi_comm_init_smp(MPI_Comm comm){ @@ -384,18 +367,10 @@ void smpi_comm_init_smp(MPI_Comm comm){ //get the indexes of all processes sharing the same simix host xbt_swag_t process_list = SIMIX_host_self()->processes(); int intra_comm_size = 0; - //only one process/node, disable SMP support and return -// if(intra_comm_size==1){ -// smpi_comm_set_intra_comm(comm, MPI_COMM_SELF); -// //smpi_comm_set_leaders_comm(comm, comm); -// smpi_process_set_comm_intra(MPI_COMM_SELF); -// return; -// } int i =0; int min_index=INT_MAX;//the minimum index will be the leader smx_process_t process = NULL; xbt_swag_foreach(process, process_list) { - //is_in_comm=0; int index = SIMIX_process_get_PID(process) -1; if(smpi_group_rank(smpi_comm_group(comm), index)!=MPI_UNDEFINED){ @@ -411,7 +386,6 @@ void smpi_comm_init_smp(MPI_Comm comm){ i=0; process = NULL; xbt_swag_foreach(process, process_list) { - //is_in_comm=0; int index = SIMIX_process_get_PID(process) -1; if(smpi_group_rank(smpi_comm_group(comm), index)!=MPI_UNDEFINED){ smpi_group_set_mapping(group_intra, index, i); @@ -420,14 +394,10 @@ void smpi_comm_init_smp(MPI_Comm comm){ } MPI_Comm comm_intra = smpi_comm_new(group_intra, NULL); - //MPI_Comm shmem_comm = smpi_process_comm_intra(); - //int intra_rank = smpi_comm_rank(shmem_comm); - - //if(smpi_process_index()==min_index) leader=min_index; - int * leaders_map= (int*)xbt_malloc0(sizeof(int)*comm_size); - int * leader_list= (int*)xbt_malloc0(sizeof(int)*comm_size); + int * leaders_map= static_cast(xbt_malloc0(sizeof(int)*comm_size)); + int * leader_list= static_cast(xbt_malloc0(sizeof(int)*comm_size)); for(i=0; ileaders_map){ + if(comm->leaders_map==NULL){ comm->leaders_map= leaders_map; }else{ xbt_free(leaders_map); @@ -452,7 +422,7 @@ void smpi_comm_init_smp(MPI_Comm comm){ already_done=1; } } - if(!already_done){ + if(already_done==0){ leader_list[leader_group_size]=comm->leaders_map[i]; leader_group_size++; } @@ -471,7 +441,6 @@ void smpi_comm_init_smp(MPI_Comm comm){ smpi_comm_set_intra_comm(comm, comm_intra); //create intracommunicator - // smpi_comm_set_intra_comm(comm, smpi_comm_split(comm, *(int*)SIMIX_host_self(), comm_rank)); }else{ for (i=0; i< leader_group_size;i++) smpi_group_set_mapping(leaders_group, leader_list[i], i); @@ -500,7 +469,7 @@ void smpi_comm_init_smp(MPI_Comm comm){ break; } } - if(!is_uniform && smpi_comm_is_uniform(comm)){ + if(is_uniform==0 && smpi_comm_is_uniform(comm)!=0){ comm->non_uniform_map= non_uniform_map; }else{ xbt_free(non_uniform_map); @@ -542,28 +511,29 @@ void smpi_comm_init_smp(MPI_Comm comm){ int smpi_comm_attr_delete(MPI_Comm comm, int keyval){ smpi_comm_key_elem elem = - static_cast(xbt_dict_get_or_null_ext(smpi_comm_keyvals, (const char*)&keyval, sizeof(int))); - if(!elem) + static_cast(xbt_dict_get_or_null_ext(smpi_comm_keyvals, reinterpret_cast(&keyval), sizeof(int))); + if(elem==NULL) return MPI_ERR_ARG; if(elem->delete_fn!=MPI_NULL_DELETE_FN){ void * value; int flag; if(smpi_comm_attr_get(comm, keyval, &value, &flag)==MPI_SUCCESS){ int ret = elem->delete_fn(comm, keyval, value, &flag); - if(ret!=MPI_SUCCESS) return ret; + if(ret!=MPI_SUCCESS) + return ret; } } if(comm->attributes==NULL) return MPI_ERR_ARG; - xbt_dict_remove_ext(comm->attributes, (const char*)&keyval, sizeof(int)); + xbt_dict_remove_ext(comm->attributes, reinterpret_cast(&keyval), sizeof(int)); return MPI_SUCCESS; } int smpi_comm_attr_get(MPI_Comm comm, int keyval, void* attr_value, int* flag){ smpi_comm_key_elem elem = - static_cast(xbt_dict_get_or_null_ext(smpi_comm_keyvals, (const char*)&keyval, sizeof(int))); - if(!elem) + static_cast(xbt_dict_get_or_null_ext(smpi_comm_keyvals, reinterpret_cast(&keyval), sizeof(int))); + if(elem==NULL) return MPI_ERR_ARG; xbt_ex_t ex; if(comm->attributes==NULL){ @@ -571,7 +541,8 @@ int smpi_comm_attr_get(MPI_Comm comm, int keyval, void* attr_value, int* flag){ return MPI_SUCCESS; } TRY { - *(void**)attr_value = xbt_dict_get_ext(comm->attributes, (const char*)&keyval, sizeof(int)); + *static_cast(attr_value) = xbt_dict_get_ext(comm->attributes, + reinterpret_cast(&keyval), sizeof(int)); *flag=1; } CATCH(ex) { *flag=0; @@ -581,49 +552,49 @@ int smpi_comm_attr_get(MPI_Comm comm, int keyval, void* attr_value, int* flag){ } int smpi_comm_attr_put(MPI_Comm comm, int keyval, void* attr_value){ - if(!smpi_comm_keyvals) - smpi_comm_keyvals = xbt_dict_new(); + if(smpi_comm_keyvals==NULL) + smpi_comm_keyvals = xbt_dict_new(); smpi_comm_key_elem elem = - static_cast(xbt_dict_get_or_null_ext(smpi_comm_keyvals, (const char*)&keyval, sizeof(int))); - if(!elem ) + static_cast(xbt_dict_get_or_null_ext(smpi_comm_keyvals, reinterpret_cast(&keyval), sizeof(int))); + if(elem==NULL) return MPI_ERR_ARG; int flag; void* value; smpi_comm_attr_get(comm, keyval, &value, &flag); - if(flag && elem->delete_fn!=MPI_NULL_DELETE_FN){ + if(flag!=0 && elem->delete_fn!=MPI_NULL_DELETE_FN){ int ret = elem->delete_fn(comm, keyval, value, &flag); - if(ret!=MPI_SUCCESS) return ret; + if(ret!=MPI_SUCCESS) + return ret; } if(comm->attributes==NULL) comm->attributes=xbt_dict_new(); - xbt_dict_set_ext(comm->attributes, (const char*)&keyval, sizeof(int), attr_value, NULL); + xbt_dict_set_ext(comm->attributes, reinterpret_cast(&keyval), sizeof(int), attr_value, NULL); return MPI_SUCCESS; } int smpi_comm_keyval_create(MPI_Comm_copy_attr_function* copy_fn, MPI_Comm_delete_attr_function* delete_fn, int* keyval, void* extra_state){ - if(!smpi_comm_keyvals) - smpi_comm_keyvals = xbt_dict_new(); + if(smpi_comm_keyvals==NULL) + smpi_comm_keyvals = xbt_dict_new(); - smpi_comm_key_elem value = (smpi_comm_key_elem) xbt_new0(s_smpi_mpi_comm_key_elem_t,1); + smpi_comm_key_elem value = static_cast(xbt_new0(s_smpi_mpi_comm_key_elem_t,1)); value->copy_fn=copy_fn; value->delete_fn=delete_fn; *keyval = comm_keyval_id; - xbt_dict_set_ext(smpi_comm_keyvals, (const char*)keyval, sizeof(int),(void*)value, NULL); + xbt_dict_set_ext(smpi_comm_keyvals, reinterpret_cast(keyval), sizeof(int),static_cast(value), NULL); comm_keyval_id++; return MPI_SUCCESS; } int smpi_comm_keyval_free(int* keyval){ smpi_comm_key_elem elem = - static_cast(xbt_dict_get_or_null_ext(smpi_comm_keyvals, (const char*)keyval, sizeof(int))); - if(!elem){ + static_cast(xbt_dict_get_or_null_ext(smpi_comm_keyvals, reinterpret_cast(keyval), sizeof(int))); + if(elem==NULL) return MPI_ERR_ARG; - } - xbt_dict_remove_ext(smpi_comm_keyvals, (const char*)keyval, sizeof(int)); + xbt_dict_remove_ext(smpi_comm_keyvals, reinterpret_cast(keyval), sizeof(int)); xbt_free(elem); return MPI_SUCCESS; } diff --git a/src/smpi/smpi_f77.cpp b/src/smpi/smpi_f77.cpp index 09cb2100a7..8f174f8f95 100644 --- a/src/smpi/smpi_f77.cpp +++ b/src/smpi/smpi_f77.cpp @@ -58,7 +58,7 @@ static char* get_key_id(char* key, int id) { } static void smpi_init_fortran_types(){ - if(!comm_lookup){ + if(comm_lookup == NULL){ comm_lookup = xbt_dict_new_homogeneous(NULL); smpi_comm_c2f(MPI_COMM_WORLD); group_lookup = xbt_dict_new_homogeneous(NULL); @@ -68,13 +68,13 @@ static void smpi_init_fortran_types(){ info_lookup = xbt_dict_new_homogeneous(NULL); smpi_type_c2f(MPI_BYTE);//MPI_BYTE smpi_type_c2f(MPI_CHAR);//MPI_CHARACTER - #if defined(__alpha__) || defined(__sparc64__) || defined(__x86_64__) || defined(__ia64__) +#if defined(__alpha__) || defined(__sparc64__) || defined(__x86_64__) || defined(__ia64__) smpi_type_c2f(MPI_INT);//MPI_LOGICAL smpi_type_c2f(MPI_INT);//MPI_INTEGER - #else +#else smpi_type_c2f(MPI_LONG);//MPI_LOGICAL smpi_type_c2f(MPI_LONG);//MPI_INTEGER - #endif +#endif smpi_type_c2f(MPI_INT8_T);//MPI_INTEGER1 smpi_type_c2f(MPI_INT16_T);//MPI_INTEGER2 smpi_type_c2f(MPI_INT32_T);//MPI_INTEGER4 @@ -85,11 +85,11 @@ static void smpi_init_fortran_types(){ smpi_type_c2f(MPI_DOUBLE);//MPI_DOUBLE_PRECISION smpi_type_c2f(MPI_C_FLOAT_COMPLEX);//MPI_COMPLEX smpi_type_c2f(MPI_C_DOUBLE_COMPLEX);//MPI_DOUBLE_COMPLEX - #if defined(__alpha__) || defined(__sparc64__) || defined(__x86_64__) || defined(__ia64__) +#if defined(__alpha__) || defined(__sparc64__) || defined(__x86_64__) || defined(__ia64__) smpi_type_c2f(MPI_2INT);//MPI_2INTEGER - #else +#else smpi_type_c2f(MPI_2LONG);//MPI_2INTEGER - #endif +#endif smpi_type_c2f(MPI_UINT8_T);//MPI_LOGICAL1 smpi_type_c2f(MPI_UINT16_T);//MPI_LOGICAL2 smpi_type_c2f(MPI_UINT32_T);//MPI_LOGICAL4 @@ -137,14 +137,15 @@ MPI_Comm smpi_comm_f2c(int comm) { smpi_init_fortran_types(); if(comm == -2) { return MPI_COMM_SELF; - }else if(comm==0){ + } else if(comm==0){ return MPI_COMM_WORLD; - } else if(comm_lookup && comm >= 0) { + } else if(comm_lookup != NULL && comm >= 0) { char key[KEY_SIZE]; - MPI_Comm tmp = (MPI_Comm)xbt_dict_get_or_null(comm_lookup,get_key_id(key, comm)); + MPI_Comm tmp = static_cast(xbt_dict_get_or_null(comm_lookup,get_key_id(key, comm))); return tmp != NULL ? tmp : MPI_COMM_NULL ; + } else { + return MPI_COMM_NULL; } - return MPI_COMM_NULL; } int smpi_group_c2f(MPI_Group group) { @@ -159,11 +160,12 @@ MPI_Group smpi_group_f2c(int group) { smpi_init_fortran_types(); if(group == -2) { return MPI_GROUP_EMPTY; - } else if(group_lookup && group >= 0) { + } else if(group_lookup != NULL && group >= 0) { char key[KEY_SIZE]; - return (MPI_Group)xbt_dict_get_or_null(group_lookup, get_key(key, group)); + return static_cast(xbt_dict_get_or_null(group_lookup, get_key(key, group))); + } else { + return MPI_GROUP_NULL; } - return MPI_GROUP_NULL; } static void free_group(int group) { @@ -182,8 +184,9 @@ int smpi_request_c2f(MPI_Request req) { MPI_Request smpi_request_f2c(int req) { smpi_init_fortran_types(); char key[KEY_SIZE]; - if(req==MPI_FORTRAN_REQUEST_NULL)return MPI_REQUEST_NULL; - return (MPI_Request)xbt_dict_get(request_lookup, get_key_id(key, req)); + if(req==MPI_FORTRAN_REQUEST_NULL) + return MPI_REQUEST_NULL; + return static_cast(xbt_dict_get(request_lookup, get_key_id(key, req))); } static void free_request(int request) { @@ -203,7 +206,7 @@ int smpi_type_c2f(MPI_Datatype datatype) { MPI_Datatype smpi_type_f2c(int datatype) { smpi_init_fortran_types(); char key[KEY_SIZE]; - return datatype >= 0 ? (MPI_Datatype)xbt_dict_get_or_null(datatype_lookup, get_key(key, datatype)): MPI_DATATYPE_NULL; + return datatype >= 0 ? static_cast(xbt_dict_get_or_null(datatype_lookup, get_key(key, datatype))): MPI_DATATYPE_NULL; } static void free_datatype(int datatype) { @@ -222,7 +225,7 @@ int smpi_op_c2f(MPI_Op op) { MPI_Op smpi_op_f2c(int op) { smpi_init_fortran_types(); char key[KEY_SIZE]; - return op >= 0 ? (MPI_Op)xbt_dict_get_or_null(op_lookup, get_key(key, op)): MPI_OP_NULL; + return op >= 0 ? static_cast(xbt_dict_get_or_null(op_lookup, get_key(key, op))): MPI_OP_NULL; } static void free_op(int op) { @@ -241,7 +244,7 @@ int smpi_win_c2f(MPI_Win win) { MPI_Win smpi_win_f2c(int win) { smpi_init_fortran_types(); char key[KEY_SIZE]; - return win >= 0 ? (MPI_Win)xbt_dict_get_or_null(win_lookup, get_key(key, win)) : MPI_WIN_NULL; + return win >= 0 ? static_cast(xbt_dict_get_or_null(win_lookup, get_key(key, win))) : MPI_WIN_NULL; } static void free_win(int win) { @@ -260,7 +263,7 @@ int smpi_info_c2f(MPI_Info info) { MPI_Info smpi_info_f2c(int info) { smpi_init_fortran_types(); char key[KEY_SIZE]; - return info >= 0 ? (MPI_Info)xbt_dict_get_or_null(info_lookup, get_key(key, info)) : MPI_INFO_NULL; + return info >= 0 ? static_cast(xbt_dict_get_or_null(info_lookup, get_key(key, info))) : MPI_INFO_NULL; } static void free_info(int info) { @@ -369,7 +372,7 @@ void mpi_initialized_(int* flag, int* ierr){ void mpi_send_init_(void *buf, int* count, int* datatype, int* dst, int* tag, int* comm, int* request, int* ierr) { MPI_Request req; - buf = (char *) FORT_BOTTOM(buf); + buf = static_cast(FORT_BOTTOM(buf)); *ierr = MPI_Send_init(buf, *count, smpi_type_f2c(*datatype), *dst, *tag, smpi_comm_f2c(*comm), &req); if(*ierr == MPI_SUCCESS) { *request = smpi_request_c2f(req); @@ -378,7 +381,7 @@ void mpi_send_init_(void *buf, int* count, int* datatype, int* dst, int* tag, in void mpi_isend_(void *buf, int* count, int* datatype, int* dst, int* tag, int* comm, int* request, int* ierr) { MPI_Request req; - buf = (char *) FORT_BOTTOM(buf); + buf = static_cast(FORT_BOTTOM(buf)); *ierr = MPI_Isend(buf, *count, smpi_type_f2c(*datatype), *dst, *tag, smpi_comm_f2c(*comm), &req); if(*ierr == MPI_SUCCESS) { *request = smpi_request_c2f(req); @@ -387,7 +390,7 @@ void mpi_isend_(void *buf, int* count, int* datatype, int* dst, int* tag, int* c void mpi_irsend_(void *buf, int* count, int* datatype, int* dst, int* tag, int* comm, int* request, int* ierr) { MPI_Request req; - buf = (char *) FORT_BOTTOM(buf); + buf = static_cast(FORT_BOTTOM(buf)); *ierr = MPI_Irsend(buf, *count, smpi_type_f2c(*datatype), *dst, *tag, smpi_comm_f2c(*comm), &req); if(*ierr == MPI_SUCCESS) { *request = smpi_request_c2f(req); @@ -395,26 +398,26 @@ void mpi_irsend_(void *buf, int* count, int* datatype, int* dst, int* tag, int* } void mpi_send_(void* buf, int* count, int* datatype, int* dst, int* tag, int* comm, int* ierr) { - buf = (char *) FORT_BOTTOM(buf); + buf = static_cast(FORT_BOTTOM(buf)); *ierr = MPI_Send(buf, *count, smpi_type_f2c(*datatype), *dst, *tag, smpi_comm_f2c(*comm)); } void mpi_rsend_(void* buf, int* count, int* datatype, int* dst, int* tag, int* comm, int* ierr) { - buf = (char *) FORT_BOTTOM(buf); + buf = static_cast(FORT_BOTTOM(buf)); *ierr = MPI_Rsend(buf, *count, smpi_type_f2c(*datatype), *dst, *tag, smpi_comm_f2c(*comm)); } void mpi_sendrecv_(void* sendbuf, int* sendcount, int* sendtype, int* dst, int* sendtag, void *recvbuf, int* recvcount, int* recvtype, int* src, int* recvtag, int* comm, MPI_Status* status, int* ierr) { - sendbuf = (char *) FORT_BOTTOM(sendbuf); - recvbuf = (char *) FORT_BOTTOM(recvbuf); + sendbuf = static_cast( FORT_BOTTOM(sendbuf)); + recvbuf = static_cast( FORT_BOTTOM(recvbuf)); *ierr = MPI_Sendrecv(sendbuf, *sendcount, smpi_type_f2c(*sendtype), *dst, *sendtag, recvbuf, *recvcount, smpi_type_f2c(*recvtype), *src, *recvtag, smpi_comm_f2c(*comm), FORT_STATUS_IGNORE(status)); } void mpi_recv_init_(void *buf, int* count, int* datatype, int* src, int* tag, int* comm, int* request, int* ierr) { MPI_Request req; - buf = (char *) FORT_BOTTOM(buf); + buf = static_cast( FORT_BOTTOM(buf)); *ierr = MPI_Recv_init(buf, *count, smpi_type_f2c(*datatype), *src, *tag, smpi_comm_f2c(*comm), &req); if(*ierr == MPI_SUCCESS) { *request = smpi_request_c2f(req); @@ -423,7 +426,7 @@ void mpi_recv_init_(void *buf, int* count, int* datatype, int* src, int* tag, in void mpi_irecv_(void *buf, int* count, int* datatype, int* src, int* tag, int* comm, int* request, int* ierr) { MPI_Request req; - buf = (char *) FORT_BOTTOM(buf); + buf = static_cast( FORT_BOTTOM(buf)); *ierr = MPI_Irecv(buf, *count, smpi_type_f2c(*datatype), *src, *tag, smpi_comm_f2c(*comm), &req); if(*ierr == MPI_SUCCESS) { *request = smpi_request_c2f(req); @@ -431,7 +434,7 @@ void mpi_irecv_(void *buf, int* count, int* datatype, int* src, int* tag, int* c } void mpi_recv_(void* buf, int* count, int* datatype, int* src, int* tag, int* comm, MPI_Status* status, int* ierr) { - buf = (char *) FORT_BOTTOM(buf); + buf = static_cast( FORT_BOTTOM(buf)); *ierr = MPI_Recv(buf, *count, smpi_type_f2c(*datatype), *src, *tag, smpi_comm_f2c(*comm), status); } @@ -450,7 +453,7 @@ void mpi_startall_(int* count, int* requests, int* ierr) { reqs[i] = smpi_request_f2c(requests[i]); } *ierr = MPI_Startall(*count, reqs); - free(reqs); + xbt_free(reqs); } void mpi_wait_(int* request, MPI_Status* status, int* ierr) { @@ -476,7 +479,7 @@ void mpi_waitany_(int* count, int* requests, int* index, MPI_Status* status, int free_request(requests[*index]); requests[*index]=MPI_FORTRAN_REQUEST_NULL; } - free(reqs); + xbt_free(reqs); } void mpi_waitall_(int* count, int* requests, MPI_Status* status, int* ierr) { @@ -495,7 +498,7 @@ void mpi_waitall_(int* count, int* requests, MPI_Status* status, int* ierr) { } } - free(reqs); + xbt_free(reqs); } void mpi_barrier_(int* comm, int* ierr) { @@ -507,65 +510,65 @@ void mpi_bcast_(void *buf, int* count, int* datatype, int* root, int* comm, int* } void mpi_reduce_(void* sendbuf, void* recvbuf, int* count, int* datatype, int* op, int* root, int* comm, int* ierr) { - sendbuf = (char *) FORT_IN_PLACE(sendbuf); - sendbuf = (char *) FORT_BOTTOM(sendbuf); - recvbuf = (char *) FORT_BOTTOM(recvbuf); + sendbuf = static_cast( FORT_IN_PLACE(sendbuf)); + sendbuf = static_cast( FORT_BOTTOM(sendbuf)); + recvbuf = static_cast( FORT_BOTTOM(recvbuf)); *ierr = MPI_Reduce(sendbuf, recvbuf, *count, smpi_type_f2c(*datatype), smpi_op_f2c(*op), *root, smpi_comm_f2c(*comm)); } void mpi_allreduce_(void* sendbuf, void* recvbuf, int* count, int* datatype, int* op, int* comm, int* ierr) { - sendbuf = (char *) FORT_IN_PLACE(sendbuf); + sendbuf = static_cast( FORT_IN_PLACE(sendbuf)); *ierr = MPI_Allreduce(sendbuf, recvbuf, *count, smpi_type_f2c(*datatype), smpi_op_f2c(*op), smpi_comm_f2c(*comm)); } void mpi_reduce_scatter_(void* sendbuf, void* recvbuf, int* recvcounts, int* datatype, int* op, int* comm, int* ierr) { - sendbuf = (char *) FORT_IN_PLACE(sendbuf); + sendbuf = static_cast( FORT_IN_PLACE(sendbuf)); *ierr = MPI_Reduce_scatter(sendbuf, recvbuf, recvcounts, smpi_type_f2c(*datatype), smpi_op_f2c(*op), smpi_comm_f2c(*comm)); } void mpi_scatter_(void* sendbuf, int* sendcount, int* sendtype, void* recvbuf, int* recvcount, int* recvtype, int* root, int* comm, int* ierr) { - recvbuf = (char *) FORT_IN_PLACE(recvbuf); + recvbuf = static_cast( FORT_IN_PLACE(recvbuf)); *ierr = MPI_Scatter(sendbuf, *sendcount, smpi_type_f2c(*sendtype), recvbuf, *recvcount, smpi_type_f2c(*recvtype), *root, smpi_comm_f2c(*comm)); } void mpi_scatterv_(void* sendbuf, int* sendcounts, int* displs, int* sendtype, void* recvbuf, int* recvcount, int* recvtype, int* root, int* comm, int* ierr) { - recvbuf = (char *) FORT_IN_PLACE(recvbuf); + recvbuf = static_cast( FORT_IN_PLACE(recvbuf)); *ierr = MPI_Scatterv(sendbuf, sendcounts, displs, smpi_type_f2c(*sendtype), recvbuf, *recvcount, smpi_type_f2c(*recvtype), *root, smpi_comm_f2c(*comm)); } void mpi_gather_(void* sendbuf, int* sendcount, int* sendtype, void* recvbuf, int* recvcount, int* recvtype, int* root, int* comm, int* ierr) { - sendbuf = (char *) FORT_IN_PLACE(sendbuf); - sendbuf = (char *) FORT_BOTTOM(sendbuf); - recvbuf = (char *) FORT_BOTTOM(recvbuf); + sendbuf = static_cast( FORT_IN_PLACE(sendbuf)); + sendbuf = static_cast( FORT_BOTTOM(sendbuf)); + recvbuf = static_cast( FORT_BOTTOM(recvbuf)); *ierr = MPI_Gather(sendbuf, *sendcount, smpi_type_f2c(*sendtype), recvbuf, *recvcount, smpi_type_f2c(*recvtype), *root, smpi_comm_f2c(*comm)); } void mpi_gatherv_(void* sendbuf, int* sendcount, int* sendtype, void* recvbuf, int* recvcounts, int* displs, int* recvtype, int* root, int* comm, int* ierr) { - sendbuf = (char *) FORT_IN_PLACE(sendbuf); - sendbuf = (char *) FORT_BOTTOM(sendbuf); - recvbuf = (char *) FORT_BOTTOM(recvbuf); + sendbuf = static_cast( FORT_IN_PLACE(sendbuf)); + sendbuf = static_cast( FORT_BOTTOM(sendbuf)); + recvbuf = static_cast( FORT_BOTTOM(recvbuf)); *ierr = MPI_Gatherv(sendbuf, *sendcount, smpi_type_f2c(*sendtype), recvbuf, recvcounts, displs, smpi_type_f2c(*recvtype), *root, smpi_comm_f2c(*comm)); } void mpi_allgather_(void* sendbuf, int* sendcount, int* sendtype, void* recvbuf, int* recvcount, int* recvtype, int* comm, int* ierr) { - sendbuf = (char *) FORT_IN_PLACE(sendbuf); + sendbuf = static_cast( FORT_IN_PLACE(sendbuf)); *ierr = MPI_Allgather(sendbuf, *sendcount, smpi_type_f2c(*sendtype), recvbuf, *recvcount, smpi_type_f2c(*recvtype), smpi_comm_f2c(*comm)); } void mpi_allgatherv_(void* sendbuf, int* sendcount, int* sendtype, void* recvbuf, int* recvcounts,int* displs, int* recvtype, int* comm, int* ierr) { - sendbuf = (char *) FORT_IN_PLACE(sendbuf); + sendbuf = static_cast( FORT_IN_PLACE(sendbuf)); *ierr = MPI_Allgatherv(sendbuf, *sendcount, smpi_type_f2c(*sendtype), recvbuf, recvcounts, displs, smpi_type_f2c(*recvtype), smpi_comm_f2c(*comm)); } @@ -704,7 +707,7 @@ void mpi_win_free_( int* win, int* ierr){ void mpi_win_create_( int *base, MPI_Aint* size, int* disp_unit, int* info, int* comm, int *win, int* ierr){ MPI_Win tmp; - *ierr = MPI_Win_create( (void*)base, *size, *disp_unit, smpi_info_f2c(*info), smpi_comm_f2c(*comm),&tmp); + *ierr = MPI_Win_create( static_cast(base), *size, *disp_unit, smpi_info_f2c(*info), smpi_comm_f2c(*comm),&tmp); if(*ierr == MPI_SUCCESS) { *win = smpi_win_c2f(tmp); } @@ -727,22 +730,24 @@ void mpi_win_wait_(int* win, int* ierr){ } void mpi_win_set_name_ (int* win, char * name, int* ierr, int size){ - //handle trailing blanks - while(name[size-1]==' ')size--; - while(*name==' '){//handle leading blanks - size --; - name++; - } - char* tname = xbt_new(char,size+1); - strncpy(tname, name, size); - tname[size]='\0'; - *ierr = MPI_Win_set_name(smpi_win_f2c(*win), tname); - xbt_free(tname); + //handle trailing blanks + while(name[size-1]==' ') + size--; + while(*name==' '){//handle leading blanks + size--; + name++; + } + char* tname = xbt_new(char,size+1); + strncpy(tname, name, size); + tname[size]='\0'; + *ierr = MPI_Win_set_name(smpi_win_f2c(*win), tname); + xbt_free(tname); } void mpi_win_get_name_ (int* win, char * name, int* len, int* ierr){ - *ierr = MPI_Win_get_name(smpi_win_f2c(*win),name,len); - if(*len>0) name[*len]=' ';//blank padding, not \0 + *ierr = MPI_Win_get_name(smpi_win_f2c(*win),name,len); + if(*len>0) + name[*len]=' ';//blank padding, not \0 } void mpi_info_create_( int *info, int* ierr){ @@ -754,48 +759,53 @@ void mpi_info_create_( int *info, int* ierr){ } void mpi_info_set_( int *info, char *key, char *value, int* ierr, unsigned int keylen, unsigned int valuelen){ - //handle trailing blanks - while(key[keylen-1]==' ')keylen--; - while(*key==' '){//handle leading blanks - keylen --; - key++; - } - char* tkey = xbt_new(char,keylen+1); - strncpy(tkey, key, keylen); - tkey[keylen]='\0'; - - while(value[valuelen-1]==' ')valuelen--; - while(*value==' '){//handle leading blanks - valuelen --; - value++; - } - char* tvalue = xbt_new(char,valuelen+1); - strncpy(tvalue, value, valuelen); - - tvalue[valuelen]='\0'; - *ierr = MPI_Info_set( smpi_info_f2c(*info), tkey, tvalue); - xbt_free(tkey); + //handle trailing blanks + while(key[keylen-1]==' ') + keylen--; + while(*key==' '){//handle leading blanks + keylen--; + key++; + } + char* tkey = xbt_new(char,keylen+1); + strncpy(tkey, key, keylen); + tkey[keylen]='\0'; + + while(value[valuelen-1]==' ') + valuelen--; + while(*value==' '){//handle leading blanks + valuelen--; + value++; + } + char* tvalue = xbt_new(char,valuelen+1); + strncpy(tvalue, value, valuelen); + + tvalue[valuelen]='\0'; + *ierr = MPI_Info_set( smpi_info_f2c(*info), tkey, tvalue); + xbt_free(tkey); } void mpi_info_get_ (int* info,char *key,int* valuelen, char *value, int *flag, int* ierr, unsigned int keylen ){ - while(key[keylen-1]==' ')keylen--; - while(*key==' '){//handle leading blanks - keylen --; - key++; - } char* tkey = xbt_new(char,keylen+1); - strncpy(tkey, key, keylen); - tkey[keylen]='\0'; - *ierr = MPI_Info_get(smpi_info_f2c(*info),tkey,*valuelen, value, flag); - xbt_free(tkey); - if(*flag==true){ - int replace=0, i=0; - for (i=0; i<*valuelen; i++){ - if(value[i]=='\0') - replace=1; - if(replace) - value[i]=' '; - } - } + while(key[keylen-1]==' ') + keylen--; + while(*key==' '){//handle leading blanks + keylen--; + key++; + } + char* tkey = xbt_new(char,keylen+1); + strncpy(tkey, key, keylen); + tkey[keylen]='\0'; + *ierr = MPI_Info_get(smpi_info_f2c(*info),tkey,*valuelen, value, flag); + xbt_free(tkey); + if(*flag==true){ + int replace=0; + int i=0; + for (i=0; i<*valuelen; i++){ + if(value[i]=='\0') + replace=1; + if(replace) + value[i]=' '; + } + } } void mpi_info_free_(int* info, int* ierr){ @@ -808,19 +818,19 @@ void mpi_info_free_(int* info, int* ierr){ void mpi_get_( int *origin_addr, int* origin_count, int* origin_datatype, int *target_rank, MPI_Aint* target_disp, int *target_count, int* tarsmpi_type_f2c, int* win, int* ierr){ - *ierr = MPI_Get( (void*)origin_addr,*origin_count, smpi_type_f2c(*origin_datatype),*target_rank, + *ierr = MPI_Get( static_cast(origin_addr),*origin_count, smpi_type_f2c(*origin_datatype),*target_rank, *target_disp, *target_count,smpi_type_f2c(*tarsmpi_type_f2c), smpi_win_f2c(*win)); } void mpi_accumulate_( int *origin_addr, int* origin_count, int* origin_datatype, int *target_rank, MPI_Aint* target_disp, int *target_count, int* tarsmpi_type_f2c, int* op, int* win, int* ierr){ - *ierr = MPI_Accumulate( (void*)origin_addr,*origin_count, smpi_type_f2c(*origin_datatype),*target_rank, + *ierr = MPI_Accumulate( static_cast(origin_addr),*origin_count, smpi_type_f2c(*origin_datatype),*target_rank, *target_disp, *target_count,smpi_type_f2c(*tarsmpi_type_f2c), smpi_op_f2c(*op), smpi_win_f2c(*win)); } void mpi_put_( int *origin_addr, int* origin_count, int* origin_datatype, int *target_rank, MPI_Aint* target_disp, int *target_count, int* tarsmpi_type_f2c, int* win, int* ierr){ - *ierr = MPI_Put( (void*)origin_addr,*origin_count, smpi_type_f2c(*origin_datatype),*target_rank, + *ierr = MPI_Put( static_cast(origin_addr),*origin_count, smpi_type_f2c(*origin_datatype),*target_rank, *target_disp, *target_count,smpi_type_f2c(*tarsmpi_type_f2c), smpi_win_f2c(*win)); } @@ -874,7 +884,8 @@ void mpi_type_set_name_ (int* datatype, char * name, int* ierr, int size){ void mpi_type_get_name_ (int* datatype, char * name, int* len, int* ierr){ *ierr = MPI_Type_get_name(smpi_type_f2c(*datatype),name,len); - if(*len>0) name[*len]=' '; + if(*len>0) + name[*len]=' '; } void mpi_type_get_attr_ (int* type, int* type_keyval, void *attribute_val, int* flag, int* ierr){ @@ -894,7 +905,7 @@ void mpi_type_delete_attr_ (int* type, int* type_keyval, int* ierr){ void mpi_type_create_keyval_ (void* copy_fn, void* delete_fn, int* keyval, void* extra_state, int* ierr){ - *ierr = MPI_Type_create_keyval((MPI_Type_copy_attr_function*)copy_fn, (MPI_Type_delete_attr_function*) delete_fn, + *ierr = MPI_Type_create_keyval(reinterpret_cast(copy_fn), reinterpret_cast(delete_fn), keyval, extra_state) ; } @@ -903,7 +914,7 @@ void mpi_type_free_keyval_ (int* keyval, int* ierr) { } void mpi_pcontrol_ (int* level , int* ierr){ - *ierr = MPI_Pcontrol(*(const int*)level); + *ierr = MPI_Pcontrol(*static_cast(level)); } void mpi_type_get_extent_ (int* datatype, MPI_Aint * lb, MPI_Aint * extent, int* ierr){ @@ -918,7 +929,7 @@ void mpi_type_get_true_extent_ (int* datatype, MPI_Aint * lb, MPI_Aint * extent, void mpi_op_create_ (void * function, int* commute, int* op, int* ierr){ MPI_Op tmp; - *ierr = MPI_Op_create((MPI_User_function*)function,* commute, &tmp); + *ierr = MPI_Op_create(reinterpret_cast(function),*commute, &tmp); if(*ierr == MPI_SUCCESS) { *op = smpi_op_c2f(tmp); } @@ -1028,7 +1039,7 @@ void mpi_comm_delete_attr_ (int* comm, int* comm_keyval, int* ierr){ void mpi_comm_create_keyval_ (void* copy_fn, void* delete_fn, int* keyval, void* extra_state, int* ierr){ - *ierr = MPI_Comm_create_keyval((MPI_Comm_copy_attr_function*)copy_fn, (MPI_Comm_delete_attr_function*)delete_fn, + *ierr = MPI_Comm_create_keyval(reinterpret_cast(copy_fn), reinterpret_cast(delete_fn), keyval, extra_state) ; } @@ -1038,7 +1049,8 @@ void mpi_comm_free_keyval_ (int* keyval, int* ierr) { void mpi_comm_get_name_ (int* comm, char* name, int* len, int* ierr){ *ierr = MPI_Comm_get_name(smpi_comm_f2c(*comm), name, len); - if(*len>0) name[*len]=' '; + if(*len>0) + name[*len]=' '; } void mpi_comm_compare_ (int* comm1, int* comm2, int *result, int* ierr){ @@ -1079,12 +1091,11 @@ void mpi_testany_ (int* count, int* requests, int *index, int *flag, MPI_Status* reqs[i] = smpi_request_f2c(requests[i]); } *ierr = MPI_Testany(*count, reqs, index, flag, FORT_STATUS_IGNORE(status)); - if(*index!=MPI_UNDEFINED) - if(reqs[*index]==MPI_REQUEST_NULL){ + if(*index!=MPI_UNDEFINED && reqs[*index]==MPI_REQUEST_NULL){ free_request(requests[*index]); requests[*index]=MPI_FORTRAN_REQUEST_NULL; } - free(reqs); + xbt_free(reqs); } void mpi_waitsome_ (int* incount, int* requests, int *outcount, int *indices, MPI_Status* status, int* ierr) @@ -1103,7 +1114,7 @@ void mpi_waitsome_ (int* incount, int* requests, int *outcount, int *indices, MP requests[indices[i]]=MPI_FORTRAN_REQUEST_NULL; } } - free(reqs); + xbt_free(reqs); } void mpi_reduce_local_ (void *inbuf, void *inoutbuf, int* count, int* datatype, int* op, int* ierr){ @@ -1114,7 +1125,7 @@ void mpi_reduce_local_ (void *inbuf, void *inoutbuf, int* count, int* datatype, void mpi_reduce_scatter_block_ (void *sendbuf, void *recvbuf, int* recvcount, int* datatype, int* op, int* comm, int* ierr) { - sendbuf = (char *) FORT_IN_PLACE(sendbuf); + sendbuf = static_cast( FORT_IN_PLACE(sendbuf)); *ierr = MPI_Reduce_scatter_block(sendbuf, recvbuf, *recvcount, smpi_type_f2c(*datatype), smpi_op_f2c(*op), smpi_comm_f2c(*comm)); } @@ -1200,27 +1211,27 @@ void mpi_error_class_ (int* errorcode, int* errorclass, int* ierr) { } void mpi_errhandler_create_ (void* function, void* errhandler, int* ierr) { - *ierr = MPI_Errhandler_create((MPI_Handler_function*)function, (MPI_Errhandler*)errhandler); + *ierr = MPI_Errhandler_create(reinterpret_cast(function), static_cast(errhandler)); } void mpi_errhandler_free_ (void* errhandler, int* ierr) { - *ierr = MPI_Errhandler_free((MPI_Errhandler*)errhandler); + *ierr = MPI_Errhandler_free(static_cast(errhandler)); } void mpi_errhandler_get_ (int* comm, void* errhandler, int* ierr) { - *ierr = MPI_Errhandler_get(smpi_comm_f2c(*comm), (MPI_Errhandler*) errhandler); + *ierr = MPI_Errhandler_get(smpi_comm_f2c(*comm), static_cast(errhandler)); } void mpi_errhandler_set_ (int* comm, void* errhandler, int* ierr) { - *ierr = MPI_Errhandler_set(smpi_comm_f2c(*comm), *(MPI_Errhandler*)errhandler); + *ierr = MPI_Errhandler_set(smpi_comm_f2c(*comm), *static_cast(errhandler)); } void mpi_comm_set_errhandler_ (int* comm, void* errhandler, int* ierr) { - *ierr = MPI_Errhandler_set(smpi_comm_f2c(*comm), *(MPI_Errhandler*)errhandler); + *ierr = MPI_Errhandler_set(smpi_comm_f2c(*comm), *static_cast(errhandler)); } void mpi_comm_get_errhandler_ (int* comm, void* errhandler, int* ierr) { - *ierr = MPI_Errhandler_set(smpi_comm_f2c(*comm), (MPI_Errhandler*)errhandler); + *ierr = MPI_Errhandler_set(smpi_comm_f2c(*comm), static_cast(errhandler)); } void mpi_type_contiguous_ (int* count, int* old_type, int* newtype, int* ierr) { @@ -1255,14 +1266,12 @@ void mpi_testsome_ (int* incount, int* requests, int* outcount, int* indices, M } *ierr = MPI_Testsome(*incount, reqs, outcount, indices, FORT_STATUSES_IGNORE(statuses)); for(i=0;i<*incount;i++){ - if(indices[i]){ - if(reqs[indices[i]]==MPI_REQUEST_NULL){ - free_request(requests[indices[i]]); - requests[indices[i]]=MPI_FORTRAN_REQUEST_NULL; - } + if(indices[i] && reqs[indices[i]]==MPI_REQUEST_NULL){ + free_request(requests[indices[i]]); + requests[indices[i]]=MPI_FORTRAN_REQUEST_NULL; } } - free(reqs); + xbt_free(reqs); } void mpi_comm_test_inter_ (int* comm, int* flag, int* ierr) { @@ -1333,7 +1342,7 @@ void mpi_type_create_indexed_block_ (int* count, int* blocklength, int* indices, void mpi_type_struct_ (int* count, int* blocklens, MPI_Aint* indices, int* old_types, int* newtype, int* ierr) { MPI_Datatype tmp; int i=0; - MPI_Datatype* types = (MPI_Datatype*)xbt_malloc(*count*sizeof(MPI_Datatype)); + MPI_Datatype* types = static_cast(xbt_malloc(*count*sizeof(MPI_Datatype))); for(i=0; i< *count; i++){ types[i] = smpi_type_f2c(old_types[i]); } @@ -1347,7 +1356,7 @@ void mpi_type_struct_ (int* count, int* blocklens, MPI_Aint* indices, int* old_t void mpi_type_create_struct_(int* count, int* blocklens, MPI_Aint* indices, int* old_types, int* newtype, int* ierr){ MPI_Datatype tmp; int i=0; - MPI_Datatype* types = (MPI_Datatype*)xbt_malloc(*count*sizeof(MPI_Datatype)); + MPI_Datatype* types = static_cast(xbt_malloc(*count*sizeof(MPI_Datatype))); for(i=0; i< *count; i++){ types[i] = smpi_type_f2c(old_types[i]); } @@ -1449,7 +1458,7 @@ void mpi_rsend_init_ (void* buf, int* count, int* datatype, int *dest, int* tag, } void mpi_keyval_create_ (void* copy_fn, void* delete_fn, int* keyval, void* extra_state, int* ierr) { - *ierr = MPI_Keyval_create((MPI_Copy_function*)copy_fn, (MPI_Delete_function*)delete_fn, keyval, extra_state); + *ierr = MPI_Keyval_create(reinterpret_cast(copy_fn),reinterpret_cast(delete_fn), keyval, extra_state); } void mpi_keyval_free_ (int* keyval, int* ierr) { @@ -1486,7 +1495,7 @@ void mpi_type_get_contents_ (int* datatype, int* max_integers, int* max_addresse int* array_of_integers, MPI_Aint* array_of_addresses, int* array_of_datatypes, int* ierr){ *ierr = MPI_Type_get_contents(smpi_type_f2c(*datatype), *max_integers, *max_addresses,*max_datatypes, - array_of_integers, array_of_addresses, (MPI_Datatype*)array_of_datatypes); + array_of_integers, array_of_addresses, reinterpret_cast(array_of_datatypes)); } void mpi_type_create_darray_ (int* size, int* rank, int* ndims, int* array_of_gsizes, int* array_of_distribs, @@ -1529,8 +1538,8 @@ void mpi_type_match_size_ (int* typeclass,int* size,int* datatype, int* ierr){ void mpi_alltoallw_ ( void *sendbuf, int *sendcnts, int *sdispls, int* sendtypes, void *recvbuf, int *recvcnts, int *rdispls, int* recvtypes, int* comm, int* ierr){ - *ierr = MPI_Alltoallw( sendbuf, sendcnts, sdispls, (MPI_Datatype*) sendtypes, recvbuf, recvcnts, rdispls, - (MPI_Datatype*)recvtypes, smpi_comm_f2c(*comm)); + *ierr = MPI_Alltoallw( sendbuf, sendcnts, sdispls, reinterpret_cast(sendtypes), recvbuf, recvcnts, rdispls, + reinterpret_cast(recvtypes), smpi_comm_f2c(*comm)); } void mpi_exscan_ (void *sendbuf, void *recvbuf, int* count, int* datatype, int* op, int* comm, int* ierr){ @@ -1574,7 +1583,7 @@ void mpi_comm_get_info_ (int* comm, int* info, int* ierr){ } void mpi_comm_create_errhandler_ ( void *function, void *errhandler, int* ierr){ - *ierr = MPI_Comm_create_errhandler( (MPI_Comm_errhandler_fn*) function, (MPI_Errhandler*)errhandler); + *ierr = MPI_Comm_create_errhandler( reinterpret_cast(function), static_cast(errhandler)); } void mpi_add_error_class_ ( int *errorclass, int* ierr){ @@ -1602,29 +1611,31 @@ void mpi_info_dup_ (int* info, int* newinfo, int* ierr){ } void mpi_info_get_valuelen_ ( int* info, char *key, int *valuelen, int *flag, int* ierr, unsigned int keylen){ - while(key[keylen-1]==' ')keylen--; - while(*key==' '){//handle leading blanks - keylen --; - key++; - } - char* tkey = xbt_new(char, keylen+1); - strncpy(tkey, key, keylen); - tkey[keylen]='\0'; - *ierr = MPI_Info_get_valuelen( smpi_info_f2c(*info), tkey, valuelen, flag); - xbt_free(tkey); + while(key[keylen-1]==' ') + keylen--; + while(*key==' '){//handle leading blanks + keylen--; + key++; + } + char* tkey = xbt_new(char, keylen+1); + strncpy(tkey, key, keylen); + tkey[keylen]='\0'; + *ierr = MPI_Info_get_valuelen( smpi_info_f2c(*info), tkey, valuelen, flag); + xbt_free(tkey); } void mpi_info_delete_ (int* info, char *key, int* ierr, unsigned int keylen){ - while(key[keylen-1]==' ')keylen--; - while(*key==' '){//handle leading blanks - keylen --; - key++; - } - char* tkey = xbt_new(char, keylen+1); - strncpy(tkey, key, keylen); - tkey[keylen]='\0'; - *ierr = MPI_Info_delete(smpi_info_f2c(*info), tkey); - xbt_free(tkey); + while(key[keylen-1]==' ') + keylen--; + while(*key==' '){//handle leading blanks + keylen--; + key++; + } + char* tkey = xbt_new(char, keylen+1); + strncpy(tkey, key, keylen); + tkey[keylen]='\0'; + *ierr = MPI_Info_delete(smpi_info_f2c(*info), tkey); + xbt_free(tkey); } void mpi_info_get_nkeys_ ( int* info, int *nkeys, int* ierr){ @@ -1632,10 +1643,10 @@ void mpi_info_get_nkeys_ ( int* info, int *nkeys, int* ierr){ } void mpi_info_get_nthkey_ ( int* info, int* n, char *key, int* ierr, unsigned int keylen){ - *ierr = MPI_Info_get_nthkey( smpi_info_f2c(*info), *n, key); - unsigned int i = 0; - for (i=strlen(key); i(query_fn), reinterpret_cast(free_fn), + reinterpret_cast(cancel_fn), extra_state, &tmp); if(*ierr == MPI_SUCCESS) { *request = smpi_request_c2f(tmp); } @@ -1673,22 +1684,22 @@ void mpi_status_set_elements_ ( MPI_Status* status, int* datatype, int* count, i void mpi_comm_connect_ ( char *port_name, int* info, int* root, int* comm, int*newcomm, int* ierr){ MPI_Comm tmp; - *ierr = MPI_Comm_connect( port_name, *(MPI_Info*)info, *root, smpi_comm_f2c(*comm), &tmp); + *ierr = MPI_Comm_connect( port_name, *reinterpret_cast(info), *root, smpi_comm_f2c(*comm), &tmp); if(*ierr == MPI_SUCCESS) { *newcomm = smpi_comm_c2f(tmp); } } void mpi_publish_name_ ( char *service_name, int* info, char *port_name, int* ierr){ - *ierr = MPI_Publish_name( service_name, *(MPI_Info*)info, port_name); + *ierr = MPI_Publish_name( service_name, *reinterpret_cast(info), port_name); } void mpi_unpublish_name_ ( char *service_name, int* info, char *port_name, int* ierr){ - *ierr = MPI_Unpublish_name( service_name, *(MPI_Info*)info, port_name); + *ierr = MPI_Unpublish_name( service_name, *reinterpret_cast(info), port_name); } void mpi_lookup_name_ ( char *service_name, int* info, char *port_name, int* ierr){ - *ierr = MPI_Lookup_name( service_name, *(MPI_Info*)info, port_name); + *ierr = MPI_Lookup_name( service_name, *reinterpret_cast(info), port_name); } void mpi_comm_join_ ( int* fd, int* intercomm, int* ierr){ @@ -1700,7 +1711,7 @@ void mpi_comm_join_ ( int* fd, int* intercomm, int* ierr){ } void mpi_open_port_ ( int* info, char *port_name, int* ierr){ - *ierr = MPI_Open_port( *(MPI_Info*)info,port_name); + *ierr = MPI_Open_port( *reinterpret_cast(info),port_name); } void mpi_close_port_ ( char *port_name, int* ierr){ @@ -1709,7 +1720,7 @@ void mpi_close_port_ ( char *port_name, int* ierr){ void mpi_comm_accept_ ( char *port_name, int* info, int* root, int* comm, int*newcomm, int* ierr){ MPI_Comm tmp; - *ierr = MPI_Comm_accept( port_name, *(MPI_Info*)info, *root, smpi_comm_f2c(*comm), &tmp); + *ierr = MPI_Comm_accept( port_name, *reinterpret_cast(info), *root, smpi_comm_f2c(*comm), &tmp); if(*ierr == MPI_SUCCESS) { *newcomm = smpi_comm_c2f(tmp); } @@ -1718,7 +1729,7 @@ void mpi_comm_accept_ ( char *port_name, int* info, int* root, int* comm, int*ne void mpi_comm_spawn_ ( char *command, char *argv, int* maxprocs, int* info, int* root, int* comm, int* intercomm, int* array_of_errcodes, int* ierr){ MPI_Comm tmp; - *ierr = MPI_Comm_spawn( command, NULL, *maxprocs, *(MPI_Info*)info, *root, smpi_comm_f2c(*comm), &tmp, + *ierr = MPI_Comm_spawn( command, NULL, *maxprocs, *reinterpret_cast(info), *root, smpi_comm_f2c(*comm), &tmp, array_of_errcodes); if(*ierr == MPI_SUCCESS) { *intercomm = smpi_comm_c2f(tmp); @@ -1730,7 +1741,7 @@ void mpi_comm_spawn_multiple_ ( int* count, char *array_of_commands, char** arra int* comm, int* intercomm, int* array_of_errcodes, int* ierr){ MPI_Comm tmp; *ierr = MPI_Comm_spawn_multiple(* count, &array_of_commands, &array_of_argv, array_of_maxprocs, - (MPI_Info*)array_of_info, *root, smpi_comm_f2c(*comm), &tmp, array_of_errcodes); + reinterpret_cast(array_of_info), *root, smpi_comm_f2c(*comm), &tmp, array_of_errcodes); if(*ierr == MPI_SUCCESS) { *intercomm = smpi_comm_c2f(tmp); } diff --git a/src/smpi/smpi_global.cpp b/src/smpi/smpi_global.cpp index e2bc34462d..1a008f954b 100644 --- a/src/smpi/smpi_global.cpp +++ b/src/smpi/smpi_global.cpp @@ -67,13 +67,13 @@ MPI_Errhandler *MPI_ERRHANDLER_NULL = NULL; static char *get_mailbox_name(char *str, int index) { - snprintf(str, MAILBOX_NAME_MAXLEN, "SMPI-%0*x", (int) (sizeof(int) * 2), index); + snprintf(str, MAILBOX_NAME_MAXLEN, "SMPI-%0*x", static_cast (sizeof(int) * 2), index); return str; } static char *get_mailbox_name_small(char *str, int index) { - snprintf(str, MAILBOX_NAME_MAXLEN, "small%0*x", (int) (sizeof(int) * 2), index); + snprintf(str, MAILBOX_NAME_MAXLEN, "small%0*x", static_cast (sizeof(int) * 2), index); return str; } @@ -83,16 +83,15 @@ void smpi_process_init(int *argc, char ***argv) smpi_process_data_t data; smx_process_t proc; - if (argc && argv) { + if (argc != NULL && argv != NULL) { proc = SIMIX_process_self(); - //FIXME: dirty cleanup method to avoid using msg cleanup functions on these processes when using MSG+SMPI SIMIX_process_set_cleanup_function(proc, MSG_process_cleanup_from_SIMIX); char* instance_id = (*argv)[1]; int rank = xbt_str_parse_int((*argv)[2], "Invalid rank: %s"); index = smpi_process_index_of_smx_process(proc); - if(!index_to_process_data){ - index_to_process_data=(int*)xbt_malloc(SIMIX_process_count()*sizeof(int)); + if(index_to_process_data == NULL){ + index_to_process_data=static_cast(xbt_malloc(SIMIX_process_count()*sizeof(int))); } if(smpi_privatize_global_variables){ @@ -107,11 +106,11 @@ void smpi_process_init(int *argc, char ***argv) smpi_deployment_register_process(instance_id, rank, index, &temp_comm_world, &temp_bar); data = smpi_process_remote_data(index); data->comm_world = temp_comm_world; - if(temp_bar != NULL) data->finalization_barrier = temp_bar; + if(temp_bar != NULL) + data->finalization_barrier = temp_bar; data->index = index; data->instance_id = instance_id; data->replaying = false; - //xbt_free(simcall_process_get_data(proc)); simdata_process_t simdata = static_cast(simcall_process_get_data(proc)); simdata->data = data; @@ -134,7 +133,7 @@ void smpi_process_init(int *argc, char ***argv) "MPI-2, this is currently not supported by SMPI."); } -void smpi_process_destroy(void) +void smpi_process_destroy() { int index = smpi_process_index(); if(smpi_privatize_global_variables){ @@ -145,7 +144,7 @@ void smpi_process_destroy(void) } /** @brief Prepares the current process for termination. */ -void smpi_process_finalize(void) +void smpi_process_finalize() { // This leads to an explosion of the search graph which cannot be reduced: if(MC_is_active() || MC_record_replay_is_active()) @@ -167,9 +166,9 @@ int smpi_process_finalized() } /** @brief Check if a process is initialized */ -int smpi_process_initialized(void) +int smpi_process_initialized() { - if (!index_to_process_data){ + if (index_to_process_data == NULL){ return false; } else{ int index = smpi_process_index(); @@ -178,7 +177,7 @@ int smpi_process_initialized(void) } /** @brief Mark a process as initialized (=MPI_Init called) */ -void smpi_process_mark_as_initialized(void) +void smpi_process_mark_as_initialized() { int index = smpi_process_index(); if ((index != MPI_UNDEFINED) && (process_data[index_to_process_data[index]]->state != SMPI_FINALIZED)) @@ -198,7 +197,7 @@ bool smpi_process_get_replaying(){ else return (_xbt_replay_is_active() != 0); } -int smpi_global_size(void) +int smpi_global_size() { char *value = getenv("SMPI_GLOBAL_SIZE"); xbt_assert(value,"Please set env var SMPI_GLOBAL_SIZE to the expected number of processes."); @@ -206,7 +205,7 @@ int smpi_global_size(void) return xbt_str_parse_int(value, "SMPI_GLOBAL_SIZE contains a non-numerical value: %s"); } -smpi_process_data_t smpi_process_data(void) +smpi_process_data_t smpi_process_data() { simdata_process_t simdata = static_cast(SIMIX_process_self_get_data()); return static_cast(simdata->data); @@ -229,7 +228,7 @@ void *smpi_process_get_user_data() return process_data->data; } -int smpi_process_count(void) +int smpi_process_count() { return process_count; } @@ -240,39 +239,39 @@ int smpi_process_count(void) * * \see smpi_trace_set_call_location */ -smpi_trace_call_location_t* smpi_process_get_call_location(void) +smpi_trace_call_location_t* smpi_process_get_call_location() { smpi_process_data_t process_data = smpi_process_data(); return process_data->trace_call_loc; } -int smpi_process_index(void) +int smpi_process_index() { smpi_process_data_t data = smpi_process_data(); //return -1 if not initialized - return data ? data->index : MPI_UNDEFINED; + return data != NULL ? data->index : MPI_UNDEFINED; } -MPI_Comm smpi_process_comm_world(void) +MPI_Comm smpi_process_comm_world() { smpi_process_data_t data = smpi_process_data(); //return MPI_COMM_NULL if not initialized - return data ? *data->comm_world : MPI_COMM_NULL; + return data != NULL ? *data->comm_world : MPI_COMM_NULL; } -smx_mailbox_t smpi_process_mailbox(void) +smx_mailbox_t smpi_process_mailbox() { smpi_process_data_t data = smpi_process_data(); return data->mailbox; } -smx_mailbox_t smpi_process_mailbox_small(void) +smx_mailbox_t smpi_process_mailbox_small() { smpi_process_data_t data = smpi_process_data(); return data->mailbox_small; } -xbt_mutex_t smpi_process_mailboxes_mutex(void) +xbt_mutex_t smpi_process_mailboxes_mutex() { smpi_process_data_t data = smpi_process_data(); return data->mailboxes_mutex; @@ -296,25 +295,25 @@ xbt_mutex_t smpi_process_remote_mailboxes_mutex(int index) return data->mailboxes_mutex; } -xbt_os_timer_t smpi_process_timer(void) +xbt_os_timer_t smpi_process_timer() { smpi_process_data_t data = smpi_process_data(); return data->timer; } -void smpi_process_simulated_start(void) +void smpi_process_simulated_start() { smpi_process_data_t data = smpi_process_data(); data->simulated = SIMIX_get_clock(); } -double smpi_process_simulated_elapsed(void) +double smpi_process_simulated_elapsed() { smpi_process_data_t data = smpi_process_data(); return SIMIX_get_clock() - data->simulated; } -MPI_Comm smpi_process_comm_self(void) +MPI_Comm smpi_process_comm_self() { smpi_process_data_t data = smpi_process_data(); if(data->comm_self==MPI_COMM_NULL){ @@ -326,7 +325,7 @@ MPI_Comm smpi_process_comm_self(void) return data->comm_self; } -MPI_Comm smpi_process_get_comm_intra(void) +MPI_Comm smpi_process_get_comm_intra() { smpi_process_data_t data = smpi_process_data(); return data->comm_intra; @@ -344,7 +343,7 @@ void smpi_process_set_sampling(int s) data->sampling = s; } -int smpi_process_get_sampling(void) +int smpi_process_get_sampling() { smpi_process_data_t data = smpi_process_data(); return data->sampling; @@ -362,21 +361,21 @@ void smpi_comm_copy_buffer_callback(smx_synchro_t synchro, void *buff, size_t bu void* tmpbuff=buff; simgrid::simix::Comm *comm = dynamic_cast(synchro); - if((smpi_privatize_global_variables) && ((char*)buff >= smpi_start_data_exe) - && ((char*)buff < smpi_start_data_exe + smpi_size_data_exe ) + if((smpi_privatize_global_variables) && (static_cast(buff) >= smpi_start_data_exe) + && (static_cast(buff) < smpi_start_data_exe + smpi_size_data_exe ) ){ XBT_DEBUG("Privatization : We are copying from a zone inside global memory... Saving data to temp buffer !"); - smpi_switch_data_segment(((smpi_process_data_t)(((simdata_process_t)SIMIX_process_get_data(comm->src_proc))->data))->index); - tmpbuff = (void*)xbt_malloc(buff_size); + smpi_switch_data_segment((static_cast((static_cast(SIMIX_process_get_data(comm->src_proc))->data))->index)); + tmpbuff = static_cast(xbt_malloc(buff_size)); memcpy(tmpbuff, buff, buff_size); } if((smpi_privatize_global_variables) && ((char*)comm->dst_buff >= smpi_start_data_exe) && ((char*)comm->dst_buff < smpi_start_data_exe + smpi_size_data_exe )){ XBT_DEBUG("Privatization : We are copying to a zone inside global memory - Switch data segment"); - smpi_switch_data_segment(((smpi_process_data_t)(((simdata_process_t)SIMIX_process_get_data(comm->dst_proc))->data))->index); + smpi_switch_data_segment((static_cast((static_cast(SIMIX_process_get_data(comm->dst_proc))->data))->index)); } memcpy(comm->dst_buff, tmpbuff, buff_size); @@ -410,11 +409,11 @@ static void smpi_check_options(){ } } -int smpi_enabled(void) { +int smpi_enabled() { return process_data != NULL; } -void smpi_global_init(void) +void smpi_global_init() { int i; MPI_Group group; @@ -455,7 +454,6 @@ void smpi_global_init(void) process_data = xbt_new0(smpi_process_data_t, process_count); for (i = 0; i < process_count; i++) { process_data[i] = xbt_new(s_smpi_process_data_t, 1); - //process_data[i]->index = i; process_data[i]->argc = NULL; process_data[i]->argv = NULL; process_data[i]->mailbox = simcall_mbox_create(get_mailbox_name(name, i)); @@ -481,7 +479,7 @@ void smpi_global_init(void) if(smpirun){ group = smpi_group_new(process_count); MPI_COMM_WORLD = smpi_comm_new(group, NULL); - MPI_Attr_put(MPI_COMM_WORLD, MPI_UNIVERSE_SIZE, (void *)(MPI_Aint)process_count); + MPI_Attr_put(MPI_COMM_WORLD, MPI_UNIVERSE_SIZE, reinterpret_cast(process_count)); xbt_bar_t bar=xbt_barrier_init(process_count); for (i = 0; i < process_count; i++) { @@ -491,7 +489,7 @@ void smpi_global_init(void) } } -void smpi_global_destroy(void) +void smpi_global_destroy() { int count = smpi_process_count(); int i; @@ -597,55 +595,55 @@ static void smpi_init_logs(){ static void smpi_init_options(){ int gather_id = find_coll_description(mpi_coll_gather_description, xbt_cfg_get_string("smpi/gather"),"gather"); - mpi_coll_gather_fun = (int (*)(void *, int, MPI_Datatype, void *, int, MPI_Datatype, int, MPI_Comm)) - mpi_coll_gather_description[gather_id].coll; + mpi_coll_gather_fun = reinterpret_cast + (mpi_coll_gather_description[gather_id].coll); int allgather_id = find_coll_description(mpi_coll_allgather_description, xbt_cfg_get_string("smpi/allgather"),"allgather"); - mpi_coll_allgather_fun = (int (*)(void *, int, MPI_Datatype, void *, int, MPI_Datatype, MPI_Comm)) - mpi_coll_allgather_description[allgather_id].coll; + mpi_coll_allgather_fun = reinterpret_cast + (mpi_coll_allgather_description[allgather_id].coll); int allgatherv_id = find_coll_description(mpi_coll_allgatherv_description, xbt_cfg_get_string("smpi/allgatherv"),"allgatherv"); - mpi_coll_allgatherv_fun = (int (*)(void *, int, MPI_Datatype, void *, int *, int *, MPI_Datatype, MPI_Comm)) - mpi_coll_allgatherv_description[allgatherv_id].coll; + mpi_coll_allgatherv_fun = reinterpret_cast + (mpi_coll_allgatherv_description[allgatherv_id].coll); int allreduce_id = find_coll_description(mpi_coll_allreduce_description, xbt_cfg_get_string("smpi/allreduce"),"allreduce"); - mpi_coll_allreduce_fun = (int (*)(void *sbuf, void *rbuf, int rcount, MPI_Datatype dtype, MPI_Op op, MPI_Comm comm)) - mpi_coll_allreduce_description[allreduce_id].coll; + mpi_coll_allreduce_fun = reinterpret_cast + (mpi_coll_allreduce_description[allreduce_id].coll); int alltoall_id = find_coll_description(mpi_coll_alltoall_description, xbt_cfg_get_string("smpi/alltoall"),"alltoall"); - mpi_coll_alltoall_fun = (int (*)(void *, int, MPI_Datatype, void *, int, MPI_Datatype, MPI_Comm)) - mpi_coll_alltoall_description[alltoall_id].coll; + mpi_coll_alltoall_fun = reinterpret_cast + (mpi_coll_alltoall_description[alltoall_id].coll); int alltoallv_id = find_coll_description(mpi_coll_alltoallv_description, xbt_cfg_get_string("smpi/alltoallv"),"alltoallv"); - mpi_coll_alltoallv_fun = (int (*)(void *, int *, int *, MPI_Datatype, void *, int *, int *, MPI_Datatype, MPI_Comm)) - mpi_coll_alltoallv_description[alltoallv_id].coll; + mpi_coll_alltoallv_fun = reinterpret_cast + (mpi_coll_alltoallv_description[alltoallv_id].coll); int bcast_id = find_coll_description(mpi_coll_bcast_description, xbt_cfg_get_string("smpi/bcast"),"bcast"); - mpi_coll_bcast_fun = (int (*)(void *buf, int count, MPI_Datatype datatype, int root, MPI_Comm com)) - mpi_coll_bcast_description[bcast_id].coll; + mpi_coll_bcast_fun = reinterpret_cast + (mpi_coll_bcast_description[bcast_id].coll); int reduce_id = find_coll_description(mpi_coll_reduce_description, xbt_cfg_get_string("smpi/reduce"),"reduce"); - mpi_coll_reduce_fun = (int (*)(void *buf, void *rbuf, int count, MPI_Datatype datatype, MPI_Op op, int root, - MPI_Comm comm)) mpi_coll_reduce_description[reduce_id].coll; + mpi_coll_reduce_fun = reinterpret_cast + (mpi_coll_reduce_description[reduce_id].coll); int reduce_scatter_id = find_coll_description(mpi_coll_reduce_scatter_description, xbt_cfg_get_string("smpi/reduce-scatter"),"reduce_scatter"); - mpi_coll_reduce_scatter_fun = (int (*)(void *sbuf, void *rbuf, int *rcounts,MPI_Datatype dtype, MPI_Op op, - MPI_Comm comm)) mpi_coll_reduce_scatter_description[reduce_scatter_id].coll; + mpi_coll_reduce_scatter_fun = reinterpret_cast + (mpi_coll_reduce_scatter_description[reduce_scatter_id].coll); int scatter_id = find_coll_description(mpi_coll_scatter_description, xbt_cfg_get_string("smpi/scatter"),"scatter"); - mpi_coll_scatter_fun = (int (*)(void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, - int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm)) - mpi_coll_scatter_description[scatter_id].coll; + mpi_coll_scatter_fun = reinterpret_cast + (mpi_coll_scatter_description[scatter_id].coll); int barrier_id = find_coll_description(mpi_coll_barrier_description, xbt_cfg_get_string("smpi/barrier"),"barrier"); - mpi_coll_barrier_fun = (int (*)(MPI_Comm comm)) mpi_coll_barrier_description[barrier_id].coll; + mpi_coll_barrier_fun = reinterpret_cast + (mpi_coll_barrier_description[barrier_id].coll); smpi_coll_cleanup_callback=NULL; smpi_cpu_threshold = xbt_cfg_get_double("smpi/cpu-threshold"); diff --git a/src/smpi/smpi_group.cpp b/src/smpi/smpi_group.cpp index ea72ca5d0e..36e94c0664 100644 --- a/src/smpi/smpi_group.cpp +++ b/src/smpi/smpi_group.cpp @@ -62,8 +62,8 @@ MPI_Group smpi_group_copy(MPI_Group origin) } xbt_dict_foreach(origin->index_to_rank_map, cursor, key, ptr_rank) { - int * cp = (int*)xbt_malloc(sizeof(int)); - *cp=*(int*)ptr_rank; + int * cp = static_cast(xbt_malloc(sizeof(int))); + *cp=*reinterpret_cast(ptr_rank); xbt_dict_set(group->index_to_rank_map, key, cp, NULL); } } @@ -86,12 +86,12 @@ void smpi_group_set_mapping(MPI_Group group, int index, int rank) if (rank < group->size) { group->rank_to_index_map[rank] = index; if (index!=MPI_UNDEFINED ) { - val_rank = (int *) malloc(sizeof(int)); + val_rank = static_cast(xbt_malloc(sizeof(int))); *val_rank = rank; char * key = bprintf("%d", index); xbt_dict_set(group->index_to_rank_map, key, val_rank, NULL); - free(key); + xbt_free(key); } } } diff --git a/src/smpi/smpi_mpi_dt.cpp b/src/smpi/smpi_mpi_dt.cpp index 6e6410f279..25f4454d2e 100644 --- a/src/smpi/smpi_mpi_dt.cpp +++ b/src/smpi/smpi_mpi_dt.cpp @@ -1,6 +1,4 @@ -/* smpi_mpi_dt.c -- MPI primitives to handle datatypes */ -/* FIXME: a very incomplete implementation */ - +/* smpi_mpi_dt.c -- MPI primitives to handle datatypes */ /* Copyright (c) 2009-2015. The SimGrid Team. * All rights reserved. */ @@ -154,8 +152,8 @@ CREATE_MPI_DATATYPE(MPI_PACKED, char); CREATE_MPI_DATATYPE(MPI_PTR, void*); /** Check if the datatype is usable for communications */ -int is_datatype_valid(MPI_Datatype datatype) { - return datatype != MPI_DATATYPE_NULL && (datatype->flags & DT_FLAG_COMMITED); +bool is_datatype_valid(MPI_Datatype datatype) { + return datatype != MPI_DATATYPE_NULL && ((datatype->flags & DT_FLAG_COMMITED) != 0); } size_t smpi_datatype_size(MPI_Datatype datatype) @@ -195,8 +193,8 @@ int smpi_datatype_dup(MPI_Datatype datatype, MPI_Datatype* new_t) void* value_out; xbt_dict_foreach(datatype->attributes, cursor, key, value_in){ smpi_type_key_elem elem = - static_cast(xbt_dict_get_or_null_ext(smpi_type_keyvals, (const char*)key, sizeof(int))); - if(elem && elem->copy_fn!=MPI_NULL_COPY_FN){ + static_cast(xbt_dict_get_or_null_ext(smpi_type_keyvals, reinterpret_cast(key), sizeof(int))); + if(elem != NULL && elem->copy_fn!=MPI_NULL_COPY_FN){ ret = elem->copy_fn(datatype, *key, NULL, value_in, &value_out, &flag ); if(ret!=MPI_SUCCESS){ smpi_datatype_unuse(*new_t); @@ -205,7 +203,7 @@ int smpi_datatype_dup(MPI_Datatype datatype, MPI_Datatype* new_t) return ret; } if(flag) - xbt_dict_set_ext((*new_t)->attributes, (const char*)key, sizeof(int),value_out, NULL); + xbt_dict_set_ext((*new_t)->attributes, reinterpret_cast(key), sizeof(int),value_out, NULL); } } } @@ -233,13 +231,13 @@ MPI_Aint smpi_datatype_get_extent(MPI_Datatype datatype){ void smpi_datatype_get_name(MPI_Datatype datatype, char* name, int* length){ *length = strlen(datatype->name); - strcpy(name, datatype->name); + strncpy(name, datatype->name, *length+1); } void smpi_datatype_set_name(MPI_Datatype datatype, char* name){ - if(datatype->name!=NULL && !(datatype->flags & DT_FLAG_PREDEFINED)) + if(datatype->name!=NULL && (datatype->flags & DT_FLAG_PREDEFINED) == 0) xbt_free(datatype->name); - datatype->name = xbt_strdup(name);; + datatype->name = xbt_strdup(name); } int smpi_datatype_copy(void *sendbuf, int sendcount, MPI_Datatype sendtype, @@ -257,7 +255,8 @@ int smpi_datatype_copy(void *sendbuf, int sendcount, MPI_Datatype sendtype, count = sendcount < recvcount ? sendcount : recvcount; if(sendtype->sizeof_substruct == 0 && recvtype->sizeof_substruct == 0) { - if(!smpi_process_get_replaying()) memcpy(recvbuf, sendbuf, count); + if(!smpi_process_get_replaying()) + memcpy(recvbuf, sendbuf, count); } else if (sendtype->sizeof_substruct == 0) { @@ -277,7 +276,7 @@ int smpi_datatype_copy(void *sendbuf, int sendcount, MPI_Datatype sendtype, subtype = static_cast(recvtype->substruct); subtype->unserialize( buf_tmp, recvbuf,count/smpi_datatype_size(recvtype), subtype, MPI_REPLACE); - free(buf_tmp); + xbt_free(buf_tmp); } } @@ -295,16 +294,16 @@ int smpi_datatype_copy(void *sendbuf, int sendcount, MPI_Datatype sendtype, */ void serialize_vector( const void *noncontiguous_vector, void *contiguous_vector, int count, void *type) { - s_smpi_mpi_vector_t* type_c = (s_smpi_mpi_vector_t*)type; + s_smpi_mpi_vector_t* type_c = reinterpret_cast(type); int i; - char* contiguous_vector_char = (char*)contiguous_vector; - char* noncontiguous_vector_char = (char*)noncontiguous_vector; + char* contiguous_vector_char = static_cast(contiguous_vector); + const char* noncontiguous_vector_char = static_cast(noncontiguous_vector); for (i = 0; i < type_c->block_count * count; i++) { if (type_c->old_type->sizeof_substruct == 0) memcpy(contiguous_vector_char, noncontiguous_vector_char, type_c->block_length * type_c->size_oldtype); else - ((s_smpi_subtype_t*)type_c->old_type->substruct)->serialize( noncontiguous_vector_char, + static_cast(type_c->old_type->substruct)->serialize( noncontiguous_vector_char, contiguous_vector_char, type_c->block_length, type_c->old_type->substruct); @@ -327,20 +326,18 @@ void serialize_vector( const void *noncontiguous_vector, void *contiguous_vector */ void unserialize_vector( const void *contiguous_vector, void *noncontiguous_vector, int count, void *type, MPI_Op op) { - s_smpi_mpi_vector_t* type_c = (s_smpi_mpi_vector_t*)type; + s_smpi_mpi_vector_t* type_c = reinterpret_cast(type); int i; - char* contiguous_vector_char = (char*)contiguous_vector; - char* noncontiguous_vector_char = (char*)noncontiguous_vector; + const char* contiguous_vector_char = static_cast(contiguous_vector); + char* noncontiguous_vector_char = static_cast(noncontiguous_vector); for (i = 0; i < type_c->block_count * count; i++) { if (type_c->old_type->sizeof_substruct == 0) smpi_op_apply(op, contiguous_vector_char, noncontiguous_vector_char, &type_c->block_length, &type_c->old_type); - /* memcpy(noncontiguous_vector_char, - contiguous_vector_char, type_c->block_length * type_c->size_oldtype);*/ else - ((s_smpi_subtype_t*)type_c->old_type->substruct)->unserialize(contiguous_vector_char, noncontiguous_vector_char, + static_cast(type_c->old_type->substruct)->unserialize(contiguous_vector_char, noncontiguous_vector_char, type_c->block_length,type_c->old_type->substruct, op); contiguous_vector_char += type_c->block_length*type_c->size_oldtype; @@ -392,7 +389,8 @@ void smpi_datatype_create(MPI_Datatype* new_type, int size,int lb, int ub, int s void smpi_datatype_free(MPI_Datatype* type){ xbt_assert((*type)->in_use >= 0); - if((*type)->flags & DT_FLAG_PREDEFINED)return; + if((*type)->flags & DT_FLAG_PREDEFINED) + return; //if still used, mark for deletion if((*type)->in_use!=0){ @@ -407,8 +405,8 @@ void smpi_datatype_free(MPI_Datatype* type){ int flag; xbt_dict_foreach((*type)->attributes, cursor, key, value){ smpi_type_key_elem elem = - static_cast(xbt_dict_get_or_null_ext(smpi_type_keyvals, (const char*)key, sizeof(int))); - if(elem && elem->delete_fn) + static_cast(xbt_dict_get_or_null_ext(smpi_type_keyvals, reinterpret_cast(key), sizeof(int))); + if(elem!=NULL && elem->delete_fn) elem->delete_fn(*type,*key, value, &flag); } xbt_dict_free(&(*type)->attributes); @@ -425,10 +423,11 @@ void smpi_datatype_free(MPI_Datatype* type){ void smpi_datatype_use(MPI_Datatype type){ - if(type)type->in_use++; + if(type != MPI_DATATYPE_NULL) + type->in_use++; if(type->sizeof_substruct!=0){ - ((s_smpi_subtype_t *)(type)->substruct)->subtype_use(&type); + static_cast((type)->substruct)->subtype_use(&type); } #if HAVE_MC if(MC_is_active()) @@ -441,10 +440,10 @@ void smpi_datatype_unuse(MPI_Datatype type){ type->in_use--; if(type->sizeof_substruct!=0){ - ((s_smpi_subtype_t *)(type)->substruct)->subtype_free(&type); + static_cast((type)->substruct)->subtype_free(&type); } - if(type && type->in_use == 0){ + if(type != MPI_DATATYPE_NULL && type->in_use == 0){ smpi_datatype_free(&type); } #if HAVE_MC @@ -465,9 +464,9 @@ void smpi_datatype_unuse(MPI_Datatype type){ */ void serialize_contiguous( const void *noncontiguous_hvector, void *contiguous_hvector, int count, void *type) { - s_smpi_mpi_contiguous_t* type_c = (s_smpi_mpi_contiguous_t*)type; - char* contiguous_vector_char = (char*)contiguous_hvector; - char* noncontiguous_vector_char = (char*)noncontiguous_hvector+type_c->lb; + s_smpi_mpi_contiguous_t* type_c = reinterpret_cast(type); + char* contiguous_vector_char = static_cast(contiguous_hvector); + const char* noncontiguous_vector_char = static_cast(noncontiguous_hvector)+type_c->lb; memcpy(contiguous_vector_char, noncontiguous_vector_char, count* type_c->block_count * type_c->size_oldtype); } /* Copies contiguous data into noncontiguous memory. @@ -480,27 +479,27 @@ void serialize_contiguous( const void *noncontiguous_hvector, void *contiguous_h */ void unserialize_contiguous(const void *contiguous_vector, void *noncontiguous_vector, int count, void *type, MPI_Op op) { - s_smpi_mpi_contiguous_t* type_c = (s_smpi_mpi_contiguous_t*)type; - char* contiguous_vector_char = (char*)contiguous_vector; - char* noncontiguous_vector_char = (char*)noncontiguous_vector+type_c->lb; + s_smpi_mpi_contiguous_t* type_c = reinterpret_cast(type); + const char* contiguous_vector_char = static_cast(contiguous_vector); + char* noncontiguous_vector_char = static_cast(noncontiguous_vector)+type_c->lb; int n= count* type_c->block_count; smpi_op_apply(op, contiguous_vector_char, noncontiguous_vector_char, &n, &type_c->old_type); - /*memcpy(noncontiguous_vector_char, contiguous_vector_char, count* type_c->block_count * type_c->size_oldtype);*/ } void free_contiguous(MPI_Datatype* d){ - smpi_datatype_unuse(((s_smpi_mpi_contiguous_t *)(*d)->substruct)->old_type); + smpi_datatype_unuse(reinterpret_cast((*d)->substruct)->old_type); } void use_contiguous(MPI_Datatype* d){ - smpi_datatype_use(((s_smpi_mpi_contiguous_t *)(*d)->substruct)->old_type); + smpi_datatype_use(reinterpret_cast((*d)->substruct)->old_type); } /* Create a Sub type contiguous to be able to serialize and unserialize it the structure s_smpi_mpi_contiguous_t is * erived from s_smpi_subtype which required the functions unserialize and serialize */ s_smpi_mpi_contiguous_t* smpi_datatype_contiguous_create( MPI_Aint lb, int block_count, MPI_Datatype old_type, int size_oldtype){ - if(block_count==0)return NULL; + if(block_count==0) + return NULL; s_smpi_mpi_contiguous_t *new_t= xbt_new(s_smpi_mpi_contiguous_t,1); new_t->base.serialize = &serialize_contiguous; new_t->base.unserialize = &unserialize_contiguous; @@ -534,14 +533,15 @@ int smpi_datatype_contiguous(int count, MPI_Datatype old_type, MPI_Datatype* new int smpi_datatype_vector(int count, int blocklen, int stride, MPI_Datatype old_type, MPI_Datatype* new_type) { int retval; - if (blocklen<0) return MPI_ERR_ARG; + if (blocklen<0) + return MPI_ERR_ARG; MPI_Aint lb = 0; MPI_Aint ub = 0; if(count>0){ lb=smpi_datatype_lb(old_type); ub=((count-1)*stride+blocklen-1)*smpi_datatype_get_extent(old_type)+smpi_datatype_ub(old_type); } - if(old_type->sizeof_substruct || stride != blocklen){ + if(old_type->sizeof_substruct != 0 || stride != blocklen){ s_smpi_mpi_vector_t* subtype = smpi_datatype_vector_create(stride, blocklen, count, old_type, smpi_datatype_size(old_type)); @@ -558,11 +558,11 @@ int smpi_datatype_vector(int count, int blocklen, int stride, MPI_Datatype old_t } void free_vector(MPI_Datatype* d){ - smpi_datatype_unuse(((s_smpi_mpi_indexed_t *)(*d)->substruct)->old_type); + smpi_datatype_unuse(reinterpret_cast((*d)->substruct)->old_type); } void use_vector(MPI_Datatype* d){ - smpi_datatype_use(((s_smpi_mpi_indexed_t *)(*d)->substruct)->old_type); + smpi_datatype_use(reinterpret_cast((*d)->substruct)->old_type); } /* Hvector Implementation - Vector with stride in bytes */ @@ -577,16 +577,16 @@ void use_vector(MPI_Datatype* d){ */ void serialize_hvector( const void *noncontiguous_hvector, void *contiguous_hvector, int count, void *type) { - s_smpi_mpi_hvector_t* type_c = (s_smpi_mpi_hvector_t*)type; + s_smpi_mpi_hvector_t* type_c = reinterpret_cast(type); int i; - char* contiguous_vector_char = (char*)contiguous_hvector; - char* noncontiguous_vector_char = (char*)noncontiguous_hvector; + char* contiguous_vector_char = static_cast(contiguous_hvector); + const char* noncontiguous_vector_char = static_cast(noncontiguous_hvector); for (i = 0; i < type_c->block_count * count; i++) { if (type_c->old_type->sizeof_substruct == 0) memcpy(contiguous_vector_char, noncontiguous_vector_char, type_c->block_length * type_c->size_oldtype); else - ((s_smpi_subtype_t*)type_c->old_type->substruct)->serialize( noncontiguous_vector_char, + static_cast(type_c->old_type->substruct)->serialize( noncontiguous_vector_char, contiguous_vector_char, type_c->block_length, type_c->old_type->substruct); @@ -607,19 +607,17 @@ void serialize_hvector( const void *noncontiguous_hvector, void *contiguous_hvec */ void unserialize_hvector( const void *contiguous_vector, void *noncontiguous_vector, int count, void *type, MPI_Op op) { - s_smpi_mpi_hvector_t* type_c = (s_smpi_mpi_hvector_t*)type; + s_smpi_mpi_hvector_t* type_c = reinterpret_cast(type); int i; - char* contiguous_vector_char = (char*)contiguous_vector; - char* noncontiguous_vector_char = (char*)noncontiguous_vector; + const char* contiguous_vector_char = static_cast(contiguous_vector); + char* noncontiguous_vector_char = static_cast(noncontiguous_vector); for (i = 0; i < type_c->block_count * count; i++) { if (type_c->old_type->sizeof_substruct == 0) smpi_op_apply(op, contiguous_vector_char, noncontiguous_vector_char, &type_c->block_length, &type_c->old_type); - /*memcpy(noncontiguous_vector_char, - contiguous_vector_char, type_c->block_length * type_c->size_oldtype);*/ else - ((s_smpi_subtype_t*)type_c->old_type->substruct)->unserialize( contiguous_vector_char, noncontiguous_vector_char, + static_cast(type_c->old_type->substruct)->unserialize( contiguous_vector_char, noncontiguous_vector_char, type_c->block_length, type_c->old_type->substruct, op); contiguous_vector_char += type_c->block_length*type_c->size_oldtype; @@ -652,24 +650,25 @@ s_smpi_mpi_hvector_t* smpi_datatype_hvector_create( MPI_Aint block_stride, int b //do nothing for vector types void free_hvector(MPI_Datatype* d){ - smpi_datatype_unuse(((s_smpi_mpi_hvector_t *)(*d)->substruct)->old_type); + smpi_datatype_unuse(reinterpret_cast((*d)->substruct)->old_type); } void use_hvector(MPI_Datatype* d){ - smpi_datatype_use(((s_smpi_mpi_hvector_t *)(*d)->substruct)->old_type); + smpi_datatype_use(reinterpret_cast((*d)->substruct)->old_type); } int smpi_datatype_hvector(int count, int blocklen, MPI_Aint stride, MPI_Datatype old_type, MPI_Datatype* new_type) { int retval; - if (blocklen<0) return MPI_ERR_ARG; + if (blocklen<0) + return MPI_ERR_ARG; MPI_Aint lb = 0; MPI_Aint ub = 0; if(count>0){ lb=smpi_datatype_lb(old_type); ub=((count-1)*stride)+(blocklen-1)*smpi_datatype_get_extent(old_type)+smpi_datatype_ub(old_type); } - if(old_type->sizeof_substruct || stride != blocklen*smpi_datatype_get_extent(old_type)){ + if(old_type->sizeof_substruct != 0 || stride != blocklen*smpi_datatype_get_extent(old_type)){ s_smpi_mpi_hvector_t* subtype = smpi_datatype_hvector_create( stride, blocklen, count, old_type, smpi_datatype_size(old_type)); @@ -695,16 +694,16 @@ int smpi_datatype_hvector(int count, int blocklen, MPI_Aint stride, MPI_Datatype */ void serialize_indexed( const void *noncontiguous_indexed, void *contiguous_indexed, int count, void *type) { - s_smpi_mpi_indexed_t* type_c = (s_smpi_mpi_indexed_t*)type; + s_smpi_mpi_indexed_t* type_c = reinterpret_cast(type); int i,j; - char* contiguous_indexed_char = (char*)contiguous_indexed; - char* noncontiguous_indexed_char = (char*)noncontiguous_indexed+type_c->block_indices[0] * type_c->size_oldtype; + char* contiguous_indexed_char = static_cast(contiguous_indexed); + const char* noncontiguous_indexed_char = static_cast(noncontiguous_indexed)+type_c->block_indices[0] * type_c->size_oldtype; for(j=0; jblock_count; i++) { if (type_c->old_type->sizeof_substruct == 0) memcpy(contiguous_indexed_char, noncontiguous_indexed_char, type_c->block_lengths[i] * type_c->size_oldtype); else - ((s_smpi_subtype_t*)type_c->old_type->substruct)->serialize( noncontiguous_indexed_char, + static_cast(type_c->old_type->substruct)->serialize( noncontiguous_indexed_char, contiguous_indexed_char, type_c->block_lengths[i], type_c->old_type->substruct); @@ -712,11 +711,11 @@ void serialize_indexed( const void *noncontiguous_indexed, void *contiguous_inde contiguous_indexed_char += type_c->block_lengths[i]*type_c->size_oldtype; if (iblock_count-1) noncontiguous_indexed_char = - (char*)noncontiguous_indexed + type_c->block_indices[i+1]*smpi_datatype_get_extent(type_c->old_type); + static_cast(noncontiguous_indexed) + type_c->block_indices[i+1]*smpi_datatype_get_extent(type_c->old_type); else noncontiguous_indexed_char += type_c->block_lengths[i]*smpi_datatype_get_extent(type_c->old_type); } - noncontiguous_indexed=(void*)noncontiguous_indexed_char; + noncontiguous_indexed=static_cast(noncontiguous_indexed_char); } } /* Copies contiguous data into noncontiguous memory. @@ -729,20 +728,18 @@ void serialize_indexed( const void *noncontiguous_indexed, void *contiguous_inde */ void unserialize_indexed( const void *contiguous_indexed, void *noncontiguous_indexed, int count, void *type, MPI_Op op) { - s_smpi_mpi_indexed_t* type_c = (s_smpi_mpi_indexed_t*)type; + s_smpi_mpi_indexed_t* type_c = reinterpret_cast(type); int i,j; - char* contiguous_indexed_char = (char*)contiguous_indexed; + const char* contiguous_indexed_char = static_cast(contiguous_indexed); char* noncontiguous_indexed_char = - (char*)noncontiguous_indexed+type_c->block_indices[0]*smpi_datatype_get_extent(type_c->old_type); + static_cast(noncontiguous_indexed)+type_c->block_indices[0]*smpi_datatype_get_extent(type_c->old_type); for(j=0; jblock_count; i++) { if (type_c->old_type->sizeof_substruct == 0) smpi_op_apply(op, contiguous_indexed_char, noncontiguous_indexed_char, &type_c->block_lengths[i], &type_c->old_type); - /*memcpy(noncontiguous_indexed_char , - contiguous_indexed_char, type_c->block_lengths[i] * type_c->size_oldtype);*/ else - ((s_smpi_subtype_t*)type_c->old_type->substruct)->unserialize( contiguous_indexed_char, + static_cast(type_c->old_type->substruct)->unserialize( contiguous_indexed_char, noncontiguous_indexed_char, type_c->block_lengths[i], type_c->old_type->substruct, op); @@ -750,24 +747,24 @@ void unserialize_indexed( const void *contiguous_indexed, void *noncontiguous_in contiguous_indexed_char += type_c->block_lengths[i]*type_c->size_oldtype; if (iblock_count-1) noncontiguous_indexed_char = - (char*)noncontiguous_indexed + type_c->block_indices[i+1]*smpi_datatype_get_extent(type_c->old_type); + static_cast(noncontiguous_indexed) + type_c->block_indices[i+1]*smpi_datatype_get_extent(type_c->old_type); else noncontiguous_indexed_char += type_c->block_lengths[i]*smpi_datatype_get_extent(type_c->old_type); } - noncontiguous_indexed=(void*)noncontiguous_indexed_char; + noncontiguous_indexed=static_cast(noncontiguous_indexed_char); } } void free_indexed(MPI_Datatype* type){ if((*type)->in_use==0){ - xbt_free(((s_smpi_mpi_indexed_t *)(*type)->substruct)->block_lengths); - xbt_free(((s_smpi_mpi_indexed_t *)(*type)->substruct)->block_indices); + xbt_free(reinterpret_cast((*type)->substruct)->block_lengths); + xbt_free(reinterpret_cast((*type)->substruct)->block_indices); } - smpi_datatype_unuse(((s_smpi_mpi_indexed_t *)(*type)->substruct)->old_type); + smpi_datatype_unuse(reinterpret_cast((*type)->substruct)->old_type); } void use_indexed(MPI_Datatype* type){ - smpi_datatype_use(((s_smpi_mpi_indexed_t *)(*type)->substruct)->old_type); + smpi_datatype_use(reinterpret_cast((*type)->substruct)->old_type); } @@ -817,7 +814,8 @@ int smpi_datatype_indexed(int count, int* blocklens, int* indices, MPI_Datatype if(indices[i]*smpi_datatype_get_extent(old_type)+blocklens[i]*smpi_datatype_ub(old_type)>ub) ub = indices[i]*smpi_datatype_get_extent(old_type)+blocklens[i]*smpi_datatype_ub(old_type); - if ( (i< count -1) && (indices[i]+blocklens[i] != indices[i+1]) )contiguous=0; + if ( (i< count -1) && (indices[i]+blocklens[i] != indices[i+1]) ) + contiguous=0; } if (old_type->sizeof_substruct != 0) contiguous=0; @@ -847,27 +845,27 @@ int smpi_datatype_indexed(int count, int* blocklens, int* indices, MPI_Datatype */ void serialize_hindexed( const void *noncontiguous_hindexed, void *contiguous_hindexed, int count, void *type) { - s_smpi_mpi_hindexed_t* type_c = (s_smpi_mpi_hindexed_t*)type; + s_smpi_mpi_hindexed_t* type_c = reinterpret_cast(type); int i,j; - char* contiguous_hindexed_char = (char*)contiguous_hindexed; - char* noncontiguous_hindexed_char = (char*)noncontiguous_hindexed+ type_c->block_indices[0]; + char* contiguous_hindexed_char = static_cast(contiguous_hindexed); + const char* noncontiguous_hindexed_char = static_cast(noncontiguous_hindexed)+ type_c->block_indices[0]; for(j=0; jblock_count; i++) { if (type_c->old_type->sizeof_substruct == 0) memcpy(contiguous_hindexed_char, noncontiguous_hindexed_char, type_c->block_lengths[i] * type_c->size_oldtype); else - ((s_smpi_subtype_t*)type_c->old_type->substruct)->serialize( noncontiguous_hindexed_char, + static_cast(type_c->old_type->substruct)->serialize( noncontiguous_hindexed_char, contiguous_hindexed_char, type_c->block_lengths[i], type_c->old_type->substruct); contiguous_hindexed_char += type_c->block_lengths[i]*type_c->size_oldtype; if (iblock_count-1) - noncontiguous_hindexed_char = (char*)noncontiguous_hindexed + type_c->block_indices[i+1]; + noncontiguous_hindexed_char = static_cast(noncontiguous_hindexed) + type_c->block_indices[i+1]; else noncontiguous_hindexed_char += type_c->block_lengths[i]*smpi_datatype_get_extent(type_c->old_type); } - noncontiguous_hindexed=(void*)noncontiguous_hindexed_char; + noncontiguous_hindexed=reinterpret_cast(noncontiguous_hindexed_char); } } /* Copies contiguous data into noncontiguous memory. @@ -881,43 +879,42 @@ void serialize_hindexed( const void *noncontiguous_hindexed, void *contiguous_hi void unserialize_hindexed( const void *contiguous_hindexed, void *noncontiguous_hindexed, int count, void *type, MPI_Op op) { - s_smpi_mpi_hindexed_t* type_c = (s_smpi_mpi_hindexed_t*)type; + s_smpi_mpi_hindexed_t* type_c = reinterpret_cast(type); int i,j; - char* contiguous_hindexed_char = (char*)contiguous_hindexed; - char* noncontiguous_hindexed_char = (char*)noncontiguous_hindexed+ type_c->block_indices[0]; + const char* contiguous_hindexed_char = static_cast(contiguous_hindexed); + char* noncontiguous_hindexed_char = static_cast(noncontiguous_hindexed)+ type_c->block_indices[0]; for(j=0; jblock_count; i++) { if (type_c->old_type->sizeof_substruct == 0) smpi_op_apply(op, contiguous_hindexed_char, noncontiguous_hindexed_char, &type_c->block_lengths[i], &type_c->old_type); - /*memcpy(noncontiguous_hindexed_char,contiguous_hindexed_char,type_c->block_lengths[i]*type_c->size_oldtype);*/ else - ((s_smpi_subtype_t*)type_c->old_type->substruct)->unserialize( contiguous_hindexed_char, + static_cast(type_c->old_type->substruct)->unserialize( contiguous_hindexed_char, noncontiguous_hindexed_char, type_c->block_lengths[i], type_c->old_type->substruct, op); contiguous_hindexed_char += type_c->block_lengths[i]*type_c->size_oldtype; if (iblock_count-1) - noncontiguous_hindexed_char = (char*)noncontiguous_hindexed + type_c->block_indices[i+1]; + noncontiguous_hindexed_char = static_cast(noncontiguous_hindexed) + type_c->block_indices[i+1]; else noncontiguous_hindexed_char += type_c->block_lengths[i]*smpi_datatype_get_extent(type_c->old_type); } - noncontiguous_hindexed=(void*)noncontiguous_hindexed_char; + noncontiguous_hindexed=reinterpret_cast(noncontiguous_hindexed_char); } } void free_hindexed(MPI_Datatype* type){ if((*type)->in_use==0){ - xbt_free(((s_smpi_mpi_hindexed_t *)(*type)->substruct)->block_lengths); - xbt_free(((s_smpi_mpi_hindexed_t *)(*type)->substruct)->block_indices); + xbt_free(reinterpret_cast((*type)->substruct)->block_lengths); + xbt_free(reinterpret_cast((*type)->substruct)->block_indices); } - smpi_datatype_unuse(((s_smpi_mpi_indexed_t *)(*type)->substruct)->old_type); + smpi_datatype_unuse(reinterpret_cast((*type)->substruct)->old_type); } void use_hindexed(MPI_Datatype* type){ - smpi_datatype_use(((s_smpi_mpi_hindexed_t *)(*type)->substruct)->old_type); + smpi_datatype_use(reinterpret_cast((*type)->substruct)->old_type); } /* Create a Sub type hindexed to be able to serialize and unserialize it the structure s_smpi_mpi_hindexed_t is derived @@ -961,10 +958,12 @@ int smpi_datatype_hindexed(int count, int* blocklens, MPI_Aint* indices, MPI_Dat return MPI_ERR_ARG; size += blocklens[i]; - if(indices[i]+smpi_datatype_lb(old_type)ub) ub = indices[i]+blocklens[i]*smpi_datatype_ub(old_type); + if(indices[i]+smpi_datatype_lb(old_type)ub) + ub = indices[i]+blocklens[i]*smpi_datatype_ub(old_type); - if ( (i< count -1) && (indices[i]+blocklens[i]*static_cast(smpi_datatype_size(old_type)) != indices[i+1]) ) + if ( (i< count -1) && (indices[i]+blocklens[i]*(static_cast(smpi_datatype_size(old_type))) != indices[i+1]) ) contiguous=0; } if (old_type->sizeof_substruct != 0 || lb!=0) @@ -995,17 +994,17 @@ int smpi_datatype_hindexed(int count, int* blocklens, MPI_Aint* indices, MPI_Dat */ void serialize_struct( const void *noncontiguous_struct, void *contiguous_struct, int count, void *type) { - s_smpi_mpi_struct_t* type_c = (s_smpi_mpi_struct_t*)type; + s_smpi_mpi_struct_t* type_c = reinterpret_cast(type); int i,j; - char* contiguous_struct_char = (char*)contiguous_struct; - char* noncontiguous_struct_char = (char*)noncontiguous_struct+ type_c->block_indices[0]; + char* contiguous_struct_char = static_cast(contiguous_struct); + const char* noncontiguous_struct_char = static_cast(noncontiguous_struct)+ type_c->block_indices[0]; for(j=0; jblock_count; i++) { if (type_c->old_types[i]->sizeof_substruct == 0) memcpy(contiguous_struct_char, noncontiguous_struct_char, type_c->block_lengths[i] * smpi_datatype_size(type_c->old_types[i])); else - ((s_smpi_subtype_t*)type_c->old_types[i]->substruct)->serialize( noncontiguous_struct_char, + static_cast(type_c->old_types[i]->substruct)->serialize( noncontiguous_struct_char, contiguous_struct_char, type_c->block_lengths[i], type_c->old_types[i]->substruct); @@ -1013,11 +1012,11 @@ void serialize_struct( const void *noncontiguous_struct, void *contiguous_struct contiguous_struct_char += type_c->block_lengths[i]*smpi_datatype_size(type_c->old_types[i]); if (iblock_count-1) - noncontiguous_struct_char = (char*)noncontiguous_struct + type_c->block_indices[i+1]; + noncontiguous_struct_char = static_cast(noncontiguous_struct) + type_c->block_indices[i+1]; else //let's hope this is MPI_UB ? noncontiguous_struct_char += type_c->block_lengths[i]*smpi_datatype_get_extent(type_c->old_types[i]); } - noncontiguous_struct=(void*)noncontiguous_struct_char; + noncontiguous_struct=reinterpret_cast(noncontiguous_struct_char); } } @@ -1031,49 +1030,47 @@ void serialize_struct( const void *noncontiguous_struct, void *contiguous_struct */ void unserialize_struct( const void *contiguous_struct, void *noncontiguous_struct, int count, void *type, MPI_Op op) { - s_smpi_mpi_struct_t* type_c = (s_smpi_mpi_struct_t*)type; + s_smpi_mpi_struct_t* type_c = reinterpret_cast(type); int i,j; - char* contiguous_struct_char = (char*)contiguous_struct; - char* noncontiguous_struct_char = (char*)noncontiguous_struct+ type_c->block_indices[0]; + const char* contiguous_struct_char = static_cast(contiguous_struct); + char* noncontiguous_struct_char = static_cast(noncontiguous_struct)+ type_c->block_indices[0]; for(j=0; jblock_count; i++) { if (type_c->old_types[i]->sizeof_substruct == 0) smpi_op_apply(op, contiguous_struct_char, noncontiguous_struct_char, &type_c->block_lengths[i], & type_c->old_types[i]); - /*memcpy(noncontiguous_struct_char, - contiguous_struct_char, type_c->block_lengths[i] * smpi_datatype_size(type_c->old_types[i]));*/ else - ((s_smpi_subtype_t*)type_c->old_types[i]->substruct)->unserialize( contiguous_struct_char, + static_cast(type_c->old_types[i]->substruct)->unserialize( contiguous_struct_char, noncontiguous_struct_char, type_c->block_lengths[i], type_c->old_types[i]->substruct, op); contiguous_struct_char += type_c->block_lengths[i]*smpi_datatype_size(type_c->old_types[i]); if (iblock_count-1) - noncontiguous_struct_char = (char*)noncontiguous_struct + type_c->block_indices[i+1]; + noncontiguous_struct_char = static_cast(noncontiguous_struct) + type_c->block_indices[i+1]; else noncontiguous_struct_char += type_c->block_lengths[i]*smpi_datatype_get_extent(type_c->old_types[i]); } - noncontiguous_struct=(void*)noncontiguous_struct_char; + noncontiguous_struct=reinterpret_cast(noncontiguous_struct_char); } } void free_struct(MPI_Datatype* type){ int i=0; - for (i = 0; i < ((s_smpi_mpi_struct_t *)(*type)->substruct)->block_count; i++) - smpi_datatype_unuse(((s_smpi_mpi_struct_t *)(*type)->substruct)->old_types[i]); + for (i = 0; i < reinterpret_cast((*type)->substruct)->block_count; i++) + smpi_datatype_unuse(reinterpret_cast((*type)->substruct)->old_types[i]); if((*type)->in_use==0){ - xbt_free(((s_smpi_mpi_struct_t *)(*type)->substruct)->block_lengths); - xbt_free(((s_smpi_mpi_struct_t *)(*type)->substruct)->block_indices); - xbt_free(((s_smpi_mpi_struct_t *)(*type)->substruct)->old_types); + xbt_free(reinterpret_cast((*type)->substruct)->block_lengths); + xbt_free(reinterpret_cast((*type)->substruct)->block_indices); + xbt_free(reinterpret_cast((*type)->substruct)->old_types); } } void use_struct(MPI_Datatype* type){ int i=0; - for (i = 0; i < ((s_smpi_mpi_struct_t *)(*type)->substruct)->block_count; i++) - smpi_datatype_use(((s_smpi_mpi_struct_t *)(*type)->substruct)->old_types[i]); + for (i = 0; i < reinterpret_cast((*type)->substruct)->block_count; i++) + smpi_datatype_use(reinterpret_cast((*type)->substruct)->old_types[i]); } /* Create a Sub type struct to be able to serialize and unserialize it the structure s_smpi_mpi_struct_t is derived @@ -1130,7 +1127,8 @@ int smpi_datatype_struct(int count, int* blocklens, MPI_Aint* indices, MPI_Datat forced_ub=1; } - if(!forced_lb && indices[i]+smpi_datatype_lb(old_types[i])ub) ub = indices[i]+blocklens[i]*smpi_datatype_ub(old_types[i]); @@ -1138,7 +1136,7 @@ int smpi_datatype_struct(int count, int* blocklens, MPI_Aint* indices, MPI_Datat contiguous=0; } - if(!contiguous){ + if(contiguous==0){ s_smpi_mpi_struct_t* subtype = smpi_datatype_struct_create( blocklens, indices, count, old_types); smpi_datatype_create(new_type, size, lb, ub,sizeof(s_smpi_mpi_struct_t), subtype, DT_FLAG_DATA); @@ -1185,304 +1183,328 @@ typedef struct s_smpi_mpi_op { static void max_func(void *a, void *b, int *length, MPI_Datatype * datatype) { if (*datatype == MPI_CHAR) { - APPLY_FUNC(a, b, length, char, MAX_OP); + APPLY_FUNC(a, b, length, char, MAX_OP) } else if (*datatype == MPI_SHORT) { - APPLY_FUNC(a, b, length, short, MAX_OP); + APPLY_FUNC(a, b, length, short, MAX_OP) } else if (*datatype == MPI_INT) { - APPLY_FUNC(a, b, length, int, MAX_OP); + APPLY_FUNC(a, b, length, int, MAX_OP) } else if (*datatype == MPI_LONG) { - APPLY_FUNC(a, b, length, long, MAX_OP); + APPLY_FUNC(a, b, length, long, MAX_OP) } else if (*datatype == MPI_UNSIGNED_SHORT) { - APPLY_FUNC(a, b, length, unsigned short, MAX_OP); + APPLY_FUNC(a, b, length, unsigned short, MAX_OP) } else if (*datatype == MPI_UNSIGNED) { - APPLY_FUNC(a, b, length, unsigned int, MAX_OP); + APPLY_FUNC(a, b, length, unsigned int, MAX_OP) } else if (*datatype == MPI_UNSIGNED_LONG) { - APPLY_FUNC(a, b, length, unsigned long, MAX_OP); + APPLY_FUNC(a, b, length, unsigned long, MAX_OP) } else if (*datatype == MPI_UNSIGNED_CHAR) { - APPLY_FUNC(a, b, length, unsigned char, MAX_OP); + APPLY_FUNC(a, b, length, unsigned char, MAX_OP) } else if (*datatype == MPI_FLOAT) { - APPLY_FUNC(a, b, length, float, MAX_OP); + APPLY_FUNC(a, b, length, float, MAX_OP) } else if (*datatype == MPI_DOUBLE) { - APPLY_FUNC(a, b, length, double, MAX_OP); + APPLY_FUNC(a, b, length, double, MAX_OP) } else if (*datatype == MPI_LONG_DOUBLE) { - APPLY_FUNC(a, b, length, long double, MAX_OP); + APPLY_FUNC(a, b, length, long double, MAX_OP) + } else { + xbt_die("Failed to apply MAX_OP to type %s", (*datatype)->name); } } static void min_func(void *a, void *b, int *length, MPI_Datatype * datatype) { if (*datatype == MPI_CHAR) { - APPLY_FUNC(a, b, length, char, MIN_OP); + APPLY_FUNC(a, b, length, char, MIN_OP) } else if (*datatype == MPI_SHORT) { - APPLY_FUNC(a, b, length, short, MIN_OP); + APPLY_FUNC(a, b, length, short, MIN_OP) } else if (*datatype == MPI_INT) { - APPLY_FUNC(a, b, length, int, MIN_OP); + APPLY_FUNC(a, b, length, int, MIN_OP) } else if (*datatype == MPI_LONG) { - APPLY_FUNC(a, b, length, long, MIN_OP); + APPLY_FUNC(a, b, length, long, MIN_OP) } else if (*datatype == MPI_UNSIGNED_SHORT) { - APPLY_FUNC(a, b, length, unsigned short, MIN_OP); + APPLY_FUNC(a, b, length, unsigned short, MIN_OP) } else if (*datatype == MPI_UNSIGNED) { - APPLY_FUNC(a, b, length, unsigned int, MIN_OP); + APPLY_FUNC(a, b, length, unsigned int, MIN_OP) } else if (*datatype == MPI_UNSIGNED_LONG) { - APPLY_FUNC(a, b, length, unsigned long, MIN_OP); + APPLY_FUNC(a, b, length, unsigned long, MIN_OP) } else if (*datatype == MPI_UNSIGNED_CHAR) { - APPLY_FUNC(a, b, length, unsigned char, MIN_OP); + APPLY_FUNC(a, b, length, unsigned char, MIN_OP) } else if (*datatype == MPI_FLOAT) { - APPLY_FUNC(a, b, length, float, MIN_OP); + APPLY_FUNC(a, b, length, float, MIN_OP) } else if (*datatype == MPI_DOUBLE) { - APPLY_FUNC(a, b, length, double, MIN_OP); + APPLY_FUNC(a, b, length, double, MIN_OP) } else if (*datatype == MPI_LONG_DOUBLE) { - APPLY_FUNC(a, b, length, long double, MIN_OP); + APPLY_FUNC(a, b, length, long double, MIN_OP) + } else { + xbt_die("Failed to apply MIN_OP to type %s", (*datatype)->name); } } static void sum_func(void *a, void *b, int *length, MPI_Datatype * datatype) { if (*datatype == MPI_CHAR) { - APPLY_FUNC(a, b, length, char, SUM_OP); + APPLY_FUNC(a, b, length, char, SUM_OP) } else if (*datatype == MPI_SHORT) { - APPLY_FUNC(a, b, length, short, SUM_OP); + APPLY_FUNC(a, b, length, short, SUM_OP) } else if (*datatype == MPI_INT) { - APPLY_FUNC(a, b, length, int, SUM_OP); + APPLY_FUNC(a, b, length, int, SUM_OP) } else if (*datatype == MPI_LONG) { - APPLY_FUNC(a, b, length, long, SUM_OP); + APPLY_FUNC(a, b, length, long, SUM_OP) } else if (*datatype == MPI_UNSIGNED_SHORT) { - APPLY_FUNC(a, b, length, unsigned short, SUM_OP); + APPLY_FUNC(a, b, length, unsigned short, SUM_OP) } else if (*datatype == MPI_UNSIGNED) { - APPLY_FUNC(a, b, length, unsigned int, SUM_OP); + APPLY_FUNC(a, b, length, unsigned int, SUM_OP) } else if (*datatype == MPI_UNSIGNED_LONG) { - APPLY_FUNC(a, b, length, unsigned long, SUM_OP); + APPLY_FUNC(a, b, length, unsigned long, SUM_OP) } else if (*datatype == MPI_UNSIGNED_CHAR) { - APPLY_FUNC(a, b, length, unsigned char, SUM_OP); + APPLY_FUNC(a, b, length, unsigned char, SUM_OP) } else if (*datatype == MPI_FLOAT) { - APPLY_FUNC(a, b, length, float, SUM_OP); + APPLY_FUNC(a, b, length, float, SUM_OP) } else if (*datatype == MPI_DOUBLE) { - APPLY_FUNC(a, b, length, double, SUM_OP); + APPLY_FUNC(a, b, length, double, SUM_OP) } else if (*datatype == MPI_LONG_DOUBLE) { - APPLY_FUNC(a, b, length, long double, SUM_OP); + APPLY_FUNC(a, b, length, long double, SUM_OP) } else if (*datatype == MPI_C_FLOAT_COMPLEX) { - APPLY_FUNC(a, b, length, float _Complex, SUM_OP); + APPLY_FUNC(a, b, length, float _Complex, SUM_OP) } else if (*datatype == MPI_C_DOUBLE_COMPLEX) { - APPLY_FUNC(a, b, length, double _Complex, SUM_OP); + APPLY_FUNC(a, b, length, double _Complex, SUM_OP) } else if (*datatype == MPI_C_LONG_DOUBLE_COMPLEX) { - APPLY_FUNC(a, b, length, long double _Complex, SUM_OP); + APPLY_FUNC(a, b, length, long double _Complex, SUM_OP) + } else { + xbt_die("Failed to apply SUM_OP to type %s", (*datatype)->name); } } static void prod_func(void *a, void *b, int *length, MPI_Datatype * datatype) { if (*datatype == MPI_CHAR) { - APPLY_FUNC(a, b, length, char, PROD_OP); + APPLY_FUNC(a, b, length, char, PROD_OP) } else if (*datatype == MPI_SHORT) { - APPLY_FUNC(a, b, length, short, PROD_OP); + APPLY_FUNC(a, b, length, short, PROD_OP) } else if (*datatype == MPI_INT) { - APPLY_FUNC(a, b, length, int, PROD_OP); + APPLY_FUNC(a, b, length, int, PROD_OP) } else if (*datatype == MPI_LONG) { - APPLY_FUNC(a, b, length, long, PROD_OP); + APPLY_FUNC(a, b, length, long, PROD_OP) } else if (*datatype == MPI_UNSIGNED_SHORT) { - APPLY_FUNC(a, b, length, unsigned short, PROD_OP); + APPLY_FUNC(a, b, length, unsigned short, PROD_OP) } else if (*datatype == MPI_UNSIGNED) { - APPLY_FUNC(a, b, length, unsigned int, PROD_OP); + APPLY_FUNC(a, b, length, unsigned int, PROD_OP) } else if (*datatype == MPI_UNSIGNED_LONG) { - APPLY_FUNC(a, b, length, unsigned long, PROD_OP); + APPLY_FUNC(a, b, length, unsigned long, PROD_OP) } else if (*datatype == MPI_UNSIGNED_CHAR) { - APPLY_FUNC(a, b, length, unsigned char, PROD_OP); + APPLY_FUNC(a, b, length, unsigned char, PROD_OP) } else if (*datatype == MPI_FLOAT) { - APPLY_FUNC(a, b, length, float, PROD_OP); + APPLY_FUNC(a, b, length, float, PROD_OP) } else if (*datatype == MPI_DOUBLE) { - APPLY_FUNC(a, b, length, double, PROD_OP); + APPLY_FUNC(a, b, length, double, PROD_OP) } else if (*datatype == MPI_LONG_DOUBLE) { - APPLY_FUNC(a, b, length, long double, PROD_OP); + APPLY_FUNC(a, b, length, long double, PROD_OP) } else if (*datatype == MPI_C_FLOAT_COMPLEX) { - APPLY_FUNC(a, b, length, float _Complex, PROD_OP); + APPLY_FUNC(a, b, length, float _Complex, PROD_OP) } else if (*datatype == MPI_C_DOUBLE_COMPLEX) { - APPLY_FUNC(a, b, length, double _Complex, PROD_OP); + APPLY_FUNC(a, b, length, double _Complex, PROD_OP) } else if (*datatype == MPI_C_LONG_DOUBLE_COMPLEX) { - APPLY_FUNC(a, b, length, long double _Complex, PROD_OP); + APPLY_FUNC(a, b, length, long double _Complex, PROD_OP) + } else { + xbt_die("Failed to apply PROD_OP to type %s", (*datatype)->name); } } static void land_func(void *a, void *b, int *length, MPI_Datatype * datatype) { if (*datatype == MPI_CHAR) { - APPLY_FUNC(a, b, length, char, LAND_OP); + APPLY_FUNC(a, b, length, char, LAND_OP) } else if (*datatype == MPI_SHORT) { - APPLY_FUNC(a, b, length, short, LAND_OP); + APPLY_FUNC(a, b, length, short, LAND_OP) } else if (*datatype == MPI_INT) { - APPLY_FUNC(a, b, length, int, LAND_OP); + APPLY_FUNC(a, b, length, int, LAND_OP) } else if (*datatype == MPI_LONG) { - APPLY_FUNC(a, b, length, long, LAND_OP); + APPLY_FUNC(a, b, length, long, LAND_OP) } else if (*datatype == MPI_UNSIGNED_SHORT) { - APPLY_FUNC(a, b, length, unsigned short, LAND_OP); + APPLY_FUNC(a, b, length, unsigned short, LAND_OP) } else if (*datatype == MPI_UNSIGNED) { - APPLY_FUNC(a, b, length, unsigned int, LAND_OP); + APPLY_FUNC(a, b, length, unsigned int, LAND_OP) } else if (*datatype == MPI_UNSIGNED_LONG) { - APPLY_FUNC(a, b, length, unsigned long, LAND_OP); + APPLY_FUNC(a, b, length, unsigned long, LAND_OP) } else if (*datatype == MPI_UNSIGNED_CHAR) { - APPLY_FUNC(a, b, length, unsigned char, LAND_OP); + APPLY_FUNC(a, b, length, unsigned char, LAND_OP) } else if (*datatype == MPI_C_BOOL) { - APPLY_FUNC(a, b, length, bool, LAND_OP); + APPLY_FUNC(a, b, length, bool, LAND_OP) + } else { + xbt_die("Failed to apply LAND_OP to type %s", (*datatype)->name); } } static void lor_func(void *a, void *b, int *length, MPI_Datatype * datatype) { if (*datatype == MPI_CHAR) { - APPLY_FUNC(a, b, length, char, LOR_OP); + APPLY_FUNC(a, b, length, char, LOR_OP) } else if (*datatype == MPI_SHORT) { - APPLY_FUNC(a, b, length, short, LOR_OP); + APPLY_FUNC(a, b, length, short, LOR_OP) } else if (*datatype == MPI_INT) { - APPLY_FUNC(a, b, length, int, LOR_OP); + APPLY_FUNC(a, b, length, int, LOR_OP) } else if (*datatype == MPI_LONG) { - APPLY_FUNC(a, b, length, long, LOR_OP); + APPLY_FUNC(a, b, length, long, LOR_OP) } else if (*datatype == MPI_UNSIGNED_SHORT) { - APPLY_FUNC(a, b, length, unsigned short, LOR_OP); + APPLY_FUNC(a, b, length, unsigned short, LOR_OP) } else if (*datatype == MPI_UNSIGNED) { - APPLY_FUNC(a, b, length, unsigned int, LOR_OP); + APPLY_FUNC(a, b, length, unsigned int, LOR_OP) } else if (*datatype == MPI_UNSIGNED_LONG) { - APPLY_FUNC(a, b, length, unsigned long, LOR_OP); + APPLY_FUNC(a, b, length, unsigned long, LOR_OP) } else if (*datatype == MPI_UNSIGNED_CHAR) { - APPLY_FUNC(a, b, length, unsigned char, LOR_OP); + APPLY_FUNC(a, b, length, unsigned char, LOR_OP) } else if (*datatype == MPI_C_BOOL) { - APPLY_FUNC(a, b, length, bool, LOR_OP); + APPLY_FUNC(a, b, length, bool, LOR_OP) + } else { + xbt_die("Failed to apply LOR_OP to type %s", (*datatype)->name); } } static void lxor_func(void *a, void *b, int *length, MPI_Datatype * datatype) { if (*datatype == MPI_CHAR) { - APPLY_FUNC(a, b, length, char, LXOR_OP); + APPLY_FUNC(a, b, length, char, LXOR_OP) } else if (*datatype == MPI_SHORT) { - APPLY_FUNC(a, b, length, short, LXOR_OP); + APPLY_FUNC(a, b, length, short, LXOR_OP) } else if (*datatype == MPI_INT) { - APPLY_FUNC(a, b, length, int, LXOR_OP); + APPLY_FUNC(a, b, length, int, LXOR_OP) } else if (*datatype == MPI_LONG) { - APPLY_FUNC(a, b, length, long, LXOR_OP); + APPLY_FUNC(a, b, length, long, LXOR_OP) } else if (*datatype == MPI_UNSIGNED_SHORT) { - APPLY_FUNC(a, b, length, unsigned short, LXOR_OP); + APPLY_FUNC(a, b, length, unsigned short, LXOR_OP) } else if (*datatype == MPI_UNSIGNED) { - APPLY_FUNC(a, b, length, unsigned int, LXOR_OP); + APPLY_FUNC(a, b, length, unsigned int, LXOR_OP) } else if (*datatype == MPI_UNSIGNED_LONG) { - APPLY_FUNC(a, b, length, unsigned long, LXOR_OP); + APPLY_FUNC(a, b, length, unsigned long, LXOR_OP) } else if (*datatype == MPI_UNSIGNED_CHAR) { - APPLY_FUNC(a, b, length, unsigned char, LXOR_OP); + APPLY_FUNC(a, b, length, unsigned char, LXOR_OP) } else if (*datatype == MPI_C_BOOL) { - APPLY_FUNC(a, b, length, bool, LXOR_OP); + APPLY_FUNC(a, b, length, bool, LXOR_OP) + } else { + xbt_die("Failed to apply LXOR_OP to type %s", (*datatype)->name); } } static void band_func(void *a, void *b, int *length, MPI_Datatype * datatype) { if (*datatype == MPI_CHAR) { - APPLY_FUNC(a, b, length, char, BAND_OP); + APPLY_FUNC(a, b, length, char, BAND_OP) }else if (*datatype == MPI_SHORT) { - APPLY_FUNC(a, b, length, short, BAND_OP); + APPLY_FUNC(a, b, length, short, BAND_OP) } else if (*datatype == MPI_INT) { - APPLY_FUNC(a, b, length, int, BAND_OP); + APPLY_FUNC(a, b, length, int, BAND_OP) } else if (*datatype == MPI_LONG) { - APPLY_FUNC(a, b, length, long, BAND_OP); + APPLY_FUNC(a, b, length, long, BAND_OP) } else if (*datatype == MPI_UNSIGNED_SHORT) { - APPLY_FUNC(a, b, length, unsigned short, BAND_OP); + APPLY_FUNC(a, b, length, unsigned short, BAND_OP) } else if (*datatype == MPI_UNSIGNED) { - APPLY_FUNC(a, b, length, unsigned int, BAND_OP); + APPLY_FUNC(a, b, length, unsigned int, BAND_OP) } else if (*datatype == MPI_UNSIGNED_LONG) { - APPLY_FUNC(a, b, length, unsigned long, BAND_OP); + APPLY_FUNC(a, b, length, unsigned long, BAND_OP) } else if (*datatype == MPI_UNSIGNED_CHAR) { - APPLY_FUNC(a, b, length, unsigned char, BAND_OP); + APPLY_FUNC(a, b, length, unsigned char, BAND_OP) } else if (*datatype == MPI_BYTE) { - APPLY_FUNC(a, b, length, uint8_t, BAND_OP); + APPLY_FUNC(a, b, length, uint8_t, BAND_OP) + } else { + xbt_die("Failed to apply BAND_OP to type %s", (*datatype)->name); } } static void bor_func(void *a, void *b, int *length, MPI_Datatype * datatype) { if (*datatype == MPI_CHAR) { - APPLY_FUNC(a, b, length, char, BOR_OP); + APPLY_FUNC(a, b, length, char, BOR_OP) } else if (*datatype == MPI_SHORT) { - APPLY_FUNC(a, b, length, short, BOR_OP); + APPLY_FUNC(a, b, length, short, BOR_OP) } else if (*datatype == MPI_INT) { - APPLY_FUNC(a, b, length, int, BOR_OP); + APPLY_FUNC(a, b, length, int, BOR_OP) } else if (*datatype == MPI_LONG) { - APPLY_FUNC(a, b, length, long, BOR_OP); + APPLY_FUNC(a, b, length, long, BOR_OP) } else if (*datatype == MPI_UNSIGNED_SHORT) { - APPLY_FUNC(a, b, length, unsigned short, BOR_OP); + APPLY_FUNC(a, b, length, unsigned short, BOR_OP) } else if (*datatype == MPI_UNSIGNED) { - APPLY_FUNC(a, b, length, unsigned int, BOR_OP); + APPLY_FUNC(a, b, length, unsigned int, BOR_OP) } else if (*datatype == MPI_UNSIGNED_LONG) { - APPLY_FUNC(a, b, length, unsigned long, BOR_OP); + APPLY_FUNC(a, b, length, unsigned long, BOR_OP) } else if (*datatype == MPI_UNSIGNED_CHAR) { - APPLY_FUNC(a, b, length, unsigned char, BOR_OP); + APPLY_FUNC(a, b, length, unsigned char, BOR_OP) } else if (*datatype == MPI_BYTE) { - APPLY_FUNC(a, b, length, uint8_t, BOR_OP); + APPLY_FUNC(a, b, length, uint8_t, BOR_OP) + } else { + xbt_die("Failed to apply BOR_OP to type %s", (*datatype)->name); } } static void bxor_func(void *a, void *b, int *length, MPI_Datatype * datatype) { if (*datatype == MPI_CHAR) { - APPLY_FUNC(a, b, length, char, BXOR_OP); + APPLY_FUNC(a, b, length, char, BXOR_OP) } else if (*datatype == MPI_SHORT) { - APPLY_FUNC(a, b, length, short, BXOR_OP); + APPLY_FUNC(a, b, length, short, BXOR_OP) } else if (*datatype == MPI_INT) { - APPLY_FUNC(a, b, length, int, BXOR_OP); + APPLY_FUNC(a, b, length, int, BXOR_OP) } else if (*datatype == MPI_LONG) { - APPLY_FUNC(a, b, length, long, BXOR_OP); + APPLY_FUNC(a, b, length, long, BXOR_OP) } else if (*datatype == MPI_UNSIGNED_SHORT) { - APPLY_FUNC(a, b, length, unsigned short, BXOR_OP); + APPLY_FUNC(a, b, length, unsigned short, BXOR_OP) } else if (*datatype == MPI_UNSIGNED) { - APPLY_FUNC(a, b, length, unsigned int, BXOR_OP); + APPLY_FUNC(a, b, length, unsigned int, BXOR_OP) } else if (*datatype == MPI_UNSIGNED_LONG) { - APPLY_FUNC(a, b, length, unsigned long, BXOR_OP); + APPLY_FUNC(a, b, length, unsigned long, BXOR_OP) } else if (*datatype == MPI_UNSIGNED_CHAR) { - APPLY_FUNC(a, b, length, unsigned char, BXOR_OP); + APPLY_FUNC(a, b, length, unsigned char, BXOR_OP) } else if (*datatype == MPI_BYTE) { - APPLY_FUNC(a, b, length, uint8_t, BXOR_OP); + APPLY_FUNC(a, b, length, uint8_t, BXOR_OP) + } else { + xbt_die("Failed to apply BXOR_OP to type %s", (*datatype)->name); } } static void minloc_func(void *a, void *b, int *length, MPI_Datatype * datatype) { if (*datatype == MPI_FLOAT_INT) { - APPLY_FUNC(a, b, length, float_int, MINLOC_OP); + APPLY_FUNC(a, b, length, float_int, MINLOC_OP) } else if (*datatype == MPI_LONG_INT) { - APPLY_FUNC(a, b, length, long_int, MINLOC_OP); + APPLY_FUNC(a, b, length, long_int, MINLOC_OP) } else if (*datatype == MPI_DOUBLE_INT) { - APPLY_FUNC(a, b, length, double_int, MINLOC_OP); + APPLY_FUNC(a, b, length, double_int, MINLOC_OP) } else if (*datatype == MPI_SHORT_INT) { - APPLY_FUNC(a, b, length, short_int, MINLOC_OP); + APPLY_FUNC(a, b, length, short_int, MINLOC_OP) } else if (*datatype == MPI_2LONG) { - APPLY_FUNC(a, b, length, long_long, MINLOC_OP); + APPLY_FUNC(a, b, length, long_long, MINLOC_OP) } else if (*datatype == MPI_2INT) { - APPLY_FUNC(a, b, length, int_int, MINLOC_OP); + APPLY_FUNC(a, b, length, int_int, MINLOC_OP) } else if (*datatype == MPI_LONG_DOUBLE_INT) { - APPLY_FUNC(a, b, length, long_double_int, MINLOC_OP); + APPLY_FUNC(a, b, length, long_double_int, MINLOC_OP) } else if (*datatype == MPI_2FLOAT) { - APPLY_FUNC(a, b, length, float_float, MINLOC_OP); + APPLY_FUNC(a, b, length, float_float, MINLOC_OP) } else if (*datatype == MPI_2DOUBLE) { - APPLY_FUNC(a, b, length, double_double, MINLOC_OP); + APPLY_FUNC(a, b, length, double_double, MINLOC_OP) + } else { + xbt_die("Failed to apply MINLOC_OP to type %s", (*datatype)->name); } } static void maxloc_func(void *a, void *b, int *length, MPI_Datatype * datatype) { if (*datatype == MPI_FLOAT_INT) { - APPLY_FUNC(a, b, length, float_int, MAXLOC_OP); + APPLY_FUNC(a, b, length, float_int, MAXLOC_OP) } else if (*datatype == MPI_LONG_INT) { - APPLY_FUNC(a, b, length, long_int, MAXLOC_OP); + APPLY_FUNC(a, b, length, long_int, MAXLOC_OP) } else if (*datatype == MPI_DOUBLE_INT) { - APPLY_FUNC(a, b, length, double_int, MAXLOC_OP); + APPLY_FUNC(a, b, length, double_int, MAXLOC_OP) } else if (*datatype == MPI_SHORT_INT) { - APPLY_FUNC(a, b, length, short_int, MAXLOC_OP); + APPLY_FUNC(a, b, length, short_int, MAXLOC_OP) } else if (*datatype == MPI_2LONG) { - APPLY_FUNC(a, b, length, long_long, MAXLOC_OP); + APPLY_FUNC(a, b, length, long_long, MAXLOC_OP) } else if (*datatype == MPI_2INT) { - APPLY_FUNC(a, b, length, int_int, MAXLOC_OP); + APPLY_FUNC(a, b, length, int_int, MAXLOC_OP) } else if (*datatype == MPI_LONG_DOUBLE_INT) { - APPLY_FUNC(a, b, length, long_double_int, MAXLOC_OP); + APPLY_FUNC(a, b, length, long_double_int, MAXLOC_OP) } else if (*datatype == MPI_2FLOAT) { - APPLY_FUNC(a, b, length, float_float, MAXLOC_OP); + APPLY_FUNC(a, b, length, float_float, MAXLOC_OP) } else if (*datatype == MPI_2DOUBLE) { - APPLY_FUNC(a, b, length, double_double, MAXLOC_OP); + APPLY_FUNC(a, b, length, double_double, MAXLOC_OP) + } else { + xbt_die("Failed to apply MAXLOC_OP to type %s", (*datatype)->name); } } @@ -1528,7 +1550,7 @@ void smpi_op_destroy(MPI_Op op) xbt_free(op); } -void smpi_op_apply(MPI_Op op, void *invec, void *inoutvec, int *len, MPI_Datatype * datatype) +void smpi_op_apply(MPI_Op op, const void *invec, void *inoutvec, int *len, MPI_Datatype * datatype) { if(op==MPI_OP_NULL) return; @@ -1539,32 +1561,33 @@ void smpi_op_apply(MPI_Op op, void *invec, void *inoutvec, int *len, MPI_Datatyp } if(!smpi_process_get_replaying()) - op->func(invec, inoutvec, len, datatype); + op->func(const_cast(invec), inoutvec, len, datatype); } int smpi_type_attr_delete(MPI_Datatype type, int keyval){ smpi_type_key_elem elem = - static_cast(xbt_dict_get_or_null_ext(smpi_type_keyvals, (const char*)&keyval, sizeof(int))); - if(!elem) + static_cast(xbt_dict_get_or_null_ext(smpi_type_keyvals, reinterpret_cast(&keyval), sizeof(int))); + if(elem==NULL) return MPI_ERR_ARG; if(elem->delete_fn!=MPI_NULL_DELETE_FN){ void * value; int flag; if(smpi_type_attr_get(type, keyval, &value, &flag)==MPI_SUCCESS){ int ret = elem->delete_fn(type, keyval, value, &flag); - if(ret!=MPI_SUCCESS) return ret; + if(ret!=MPI_SUCCESS) + return ret; } } if(type->attributes==NULL) return MPI_ERR_ARG; - xbt_dict_remove_ext(type->attributes, (const char*)&keyval, sizeof(int)); + xbt_dict_remove_ext(type->attributes, reinterpret_cast(&keyval), sizeof(int)); return MPI_SUCCESS; } int smpi_type_attr_get(MPI_Datatype type, int keyval, void* attr_value, int* flag){ smpi_type_key_elem elem = - static_cast(xbt_dict_get_or_null_ext(smpi_type_keyvals, (const char*)&keyval, sizeof(int))); + static_cast(xbt_dict_get_or_null_ext(smpi_type_keyvals, reinterpret_cast(&keyval), sizeof(int))); if(!elem) return MPI_ERR_ARG; xbt_ex_t ex; @@ -1573,7 +1596,7 @@ int smpi_type_attr_get(MPI_Datatype type, int keyval, void* attr_value, int* fla return MPI_SUCCESS; } TRY { - *(void**)attr_value = xbt_dict_get_ext(type->attributes, (const char*)&keyval, sizeof(int)); + *static_cast(attr_value) = xbt_dict_get_ext(type->attributes, reinterpret_cast(&keyval), sizeof(int)); *flag=1; } CATCH(ex) { @@ -1587,20 +1610,21 @@ int smpi_type_attr_put(MPI_Datatype type, int keyval, void* attr_value){ if(!smpi_type_keyvals) smpi_type_keyvals = xbt_dict_new(); smpi_type_key_elem elem = - static_cast(xbt_dict_get_or_null_ext(smpi_type_keyvals, (const char*)&keyval, sizeof(int))); - if(!elem ) + static_cast(xbt_dict_get_or_null_ext(smpi_type_keyvals, reinterpret_cast(&keyval), sizeof(int))); + if(elem==NULL) return MPI_ERR_ARG; int flag; void* value; smpi_type_attr_get(type, keyval, &value, &flag); if(flag && elem->delete_fn!=MPI_NULL_DELETE_FN){ int ret = elem->delete_fn(type, keyval, value, &flag); - if(ret!=MPI_SUCCESS) return ret; + if(ret!=MPI_SUCCESS) + return ret; } if(type->attributes==NULL) type->attributes=xbt_dict_new(); - xbt_dict_set_ext(type->attributes, (const char*)&keyval, sizeof(int), attr_value, NULL); + xbt_dict_set_ext(type->attributes, reinterpret_cast(&keyval), sizeof(int), attr_value, NULL); return MPI_SUCCESS; } @@ -1615,18 +1639,18 @@ int smpi_type_keyval_create(MPI_Type_copy_attr_function* copy_fn, MPI_Type_delet value->delete_fn=delete_fn; *keyval = type_keyval_id; - xbt_dict_set_ext(smpi_type_keyvals,(const char*)keyval, sizeof(int),(void*)value, NULL); + xbt_dict_set_ext(smpi_type_keyvals,reinterpret_cast(keyval), sizeof(int),reinterpret_cast(value), NULL); type_keyval_id++; return MPI_SUCCESS; } int smpi_type_keyval_free(int* keyval){ smpi_type_key_elem elem = - static_cast(xbt_dict_get_or_null_ext(smpi_type_keyvals, (const char*)keyval, sizeof(int))); + static_cast(xbt_dict_get_or_null_ext(smpi_type_keyvals, reinterpret_cast(keyval), sizeof(int))); if(!elem){ return MPI_ERR_ARG; } - xbt_dict_remove_ext(smpi_type_keyvals, (const char*)keyval, sizeof(int)); + xbt_dict_remove_ext(smpi_type_keyvals, reinterpret_cast(keyval), sizeof(int)); xbt_free(elem); return MPI_SUCCESS; } @@ -1635,7 +1659,7 @@ int smpi_mpi_pack(void* inbuf, int incount, MPI_Datatype type, void* outbuf, int size_t size = smpi_datatype_size(type); if (outcount - *position < incount*static_cast(size)) return MPI_ERR_BUFFER; - smpi_datatype_copy(inbuf, incount, type, (char*)outbuf + *position, outcount, MPI_CHAR); + smpi_datatype_copy(inbuf, incount, type, static_cast(outbuf) + *position, outcount, MPI_CHAR); *position += incount * size; return MPI_SUCCESS; } @@ -1644,7 +1668,7 @@ int smpi_mpi_unpack(void* inbuf, int insize, int* position, void* outbuf, int ou int size = static_cast(smpi_datatype_size(type)); if (outcount*size> insize) return MPI_ERR_BUFFER; - smpi_datatype_copy((char*)inbuf + *position, insize, MPI_CHAR, outbuf, outcount, type); + smpi_datatype_copy(static_cast(inbuf) + *position, insize, MPI_CHAR, outbuf, outcount, type); *position += outcount * size; return MPI_SUCCESS; } diff --git a/src/smpi/smpi_pmpi.cpp b/src/smpi/smpi_pmpi.cpp index 4d8771755b..83213f4b29 100644 --- a/src/smpi/smpi_pmpi.cpp +++ b/src/smpi/smpi_pmpi.cpp @@ -138,10 +138,10 @@ int PMPI_Address(void *location, MPI_Aint * address) { int retval = 0; - if (!address) { + if (address==NULL) { retval = MPI_ERR_ARG; } else { - *address = (MPI_Aint) location; + *address = reinterpret_cast(location); retval = MPI_SUCCESS; } return retval; @@ -174,7 +174,7 @@ int PMPI_Type_size(MPI_Datatype datatype, int *size) } else if (size == NULL) { retval = MPI_ERR_ARG; } else { - *size = (int) smpi_datatype_size(datatype); + *size = static_cast(smpi_datatype_size(datatype)); retval = MPI_SUCCESS; } return retval; @@ -444,7 +444,8 @@ int PMPI_Group_difference(MPI_Group group1, MPI_Group group2, MPI_Group * newgro } else if (newgroup == NULL) { retval = MPI_ERR_ARG; } else { - size = size2 = smpi_group_size(group1); + size = smpi_group_size(group1); + size2 = size; for (i = 0; i < size2; i++) { proc1 = smpi_group_index(group1, i); proc2 = smpi_group_rank(group2, proc1); @@ -851,7 +852,7 @@ int PMPI_Send_init(void *buf, int count, MPI_Datatype datatype, int dst, int tag retval = MPI_SUCCESS; } smpi_bench_begin(); - if (retval != MPI_SUCCESS && request) + if (retval != MPI_SUCCESS && request != NULL) *request = MPI_REQUEST_NULL; return retval; } @@ -874,7 +875,7 @@ int PMPI_Recv_init(void *buf, int count, MPI_Datatype datatype, int src, int tag retval = MPI_SUCCESS; } smpi_bench_begin(); - if (retval != MPI_SUCCESS && request) + if (retval != MPI_SUCCESS && request != NULL) *request = MPI_REQUEST_NULL; return retval; } @@ -897,7 +898,7 @@ int PMPI_Ssend_init(void* buf, int count, MPI_Datatype datatype, int dst, int ta retval = MPI_SUCCESS; } smpi_bench_begin(); - if (retval != MPI_SUCCESS && request) + if (retval != MPI_SUCCESS && request != NULL) *request = MPI_REQUEST_NULL; return retval; } @@ -969,9 +970,7 @@ int PMPI_Irecv(void *buf, int count, MPI_Datatype datatype, int src, int tag, MP retval = MPI_SUCCESS; } else if (src!=MPI_ANY_SOURCE && (src >= smpi_group_size(smpi_comm_group(comm)) || src <0)){ retval = MPI_ERR_RANK; - } else if (count < 0) { - retval = MPI_ERR_COUNT; - } else if (buf==NULL && count > 0) { + } else if ((count < 0) || (buf==NULL && count > 0)) { retval = MPI_ERR_COUNT; } else if (!is_datatype_valid(datatype)) { retval = MPI_ERR_TYPE; @@ -989,7 +988,7 @@ int PMPI_Irecv(void *buf, int count, MPI_Datatype datatype, int src, int tag, MP int known=0; extra->datatype1 = encode_datatype(datatype, &known); int dt_size_send = 1; - if(!known) + if(known==0) dt_size_send = smpi_datatype_size(datatype); extra->send_size = count*dt_size_send; TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, extra); @@ -1002,7 +1001,7 @@ int PMPI_Irecv(void *buf, int count, MPI_Datatype datatype, int src, int tag, MP } smpi_bench_begin(); - if (retval != MPI_SUCCESS && request) + if (retval != MPI_SUCCESS && request != NULL) *request = MPI_REQUEST_NULL; return retval; } @@ -1022,9 +1021,7 @@ int PMPI_Isend(void *buf, int count, MPI_Datatype datatype, int dst, int tag, MP retval = MPI_SUCCESS; } else if (dst >= smpi_group_size(smpi_comm_group(comm)) || dst <0){ retval = MPI_ERR_RANK; - } else if (count < 0) { - retval = MPI_ERR_COUNT; - } else if (buf==NULL && count > 0) { + } else if ((count < 0) || (buf==NULL && count > 0)) { retval = MPI_ERR_COUNT; } else if (!is_datatype_valid(datatype)) { retval = MPI_ERR_TYPE; @@ -1041,7 +1038,7 @@ int PMPI_Isend(void *buf, int count, MPI_Datatype datatype, int dst, int tag, MP int known=0; extra->datatype1 = encode_datatype(datatype, &known); int dt_size_send = 1; - if(!known) + if(known==0) dt_size_send = smpi_datatype_size(datatype); extra->send_size = count*dt_size_send; TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra); @@ -1055,7 +1052,7 @@ int PMPI_Isend(void *buf, int count, MPI_Datatype datatype, int dst, int tag, MP } smpi_bench_begin(); - if (retval != MPI_SUCCESS && request) + if (retval != MPI_SUCCESS && request!=NULL) *request = MPI_REQUEST_NULL; return retval; } @@ -1074,9 +1071,7 @@ int PMPI_Issend(void* buf, int count, MPI_Datatype datatype, int dst, int tag, M retval = MPI_SUCCESS; } else if (dst >= smpi_group_size(smpi_comm_group(comm)) || dst <0){ retval = MPI_ERR_RANK; - } else if (count < 0) { - retval = MPI_ERR_COUNT; - } else if (buf==NULL && count > 0) { + } else if ((count < 0)|| (buf==NULL && count > 0)) { retval = MPI_ERR_COUNT; } else if (!is_datatype_valid(datatype)) { retval = MPI_ERR_TYPE; @@ -1093,7 +1088,7 @@ int PMPI_Issend(void* buf, int count, MPI_Datatype datatype, int dst, int tag, M int known=0; extra->datatype1 = encode_datatype(datatype, &known); int dt_size_send = 1; - if(!known) + if(known==0) dt_size_send = smpi_datatype_size(datatype); extra->send_size = count*dt_size_send; TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra); @@ -1107,7 +1102,7 @@ int PMPI_Issend(void* buf, int count, MPI_Datatype datatype, int dst, int tag, M } smpi_bench_begin(); - if (retval != MPI_SUCCESS && request) + if (retval != MPI_SUCCESS && request!=NULL) *request = MPI_REQUEST_NULL; return retval; } @@ -1125,9 +1120,7 @@ int PMPI_Recv(void *buf, int count, MPI_Datatype datatype, int src, int tag, MPI retval = MPI_SUCCESS; } else if (src!=MPI_ANY_SOURCE && (src >= smpi_group_size(smpi_comm_group(comm)) || src <0)){ retval = MPI_ERR_RANK; - } else if (count < 0) { - retval = MPI_ERR_COUNT; - } else if (buf==NULL && count > 0) { + } else if ((count < 0) || (buf==NULL && count > 0)) { retval = MPI_ERR_COUNT; } else if (!is_datatype_valid(datatype)) { retval = MPI_ERR_TYPE; @@ -1143,7 +1136,7 @@ int PMPI_Recv(void *buf, int count, MPI_Datatype datatype, int src, int tag, MPI int known=0; extra->datatype1 = encode_datatype(datatype, &known); int dt_size_send = 1; - if(!known) + if(known==0) dt_size_send = smpi_datatype_size(datatype); extra->send_size = count*dt_size_send; TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, extra); @@ -1177,9 +1170,7 @@ int PMPI_Send(void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI retval = MPI_SUCCESS; } else if (dst >= smpi_group_size(smpi_comm_group(comm)) || dst <0){ retval = MPI_ERR_RANK; - } else if (count < 0) { - retval = MPI_ERR_COUNT; - } else if (buf==NULL && count > 0) { + } else if ((count < 0) || (buf==NULL && count > 0)) { retval = MPI_ERR_COUNT; } else if (!is_datatype_valid(datatype)) { retval = MPI_ERR_TYPE; @@ -1196,7 +1187,7 @@ int PMPI_Send(void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI int known=0; extra->datatype1 = encode_datatype(datatype, &known); int dt_size_send = 1; - if(!known) + if(known==0) dt_size_send = smpi_datatype_size(datatype); extra->send_size = count*dt_size_send; TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra); @@ -1227,9 +1218,7 @@ int PMPI_Ssend(void* buf, int count, MPI_Datatype datatype, int dst, int tag, MP retval = MPI_SUCCESS; } else if (dst >= smpi_group_size(smpi_comm_group(comm)) || dst <0){ retval = MPI_ERR_RANK; - } else if (count < 0) { - retval = MPI_ERR_COUNT; - } else if (buf==NULL && count > 0) { + } else if ((count < 0) || (buf==NULL && count > 0)) { retval = MPI_ERR_COUNT; } else if (!is_datatype_valid(datatype)){ retval = MPI_ERR_TYPE; @@ -1246,7 +1235,7 @@ int PMPI_Ssend(void* buf, int count, MPI_Datatype datatype, int dst, int tag, MP int known=0; extra->datatype1 = encode_datatype(datatype, &known); int dt_size_send = 1; - if(!known) + if(known==0) dt_size_send = smpi_datatype_size(datatype); extra->send_size = count*dt_size_send; TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra); @@ -1280,9 +1269,8 @@ int PMPI_Sendrecv(void *sendbuf, int sendcount, MPI_Datatype sendtype, int dst, }else if (dst >= smpi_group_size(smpi_comm_group(comm)) || dst <0 || (src!=MPI_ANY_SOURCE && (src >= smpi_group_size(smpi_comm_group(comm)) || src <0))){ retval = MPI_ERR_RANK; - } else if (sendcount < 0 || recvcount<0) { - retval = MPI_ERR_COUNT; - } else if ((sendbuf==NULL && sendcount > 0)||(recvbuf==NULL && recvcount>0)) { + } else if ((sendcount < 0 || recvcount<0) || + (sendbuf==NULL && sendcount > 0) || (recvbuf==NULL && recvcount>0)) { retval = MPI_ERR_COUNT; } else if((sendtag<0 && sendtag != MPI_ANY_TAG)||(recvtag<0 && recvtag != MPI_ANY_TAG)){ retval = MPI_ERR_TAG; @@ -1298,12 +1286,12 @@ int PMPI_Sendrecv(void *sendbuf, int sendcount, MPI_Datatype sendtype, int dst, int known=0; extra->datatype1 = encode_datatype(sendtype, &known); int dt_size_send = 1; - if(!known) + if(known==0) dt_size_send = smpi_datatype_size(sendtype); extra->send_size = sendcount*dt_size_send; extra->datatype2 = encode_datatype(recvtype, &known); int dt_size_recv = 1; - if(!known) + if(known==0) dt_size_recv = smpi_datatype_size(recvtype); extra->recv_size = recvcount*dt_size_recv; @@ -1325,7 +1313,6 @@ int PMPI_Sendrecv(void *sendbuf, int sendcount, MPI_Datatype sendtype, int dst, int PMPI_Sendrecv_replace(void *buf, int count, MPI_Datatype datatype, int dst, int sendtag, int src, int recvtag, MPI_Comm comm, MPI_Status * status) { - //TODO: suboptimal implementation void *recvbuf; int retval = 0; if (!is_datatype_valid(datatype)) { @@ -1356,7 +1343,7 @@ int PMPI_Test(MPI_Request * request, int *flag, MPI_Status * status) smpi_empty_status(status); retval = MPI_SUCCESS; } else { - int rank = request && (*request)->comm != MPI_COMM_NULL ? smpi_process_index() : -1; + int rank = (request!=NULL && (*request)->comm != MPI_COMM_NULL) ? smpi_process_index() : -1; instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type = TRACING_TEST; @@ -1425,9 +1412,7 @@ int PMPI_Iprobe(int source, int tag, MPI_Comm comm, int* flag, MPI_Status* statu int retval = 0; smpi_bench_end(); - if (flag == NULL) { - retval = MPI_ERR_ARG; - } else if (status == NULL) { + if ((flag == NULL) || (status == NULL)) { retval = MPI_ERR_ARG; } else if (comm == MPI_COMM_NULL) { retval = MPI_ERR_COMM; @@ -1458,7 +1443,7 @@ int PMPI_Wait(MPI_Request * request, MPI_Status * status) retval = MPI_SUCCESS; } else { - int rank = request && (*request)->comm != MPI_COMM_NULL ? smpi_process_index() : -1; + int rank = (request!=NULL && (*request)->comm != MPI_COMM_NULL) ? smpi_process_index() : -1; int src_traced = (*request)->src; int dst_traced = (*request)->dst; @@ -1552,7 +1537,6 @@ int PMPI_Waitall(int count, MPI_Request requests[], MPI_Status status[]) int *valid = xbt_new0(int, count); MPI_Comm *comms = xbt_new0(MPI_Comm, count); - //int valid_count = 0; for (i = 0; i < count; i++) { MPI_Request req = requests[i]; if(req!=MPI_REQUEST_NULL){ @@ -1575,7 +1559,6 @@ int PMPI_Waitall(int count, MPI_Request requests[], MPI_Status status[]) for (i = 0; i < count; i++) { if(valid[i]){ - //int src_traced = srcs[*index]; //the src may not have been known at the beginning of the recv (MPI_ANY_SOURCE) int src_traced = srcs[i]; int dst_traced = dsts[i]; @@ -1650,7 +1633,7 @@ int PMPI_Bcast(void *buf, int count, MPI_Datatype datatype, int root, MPI_Comm c int known=0; extra->datatype1 = encode_datatype(datatype, &known); int dt_size_send = 1; - if(!known) + if(known==0) dt_size_send = smpi_datatype_size(datatype); extra->send_size = count*dt_size_send; TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__, extra); @@ -1705,7 +1688,7 @@ int PMPI_Gather(void *sendbuf, int sendcount, MPI_Datatype sendtype,void *recvbu retval = MPI_ERR_COUNT; } else { - char* sendtmpbuf = (char*) sendbuf; + char* sendtmpbuf = static_cast(sendbuf); int sendtmpcount = sendcount; MPI_Datatype sendtmptype = sendtype; if( (smpi_comm_rank(comm) == root) && (sendbuf == MPI_IN_PLACE )) { @@ -1720,12 +1703,12 @@ int PMPI_Gather(void *sendbuf, int sendcount, MPI_Datatype sendtype,void *recvbu int known=0; extra->datatype1 = encode_datatype(sendtmptype, &known); int dt_size_send = 1; - if(!known) + if(known==0) dt_size_send = smpi_datatype_size(sendtmptype); extra->send_size = sendtmpcount*dt_size_send; extra->datatype2 = encode_datatype(recvtype, &known); int dt_size_recv = 1; - if((smpi_comm_rank(comm)==root) && !known) + if((smpi_comm_rank(comm)==root) && known==0) dt_size_recv = smpi_datatype_size(recvtype); extra->recv_size = recvcount*dt_size_recv; @@ -1758,7 +1741,7 @@ int PMPI_Gatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recv } else if (recvcounts == NULL || displs == NULL) { retval = MPI_ERR_ARG; } else { - char* sendtmpbuf = (char*) sendbuf; + char* sendtmpbuf = static_cast(sendbuf); int sendtmpcount = sendcount; MPI_Datatype sendtmptype = sendtype; if( (smpi_comm_rank(comm) == root) && (sendbuf == MPI_IN_PLACE )) { @@ -1777,12 +1760,12 @@ int PMPI_Gatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recv int known=0; extra->datatype1 = encode_datatype(sendtmptype, &known); int dt_size_send = 1; - if(!known) + if(known==0) dt_size_send = smpi_datatype_size(sendtype); extra->send_size = sendtmpcount*dt_size_send; extra->datatype2 = encode_datatype(recvtype, &known); int dt_size_recv = 1; - if(!known) + if(known==0) dt_size_recv = smpi_datatype_size(recvtype); if((smpi_comm_rank(comm)==root)){ extra->recvcounts= xbt_new(int,size); @@ -1817,7 +1800,7 @@ int PMPI_Allgather(void *sendbuf, int sendcount, MPI_Datatype sendtype, retval = MPI_ERR_COUNT; } else { if(sendbuf == MPI_IN_PLACE) { - sendbuf=((char*)recvbuf)+smpi_datatype_get_extent(recvtype)*recvcount*smpi_comm_rank(comm); + sendbuf=static_cast(recvbuf)+smpi_datatype_get_extent(recvtype)*recvcount*smpi_comm_rank(comm); sendcount=recvcount; sendtype=recvtype; } @@ -1827,12 +1810,12 @@ int PMPI_Allgather(void *sendbuf, int sendcount, MPI_Datatype sendtype, int known=0; extra->datatype1 = encode_datatype(sendtype, &known); int dt_size_send = 1; - if(!known) + if(known==0) dt_size_send = smpi_datatype_size(sendtype); extra->send_size = sendcount*dt_size_send; extra->datatype2 = encode_datatype(recvtype, &known); int dt_size_recv = 1; - if(!known) + if(known==0) dt_size_recv = smpi_datatype_size(recvtype); extra->recv_size = recvcount*dt_size_recv; @@ -1865,7 +1848,7 @@ int PMPI_Allgatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype, } else { if(sendbuf == MPI_IN_PLACE) { - sendbuf=((char*)recvbuf)+smpi_datatype_get_extent(recvtype)*displs[smpi_comm_rank(comm)]; + sendbuf=static_cast(recvbuf)+smpi_datatype_get_extent(recvtype)*displs[smpi_comm_rank(comm)]; sendcount=recvcounts[smpi_comm_rank(comm)]; sendtype=recvtype; } @@ -1878,12 +1861,12 @@ int PMPI_Allgatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype, int known=0; extra->datatype1 = encode_datatype(sendtype, &known); int dt_size_send = 1; - if(!known) + if(known==0) dt_size_send = smpi_datatype_size(sendtype); extra->send_size = sendcount*dt_size_send; extra->datatype2 = encode_datatype(recvtype, &known); int dt_size_recv = 1; - if(!known) + if(known==0) dt_size_recv = smpi_datatype_size(recvtype); extra->recvcounts= xbt_new(int, size); for(i=0; i< size; i++)//copy data to avoid bad free @@ -1929,12 +1912,12 @@ int PMPI_Scatter(void *sendbuf, int sendcount, MPI_Datatype sendtype, int known=0; extra->datatype1 = encode_datatype(sendtype, &known); int dt_size_send = 1; - if((smpi_comm_rank(comm)==root) && !known) + if((smpi_comm_rank(comm)==root) && known==0) dt_size_send = smpi_datatype_size(sendtype); extra->send_size = sendcount*dt_size_send; extra->datatype2 = encode_datatype(recvtype, &known); int dt_size_recv = 1; - if(!known) + if(known==0) dt_size_recv = smpi_datatype_size(recvtype); extra->recv_size = recvcount*dt_size_recv; TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__,extra); @@ -1978,7 +1961,7 @@ int PMPI_Scatterv(void *sendbuf, int *sendcounts, int *displs, int known=0; extra->datatype1 = encode_datatype(sendtype, &known); int dt_size_send = 1; - if(!known) + if(known==0) dt_size_send = smpi_datatype_size(sendtype); if((smpi_comm_rank(comm)==root)){ extra->sendcounts= xbt_new(int, size); @@ -1987,7 +1970,7 @@ int PMPI_Scatterv(void *sendbuf, int *sendcounts, int *displs, } extra->datatype2 = encode_datatype(recvtype, &known); int dt_size_recv = 1; - if(!known) + if(known==0) dt_size_recv = smpi_datatype_size(recvtype); extra->recv_size = recvcount*dt_size_recv; TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__,extra); @@ -2020,7 +2003,7 @@ int PMPI_Reduce(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, int known=0; extra->datatype1 = encode_datatype(datatype, &known); int dt_size_send = 1; - if(!known) + if(known==0) dt_size_send = smpi_datatype_size(datatype); extra->send_size = count*dt_size_send; extra->root = root_traced; @@ -2065,9 +2048,9 @@ int PMPI_Allreduce(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatyp retval = MPI_ERR_OP; } else { - char* sendtmpbuf = (char*) sendbuf; + char* sendtmpbuf = static_cast(sendbuf); if( sendbuf == MPI_IN_PLACE ) { - sendtmpbuf = (char *)xbt_malloc(count*smpi_datatype_get_extent(datatype)); + sendtmpbuf = static_cast(xbt_malloc(count*smpi_datatype_get_extent(datatype))); smpi_datatype_copy(recvbuf, count, datatype,sendtmpbuf, count, datatype); } int rank = comm != MPI_COMM_NULL ? smpi_process_index() : -1; @@ -2076,7 +2059,7 @@ int PMPI_Allreduce(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatyp int known=0; extra->datatype1 = encode_datatype(datatype, &known); int dt_size_send = 1; - if(!known) + if(known==0) dt_size_send = smpi_datatype_size(datatype); extra->send_size = count*dt_size_send; @@ -2114,7 +2097,7 @@ int PMPI_Scan(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MP int known=0; extra->datatype1 = encode_datatype(datatype, &known); int dt_size_send = 1; - if(!known) + if(known==0) dt_size_send = smpi_datatype_size(datatype); extra->send_size = count*dt_size_send; @@ -2148,7 +2131,7 @@ int PMPI_Exscan(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, int known=0; extra->datatype1 = encode_datatype(datatype, &known); int dt_size_send = 1; - if(!known) + if(known==0) dt_size_send = smpi_datatype_size(datatype); extra->send_size = count*dt_size_send; TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra); @@ -2185,7 +2168,7 @@ int PMPI_Reduce_scatter(void *sendbuf, void *recvbuf, int *recvcounts, MPI_Datat int known=0; extra->datatype1 = encode_datatype(datatype, &known); int dt_size_send = 1; - if(!known) + if(known==0) dt_size_send = smpi_datatype_size(datatype); extra->send_size = 0; extra->recvcounts= xbt_new(int, size); @@ -2230,7 +2213,7 @@ int PMPI_Reduce_scatter_block(void *sendbuf, void *recvbuf, int recvcount, int known=0; extra->datatype1 = encode_datatype(datatype, &known); int dt_size_send = 1; - if(!known) + if(known==0) dt_size_send = smpi_datatype_size(datatype); extra->send_size = 0; extra->recvcounts= xbt_new(int, count); @@ -2239,8 +2222,9 @@ int PMPI_Reduce_scatter_block(void *sendbuf, void *recvbuf, int recvcount, TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra); - int* recvcounts=(int*)xbt_malloc(count); - for (i=0; i(xbt_malloc(count)); + for (i=0; itype = TRACING_ALLTOALL; int known=0; extra->datatype1 = encode_datatype(sendtype, &known); - if(!known) + if(known==0) extra->send_size = sendcount*smpi_datatype_size(sendtype); else extra->send_size = sendcount; extra->datatype2 = encode_datatype(recvtype, &known); - if(!known) + if(known==0) extra->recv_size = recvcount*smpi_datatype_size(recvtype); else extra->recv_size = recvcount; @@ -2316,11 +2300,11 @@ int PMPI_Alltoallv(void *sendbuf, int *sendcounts, int *senddisps,MPI_Datatype s int known=0; extra->datatype1 = encode_datatype(sendtype, &known); int dt_size_send = 1; - if(!known) + if(known==0) dt_size_send = smpi_datatype_size(sendtype); int dt_size_recv = 1; extra->datatype2 = encode_datatype(recvtype, &known); - if(!known) + if(known==0) dt_size_recv = smpi_datatype_size(recvtype); for(i=0; i< size; i++){//copy data to avoid bad free extra->send_size += sendcounts[i]*dt_size_send; @@ -2466,8 +2450,9 @@ int PMPI_Type_create_indexed_block(int count, int blocklength, int* indices, MPI } else if (count<0){ retval = MPI_ERR_COUNT; } else { - int* blocklens=(int*)xbt_malloc(blocklength*count); - for (i=0; i(xbt_malloc(blocklength*count)); + for (i=0; i 0){ + } else if ((origin_count < 0 || target_count < 0) || + (origin_addr==NULL && origin_count > 0)){ retval = MPI_ERR_COUNT; } else if ((!is_datatype_valid(origin_datatype)) || (!is_datatype_valid(target_datatype))) { retval = MPI_ERR_TYPE; @@ -2772,9 +2756,8 @@ int PMPI_Put( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, retval = MPI_ERR_RANK; } else if (target_disp <0){ retval = MPI_ERR_ARG; - } else if (origin_count < 0 || target_count < 0) { - retval = MPI_ERR_COUNT; - } else if (origin_addr==NULL && origin_count > 0){ + } else if ((origin_count < 0 || target_count < 0) || + (origin_addr==NULL && origin_count > 0)){ retval = MPI_ERR_COUNT; } else if ((!is_datatype_valid(origin_datatype)) || (!is_datatype_valid(target_datatype))) { retval = MPI_ERR_TYPE; @@ -2807,9 +2790,8 @@ int PMPI_Accumulate( void *origin_addr, int origin_count, MPI_Datatype origin_da retval = MPI_ERR_RANK; } else if (target_disp <0){ retval = MPI_ERR_ARG; - } else if (origin_count < 0 || target_count < 0) { - retval = MPI_ERR_COUNT; - } else if (origin_addr==NULL && origin_count > 0){ + } else if ((origin_count < 0 || target_count < 0) || + (origin_addr==NULL && origin_count > 0)){ retval = MPI_ERR_COUNT; } else if ((!is_datatype_valid(origin_datatype)) || (!is_datatype_valid(target_datatype))) { @@ -2906,10 +2888,10 @@ int PMPI_Win_wait(MPI_Win win){ int PMPI_Alloc_mem(MPI_Aint size, MPI_Info info, void *baseptr){ void *ptr = xbt_malloc(size); - if(!ptr) + if(ptr==NULL) return MPI_ERR_NO_MEM; else { - *(void **)baseptr = ptr; + *static_cast(baseptr) = ptr; return MPI_SUCCESS; } } @@ -3038,23 +3020,23 @@ int PMPI_Attr_get(MPI_Comm comm, int keyval, void* attr_value, int* flag) { case MPI_IO: case MPI_APPNUM: *flag = 1; - *(int**)attr_value = &zero; + *static_cast(attr_value) = &zero; return MPI_SUCCESS; case MPI_UNIVERSE_SIZE: *flag = 1; - *(int**)attr_value = &smpi_universe_size; + *static_cast(attr_value) = &smpi_universe_size; return MPI_SUCCESS; case MPI_LASTUSEDCODE: *flag = 1; - *(int**)attr_value = &last_used_code; + *static_cast(attr_value) = &last_used_code; return MPI_SUCCESS; case MPI_TAG_UB: *flag=1; - *(int**)attr_value = &tag_ub; + *static_cast(attr_value) = &tag_ub; return MPI_SUCCESS; case MPI_WTIME_IS_GLOBAL: *flag = 1; - *(int**)attr_value = &one; + *static_cast(attr_value) = &one; return MPI_SUCCESS; default: return smpi_comm_attr_get(comm, keyval, attr_value, flag); @@ -3165,7 +3147,7 @@ int PMPI_Info_get(MPI_Info info,char *key,int valuelen, char *value, int *flag){ return MPI_ERR_ARG; if (value == NULL) return MPI_ERR_INFO_VALUE; - char* tmpvalue=(char*)xbt_dict_get_or_null(info->info_dict, key); + char* tmpvalue=static_cast(xbt_dict_get_or_null(info->info_dict, key)); if(tmpvalue){ memset(value, 0, valuelen); memcpy(value,tmpvalue, (strlen(tmpvalue) + 1 < static_cast(valuelen)) ? strlen(tmpvalue) + 1 : valuelen); @@ -3184,7 +3166,7 @@ int PMPI_Info_dup(MPI_Info info, MPI_Info *newinfo){ int *key; void* data; xbt_dict_foreach(info->info_dict,cursor,key,data){ - xbt_dict_set((*newinfo)->info_dict, (char*)key, data, NULL); + xbt_dict_set((*newinfo)->info_dict, reinterpret_cast(key), data, NULL); } return MPI_SUCCESS; } @@ -3219,7 +3201,7 @@ int PMPI_Info_get_nthkey( MPI_Info info, int n, char *key){ int num=0; xbt_dict_foreach(info->info_dict,cursor,keyn,data){ if(num==n){ - strcpy(key,keyn); + strncpy(key,keyn,strlen(keyn)+1); xbt_dict_cursor_free(&cursor); return MPI_SUCCESS; } diff --git a/src/smpi/smpi_replay.cpp b/src/smpi/smpi_replay.cpp index 7975f1c1aa..3929b82947 100644 --- a/src/smpi/smpi_replay.cpp +++ b/src/smpi/smpi_replay.cpp @@ -29,15 +29,15 @@ static void log_timed_action (const char *const *action, double clock){ if (XBT_LOG_ISENABLED(smpi_replay, xbt_log_priority_verbose)){ char *name = xbt_str_join_array(action, " "); XBT_VERB("%s %f", name, smpi_process_simulated_elapsed()-clock); - free(name); + xbt_free(name); } } static xbt_dynar_t get_reqq_self() { char * key = bprintf("%d", smpi_process_index()); - xbt_dynar_t dynar_mpi_request = (xbt_dynar_t) xbt_dict_get(reqq, key); - free(key); + xbt_dynar_t dynar_mpi_request = static_cast(xbt_dict_get(reqq, key)); + xbt_free(key); return dynar_mpi_request; } @@ -46,7 +46,7 @@ static void set_reqq_self(xbt_dynar_t mpi_request) { char * key = bprintf("%d", smpi_process_index()); xbt_dict_set(reqq, key, mpi_request, free); - free(key); + xbt_free(key); } //allocate a single buffer for all sends, growing it if needed @@ -124,7 +124,8 @@ const char* encode_datatype(MPI_Datatype datatype, int* known) { //default type for output is set to MPI_BYTE // MPI_DEFAULT_TYPE is not set for output, use directly MPI_BYTE - if(known)*known=1; + if(known!=NULL) + *known=1; if (datatype==MPI_BYTE){ return ""; } @@ -141,7 +142,8 @@ const char* encode_datatype(MPI_Datatype datatype, int* known) if(datatype==MPI_FLOAT) return "5"; //tell that the datatype is not handled by replay, and that its size should be measured and replayed as size*MPI_BYTE - if(known)*known=0; + if(known!=NULL) + *known=0; // default - not implemented. // do not warn here as we pass in this function even for other trace formats return "-1"; @@ -161,8 +163,9 @@ const char* encode_datatype(MPI_Datatype datatype, int* known) static void action_init(const char *const *action) { XBT_DEBUG("Initialize the counters"); - CHECK_ACTION_PARAMS(action, 0, 1); - if(action[2]) MPI_DEFAULT_TYPE= MPI_DOUBLE; // default MPE dataype + CHECK_ACTION_PARAMS(action, 0, 1) + if(action[2]) + MPI_DEFAULT_TYPE=MPI_DOUBLE; // default MPE dataype else MPI_DEFAULT_TYPE= MPI_BYTE; // default TAU datatype /* start a simulated timer */ @@ -170,7 +173,7 @@ static void action_init(const char *const *action) /*initialize the number of active processes */ active_processes = smpi_process_count(); - if (!reqq) { + if (reqq==NULL) { reqq = xbt_dict_new(); } @@ -179,6 +182,7 @@ static void action_init(const char *const *action) static void action_finalize(const char *const *action) { + /* do nothing */ } static void action_comm_size(const char *const *action) @@ -205,7 +209,7 @@ static void action_comm_dup(const char *const *action) static void action_compute(const char *const *action) { - CHECK_ACTION_PARAMS(action, 1, 0); + CHECK_ACTION_PARAMS(action, 1, 0) double clock = smpi_process_simulated_elapsed(); double flops= parse_double(action[2]); int rank = smpi_process_index(); @@ -222,16 +226,15 @@ static void action_compute(const char *const *action) static void action_send(const char *const *action) { - CHECK_ACTION_PARAMS(action, 2, 1); + CHECK_ACTION_PARAMS(action, 2, 1) int to = atoi(action[2]); double size=parse_double(action[3]); double clock = smpi_process_simulated_elapsed(); - if(action[4]) { + if(action[4]) MPI_CURRENT_TYPE=decode_datatype(action[4]); - } else { + else MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; - } int rank = smpi_process_index(); @@ -256,14 +259,16 @@ static void action_send(const char *const *action) static void action_Isend(const char *const *action) { - CHECK_ACTION_PARAMS(action, 2, 1); + CHECK_ACTION_PARAMS(action, 2, 1) int to = atoi(action[2]); double size=parse_double(action[3]); double clock = smpi_process_simulated_elapsed(); MPI_Request request; - if(action[4]) MPI_CURRENT_TYPE=decode_datatype(action[4]); - else MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; + if(action[4]) + MPI_CURRENT_TYPE=decode_datatype(action[4]); + else + MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; int rank = smpi_process_index(); int dst_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), to); @@ -289,14 +294,16 @@ static void action_Isend(const char *const *action) } static void action_recv(const char *const *action) { - CHECK_ACTION_PARAMS(action, 2, 1); + CHECK_ACTION_PARAMS(action, 2, 1) int from = atoi(action[2]); double size=parse_double(action[3]); double clock = smpi_process_simulated_elapsed(); MPI_Status status; - if(action[4]) MPI_CURRENT_TYPE=decode_datatype(action[4]); - else MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; + if(action[4]) + MPI_CURRENT_TYPE=decode_datatype(action[4]); + else + MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; int rank = smpi_process_index(); int src_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), from); @@ -310,7 +317,7 @@ static void action_recv(const char *const *action) { TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, extra); //unknow size from the receiver pov - if(size==-1){ + if(size<=0.0){ smpi_mpi_probe(from, 0, MPI_COMM_WORLD, &status); size=status.count; } @@ -327,14 +334,16 @@ static void action_recv(const char *const *action) { static void action_Irecv(const char *const *action) { - CHECK_ACTION_PARAMS(action, 2, 1); + CHECK_ACTION_PARAMS(action, 2, 1) int from = atoi(action[2]); double size=parse_double(action[3]); double clock = smpi_process_simulated_elapsed(); MPI_Request request; - if(action[4]) MPI_CURRENT_TYPE=decode_datatype(action[4]); - else MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; + if(action[4]) + MPI_CURRENT_TYPE=decode_datatype(action[4]); + else + MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; int rank = smpi_process_index(); int src_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), from); @@ -347,7 +356,7 @@ static void action_Irecv(const char *const *action) TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, extra); MPI_Status status; //unknow size from the receiver pov - if(size==-1){ + if(size<=0.0){ smpi_mpi_probe(from, 0, MPI_COMM_WORLD, &status); size=status.count; } @@ -362,7 +371,7 @@ static void action_Irecv(const char *const *action) } static void action_test(const char *const *action){ - CHECK_ACTION_PARAMS(action, 0, 0); + CHECK_ACTION_PARAMS(action, 0, 0) double clock = smpi_process_simulated_elapsed(); MPI_Request request; MPI_Status status; @@ -372,7 +381,7 @@ static void action_test(const char *const *action){ //if request is null here, this may mean that a previous test has succeeded //Different times in traced application and replayed version may lead to this //In this case, ignore the extra calls. - if(request){ + if(request!=NULL){ int rank = smpi_process_index(); instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1); extra->type=TRACING_TEST; @@ -390,7 +399,7 @@ static void action_test(const char *const *action){ } static void action_wait(const char *const *action){ - CHECK_ACTION_PARAMS(action, 0, 0); + CHECK_ACTION_PARAMS(action, 0, 0) double clock = smpi_process_simulated_elapsed(); MPI_Request request; MPI_Status status; @@ -400,7 +409,7 @@ static void action_wait(const char *const *action){ xbt_str_join_array(action," ")); request = xbt_dynar_pop_as(get_reqq_self(),MPI_Request); - if (!request){ + if (request==NULL){ /* Assume that the trace is well formed, meaning the comm might have been caught by a MPI_test. Then just return.*/ return; } @@ -424,7 +433,7 @@ static void action_wait(const char *const *action){ } static void action_waitall(const char *const *action){ - CHECK_ACTION_PARAMS(action, 0, 0); + CHECK_ACTION_PARAMS(action, 0, 0) double clock = smpi_process_simulated_elapsed(); int count_requests=0; unsigned int i=0; @@ -443,7 +452,7 @@ static void action_waitall(const char *const *action){ xbt_dynar_t srcs = xbt_dynar_new(sizeof(int), NULL); xbt_dynar_t dsts = xbt_dynar_new(sizeof(int), NULL); xbt_dynar_t recvs = xbt_dynar_new(sizeof(int), NULL); - for (i = 0; (int)i < count_requests; i++) { + for (i = 0; static_cast(i) < count_requests; i++) { if(requests[i]){ int *asrc = xbt_new(int, 1); int *adst = xbt_new(int, 1); @@ -473,7 +482,7 @@ static void action_waitall(const char *const *action){ smpi_mpi_waitall(count_requests, requests, status); - for (i = 0; (int)i < count_requests; i++) { + for (i = 0; static_cast(i) < count_requests; i++) { int src_traced, dst_traced, is_wait_for_receive; xbt_dynar_get_cpy(srcs, i, &src_traced); xbt_dynar_get_cpy(dsts, i, &dst_traced); @@ -487,8 +496,6 @@ static void action_waitall(const char *const *action){ xbt_dynar_free(&srcs); xbt_dynar_free(&dsts); xbt_dynar_free(&recvs); - - //TODO xbt_dynar_free_container(get_reqq_self()); set_reqq_self(xbt_dynar_new(sizeof(MPI_Request),&xbt_free_ref)); } log_timed_action (action, clock); @@ -509,7 +516,7 @@ static void action_barrier(const char *const *action){ static void action_bcast(const char *const *action) { - CHECK_ACTION_PARAMS(action, 1, 2); + CHECK_ACTION_PARAMS(action, 1, 2) double size = parse_double(action[2]); double clock = smpi_process_simulated_elapsed(); int root=0; @@ -542,7 +549,7 @@ static void action_bcast(const char *const *action) static void action_reduce(const char *const *action) { - CHECK_ACTION_PARAMS(action, 2, 2); + CHECK_ACTION_PARAMS(action, 2, 2) double comm_size = parse_double(action[2]); double comp_size = parse_double(action[3]); double clock = smpi_process_simulated_elapsed(); @@ -577,12 +584,14 @@ static void action_reduce(const char *const *action) } static void action_allReduce(const char *const *action) { - CHECK_ACTION_PARAMS(action, 2, 1); + CHECK_ACTION_PARAMS(action, 2, 1) double comm_size = parse_double(action[2]); double comp_size = parse_double(action[3]); - if(action[4]) MPI_CURRENT_TYPE=decode_datatype(action[4]); - else MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; + if(action[4]) + MPI_CURRENT_TYPE=decode_datatype(action[4]); + else + MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE; double clock = smpi_process_simulated_elapsed(); int rank = smpi_process_index(); @@ -603,7 +612,7 @@ static void action_allReduce(const char *const *action) { } static void action_allToAll(const char *const *action) { - CHECK_ACTION_PARAMS(action, 2, 2); //two mandatory (send and recv volumes) + CHECK_ACTION_PARAMS(action, 2, 2) //two mandatory (send and recv volumes) //two optional (corresponding datatypes) double clock = smpi_process_simulated_elapsed(); int comm_size = smpi_comm_size(MPI_COMM_WORLD); @@ -650,7 +659,7 @@ static void action_gather(const char *const *action) { 4) 0 is the send datatype id, see decode_datatype() 5) 0 is the recv datatype id, see decode_datatype() */ - CHECK_ACTION_PARAMS(action, 2, 3); + CHECK_ACTION_PARAMS(action, 2, 3) double clock = smpi_process_simulated_elapsed(); int comm_size = smpi_comm_size(MPI_COMM_WORLD); int send_size = parse_double(action[2]); @@ -703,7 +712,7 @@ static void action_gatherv(const char *const *action) { double clock = smpi_process_simulated_elapsed(); int comm_size = smpi_comm_size(MPI_COMM_WORLD); - CHECK_ACTION_PARAMS(action, comm_size+1, 2); + CHECK_ACTION_PARAMS(action, comm_size+1, 2) int send_size = parse_double(action[2]); int *disps = xbt_new0(int, comm_size); int *recvcounts = xbt_new0(int, comm_size); @@ -726,7 +735,7 @@ static void action_gatherv(const char *const *action) { } int root=atoi(action[3+comm_size]); - int rank = smpi_comm_rank(MPI_COMM_WORLD);; + int rank = smpi_comm_rank(MPI_COMM_WORLD); if(rank==root) recv = smpi_get_tmp_recvbuffer(recv_sum* smpi_datatype_size(MPI_CURRENT_TYPE2)); @@ -764,7 +773,7 @@ static void action_reducescatter(const char *const *action) { We analyze a MPI_Reduce_scatter call to one MPI_Reduce and one MPI_Scatterv. */ double clock = smpi_process_simulated_elapsed(); int comm_size = smpi_comm_size(MPI_COMM_WORLD); - CHECK_ACTION_PARAMS(action, comm_size+1, 1); + CHECK_ACTION_PARAMS(action, comm_size+1, 1) int comp_size = parse_double(action[2+comm_size]); int *recvcounts = xbt_new0(int, comm_size); int *disps = xbt_new0(int, comm_size); @@ -816,7 +825,7 @@ static void action_allgather(const char *const *action) { 3) No more values mean that the datatype for sent and receive buffer is the default one, see decode_datatype(). */ double clock = smpi_process_simulated_elapsed(); - CHECK_ACTION_PARAMS(action, 2, 2); + CHECK_ACTION_PARAMS(action, 2, 2) int sendcount=atoi(action[2]); int recvcount=atoi(action[3]); @@ -861,7 +870,7 @@ static void action_allgatherv(const char *const *action) { double clock = smpi_process_simulated_elapsed(); int comm_size = smpi_comm_size(MPI_COMM_WORLD); - CHECK_ACTION_PARAMS(action, comm_size+1, 2); + CHECK_ACTION_PARAMS(action, comm_size+1, 2) int i=0; int sendcount=atoi(action[2]); int *recvcounts = xbt_new0(int, comm_size); @@ -918,7 +927,7 @@ static void action_allToAllv(const char *const *action) { double clock = smpi_process_simulated_elapsed(); int comm_size = smpi_comm_size(MPI_COMM_WORLD); - CHECK_ACTION_PARAMS(action, 2*comm_size+2, 2); + CHECK_ACTION_PARAMS(action, 2*comm_size+2, 2) int send_buf_size=0,recv_buf_size=0,i=0; int *sendcounts = xbt_new0(int, comm_size); int *recvcounts = xbt_new0(int, comm_size); @@ -989,9 +998,9 @@ void smpi_replay_run(int *argc, char***argv){ char *operation =bprintf("%s_init",__FUNCTION__); TRACE_smpi_collective_in(rank, -1, operation, extra); TRACE_smpi_collective_out(rank, -1, operation); - free(operation); + xbt_free(operation); - if (!_xbt_replay_action_init()) { + if (_xbt_replay_action_init()==0) { xbt_replay_action_register("init", action_init); xbt_replay_action_register("finalize", action_finalize); xbt_replay_action_register("comm_size", action_comm_size); @@ -1039,7 +1048,7 @@ void smpi_replay_run(int *argc, char***argv){ double sim_time= 1.; /* One active process will stop. Decrease the counter*/ XBT_DEBUG("There are %lu elements in reqq[*]", xbt_dynar_length(get_reqq_self())); - if (!xbt_dynar_is_empty(get_reqq_self())){ + if (xbt_dynar_is_empty(get_reqq_self())==0){ int count_requests=xbt_dynar_length(get_reqq_self()); MPI_Request requests[count_requests]; MPI_Status status[count_requests]; @@ -1052,20 +1061,14 @@ void smpi_replay_run(int *argc, char***argv){ active_processes--; } - if(!active_processes){ + if(active_processes==0){ /* Last process alive speaking */ /* end the simulated timer */ sim_time = smpi_process_simulated_elapsed(); - } - - //TODO xbt_dynar_free_container(get_reqq_self())); - - if(!active_processes){ XBT_INFO("Simulation time %f", sim_time); _xbt_replay_action_exit(); xbt_free(sendbuffer); xbt_free(recvbuffer); - //xbt_free(reqq); xbt_dict_free(&reqq); //not need, data have been freed ??? reqq = NULL; } @@ -1080,5 +1083,5 @@ void smpi_replay_run(int *argc, char***argv){ TRACE_smpi_collective_out(rank, -1, operation); TRACE_smpi_finalize(smpi_process_index()); smpi_process_destroy(); - free(operation); + xbt_free(operation); } diff --git a/src/smpi/smpi_rma.cpp b/src/smpi/smpi_rma.cpp index 87c8a8a2ce..d4c51f4e91 100644 --- a/src/smpi/smpi_rma.cpp +++ b/src/smpi/smpi_rma.cpp @@ -93,7 +93,7 @@ void smpi_mpi_win_get_name(MPI_Win win, char* name, int* length){ return; } *length = strlen(win->name); - strcpy(name, win->name); + strncpy(name, win->name, *length+1); } void smpi_mpi_win_get_group(MPI_Win win, MPI_Group* group){ @@ -103,12 +103,12 @@ void smpi_mpi_win_get_group(MPI_Win win, MPI_Group* group){ } void smpi_mpi_win_set_name(MPI_Win win, char* name){ - win->name = xbt_strdup(name);; + win->name = xbt_strdup(name); } int smpi_mpi_win_fence( int assert, MPI_Win win){ XBT_DEBUG("Entering fence"); - if(!win->opened) + if(win->opened==0) win->opened=1; if(assert != MPI_MODE_NOPRECEDE){ xbt_barrier_wait(win->bar); @@ -119,7 +119,8 @@ int smpi_mpi_win_fence( int assert, MPI_Win win){ MPI_Request req; // start all requests that have been prepared by another process xbt_dynar_foreach(reqs, cpt, req){ - if (req->flags & PREPARED) smpi_mpi_start(req); + if (req->flags & PREPARED) + smpi_mpi_start(req); } MPI_Request* treqs = static_cast(xbt_dynar_to_array(reqs)); @@ -139,12 +140,12 @@ int smpi_mpi_win_fence( int assert, MPI_Win win){ int smpi_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) { - if(!win->opened)//check that post/start has been done + if(win->opened==0)//check that post/start has been done return MPI_ERR_WIN; //get receiver pointer MPI_Win recv_win = win->connected_wins[target_rank]; - void* recv_addr = (void*) ( ((char*)recv_win->base) + target_disp * recv_win->disp_unit); + void* recv_addr = static_cast ( static_cast(recv_win->base) + target_disp * recv_win->disp_unit); XBT_DEBUG("Entering MPI_Put to %d", target_rank); if(target_rank != smpi_comm_rank(win->comm)){ @@ -174,12 +175,12 @@ int smpi_mpi_put( void *origin_addr, int origin_count, MPI_Datatype origin_datat int smpi_mpi_get( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank, MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win) { - if(!win->opened)//check that post/start has been done + if(win->opened==0)//check that post/start has been done return MPI_ERR_WIN; //get sender pointer MPI_Win send_win = win->connected_wins[target_rank]; - void* send_addr = (void*)( ((char*)send_win->base) + target_disp * send_win->disp_unit); + void* send_addr = static_cast(static_cast(send_win->base) + target_disp * send_win->disp_unit); XBT_DEBUG("Entering MPI_Get from %d", target_rank); if(target_rank != smpi_comm_rank(win->comm)){ @@ -215,13 +216,13 @@ int smpi_mpi_get( void *origin_addr, int origin_count, MPI_Datatype origin_datat int smpi_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) { - if(!win->opened)//check that post/start has been done + if(win->opened==0)//check that post/start has been done return MPI_ERR_WIN; //FIXME: local version //get receiver pointer MPI_Win recv_win = win->connected_wins[target_rank]; - void* recv_addr = (void*)( ((char*)recv_win->base) + target_disp * recv_win->disp_unit); + void* recv_addr = static_cast(static_cast(recv_win->base) + target_disp * recv_win->disp_unit); XBT_DEBUG("Entering MPI_Accumulate to %d", target_rank); //prepare send_request @@ -260,7 +261,6 @@ int smpi_mpi_win_start(MPI_Group group, int assert, MPI_Win win){ int size = smpi_group_size(group); MPI_Request* reqs = xbt_new0(MPI_Request, size); -// for(i=0;iopened==0) xbt_die("Complete called on already opened MPI_Win"); -// xbt_barrier_wait(win->bar); - //MPI_Comm comm = smpi_comm_new(win->group, NULL); - //mpi_coll_barrier_fun(comm); - //smpi_comm_destroy(comm); XBT_DEBUG("Entering MPI_Win_Complete"); int i=0,j=0; @@ -351,7 +347,8 @@ int smpi_mpi_win_complete(MPI_Win win){ MPI_Request req; // start all requests that have been prepared by another process xbt_dynar_foreach(reqqs, cpt, req){ - if (req->flags & PREPARED) smpi_mpi_start(req); + if (req->flags & PREPARED) + smpi_mpi_start(req); } MPI_Request* treqs = static_cast(xbt_dynar_to_array(reqqs)); @@ -364,17 +361,12 @@ int smpi_mpi_win_complete(MPI_Win win){ } int smpi_mpi_win_wait(MPI_Win win){ -// xbt_barrier_wait(win->bar); - //MPI_Comm comm = smpi_comm_new(win->group, NULL); - //mpi_coll_barrier_fun(comm); - //smpi_comm_destroy(comm); //naive, blocking implementation. XBT_DEBUG("Entering MPI_Win_Wait"); int i=0,j=0; int size = smpi_group_size(win->group); MPI_Request* reqs = xbt_new0(MPI_Request, size); -// for(i=0;igroup,j); if(src!=smpi_process_index()){ @@ -401,7 +393,8 @@ int smpi_mpi_win_wait(MPI_Win win){ MPI_Request req; // start all requests that have been prepared by another process xbt_dynar_foreach(reqqs, cpt, req){ - if (req->flags & PREPARED) smpi_mpi_start(req); + if (req->flags & PREPARED) + smpi_mpi_start(req); } MPI_Request* treqs = static_cast(xbt_dynar_to_array(reqqs)); diff --git a/src/smpi/smpi_topo.cpp b/src/smpi/smpi_topo.cpp index 16b8cfa1c3..bdcd9b65f0 100644 --- a/src/smpi/smpi_topo.cpp +++ b/src/smpi/smpi_topo.cpp @@ -79,15 +79,15 @@ MPI_Topology smpi_topo_create(MPIR_Topo_type kind) { void smpi_cart_topo_destroy(MPIR_Cart_Topology cart) { if (cart) { if(cart->dims) { - free(cart->dims); + xbt_free(cart->dims); } if(cart->periodic) { - free(cart->periodic); + xbt_free(cart->periodic); } if(cart->position) { - free(cart->position); + xbt_free(cart->position); } - free(cart); + xbt_free(cart); } } @@ -132,9 +132,6 @@ int smpi_mpi_cart_create(MPI_Comm comm_old, int ndims, int dims[], int periods[] newCart->topo.cart->nnodes = newSize; - /* memcpy(newCart->topo.cart->dims, dims, ndims * sizeof(*newCart->topo.cart->dims)); */ - /* memcpy(newCart->topo.cart->periodic, periods, ndims * sizeof(*newCart->topo.cart->periodic)); */ - // FIXME : code duplication... See smpi_mpi_cart_coords nranks = newSize; for (i=0; i 0) { @@ -236,7 +234,8 @@ int smpi_mpi_cart_rank(MPI_Comm comm, int* coords, int* rank) { } else if (coord < 0) { if(topo->topo.cart->periodic[i]) { coord = coord % topo->topo.cart->dims[i]; - if (coord) coord = topo->topo.cart->dims[i] + coord; + if (coord) + coord = topo->topo.cart->dims[i] + coord; } else { *rank = -1; return MPI_ERR_ARG;