From: degomme Date: Sat, 11 Mar 2017 15:12:50 +0000 (+0100) Subject: Replace all the lookup tables in smpi_f77.cpp by a single one. X-Git-Tag: v3_15~148 X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/commitdiff_plain/6fd166d6132c999bfa781b58a5372c7cbdfe36b2 Replace all the lookup tables in smpi_f77.cpp by a single one. Make all MPI_* classes inherit F2C, to provide MPI_*_f2c and MPI_*_c2f more easily. --- diff --git a/include/smpi/forward.hpp b/include/smpi/forward.hpp index 59603d2831..7788f55599 100644 --- a/include/smpi/forward.hpp +++ b/include/smpi/forward.hpp @@ -15,6 +15,7 @@ namespace smpi { class Comm; class Datatype; +class F2C; class Group; class Info; class Op; diff --git a/include/smpi/mpif.h.in b/include/smpi/mpif.h.in index bbceb0e1bd..d6ffa2f444 100644 --- a/include/smpi/mpif.h.in +++ b/include/smpi/mpif.h.in @@ -83,9 +83,8 @@ parameter(MPI_COMM_NULL_DUP_FN =0) parameter(MPI_COMM_DUP_FN =0) - integer MPI_ROOT, MPI_INFO_NULL,MPI_COMM_TYPE_SHARED + integer MPI_ROOT, MPI_COMM_TYPE_SHARED parameter(MPI_ROOT=0) - parameter(MPI_INFO_NULL=0) parameter(MPI_COMM_TYPE_SHARED=1) ! Attribute keys @@ -101,19 +100,6 @@ parameter(MPI_UNIVERSE_SIZE=-7) parameter(MPI_LASTUSEDCODE=-8) -! These should be ordered as in smpi_f77.c - integer MPI_COMM_NULL, MPI_COMM_WORLD, MPI_COMM_SELF - parameter(MPI_COMM_NULL=-1) - parameter(MPI_COMM_SELF=-2) - parameter(MPI_COMM_WORLD=0) - - integer MPI_GROUP_NULL, MPI_GROUP_EMPTY - parameter(MPI_GROUP_NULL=-1) - parameter(MPI_GROUP_EMPTY=-2) - - integer MPI_WIN_NULL - parameter(MPI_WIN_NULL=-1) - integer MPI_ERRORS_RETURN, MPI_ERRORS_ARE_FATAL integer MPI_ERRHANDLER_NULL parameter(MPI_ERRORS_RETURN=0) @@ -124,7 +110,8 @@ integer MPI_STATUS_SIZE parameter(MPI_STATUS_SIZE=4) -! These should be ordered as in smpi_f77.c + integer MPI_INTEGER_KIND + parameter(MPI_INTEGER_KIND=4) integer MPI_IN_PLACE parameter(MPI_IN_PLACE=-100) @@ -135,13 +122,8 @@ integer MPI_STATUSES_IGNORE parameter(MPI_STATUSES_IGNORE=-400) - integer MPI_REQUEST_NULL - parameter(MPI_REQUEST_NULL=-1) - - integer MPI_INTEGER_KIND - parameter(MPI_INTEGER_KIND=4) - integer MPI_DATATYPE_NULL, MPI_BYTE, MPI_CHARACTER, MPI_LOGICAL + integer MPI_BYTE, MPI_CHARACTER, MPI_LOGICAL integer MPI_INTEGER, MPI_INTEGER1, MPI_INTEGER2, MPI_INTEGER4 integer MPI_INTEGER8, MPI_REAL, MPI_REAL4, MPI_REAL8 integer MPI_DOUBLE_PRECISION, MPI_COMPLEX, MPI_DOUBLE_COMPLEX @@ -149,52 +131,71 @@ integer MPI_LOGICAL8, MPI_2REAL, MPI_2DOUBLE_PRECISION integer MPI_AINT, MPI_OFFSET, MPI_COUNT integer MPI_REAL16, MPI_PACKED - parameter(MPI_DATATYPE_NULL=-1) - parameter(MPI_BYTE=0) - parameter(MPI_CHARACTER=1) - parameter(MPI_LOGICAL=2) - parameter(MPI_INTEGER=3) - parameter(MPI_INTEGER1=4) - parameter(MPI_INTEGER2=5) - parameter(MPI_INTEGER4=6) - parameter(MPI_INTEGER8=7) - parameter(MPI_REAL=8) - parameter(MPI_REAL4=9) - parameter(MPI_REAL8=10) - parameter(MPI_DOUBLE_PRECISION=11) - parameter(MPI_COMPLEX=12) - parameter(MPI_DOUBLE_COMPLEX=13) - parameter(MPI_2INTEGER=14) - parameter(MPI_LOGICAL1=15) - parameter(MPI_LOGICAL2=16) - parameter(MPI_LOGICAL4=17) - parameter(MPI_LOGICAL8=18) - parameter(MPI_2REAL=19) - parameter(MPI_2DOUBLE_PRECISION=20) - parameter(MPI_AINT=21) - parameter(MPI_OFFSET=22) - parameter(MPI_COUNT=23) - parameter(MPI_REAL16=24) - parameter(MPI_PACKED=25) - - -! These should be ordered as in smpi_f77.c - integer MPI_OP_NULL,MPI_MAX, MPI_MIN, MPI_MAXLOC, MPI_MINLOC + + integer MPI_MAX, MPI_MIN, MPI_MAXLOC, MPI_MINLOC integer MPI_SUM, MPI_PROD, MPI_LAND, MPI_LOR, MPI_LXOR, MPI_BAND integer MPI_BOR, MPI_BXOR + +! _NULL handles should be negative + + integer MPI_REQUEST_NULL,MPI_DATATYPE_NULL,MPI_OP_NULL + integer MPI_COMM_NULL, MPI_COMM_WORLD, MPI_COMM_SELF + integer MPI_GROUP_NULL, MPI_GROUP_EMPTY, MPI_WIN_NULL + integer MPI_INFO_NULL + + parameter(MPI_REQUEST_NULL=-1) + parameter(MPI_DATATYPE_NULL=-1) parameter(MPI_OP_NULL=-1) - parameter(MPI_MAX=0) - parameter(MPI_MIN=1) - parameter(MPI_MAXLOC=2) - parameter(MPI_MINLOC=3) - parameter(MPI_SUM=4) - parameter(MPI_PROD=5) - parameter(MPI_LAND=6) - parameter(MPI_LOR=7) - parameter(MPI_LXOR=8) - parameter(MPI_BAND=9) - parameter(MPI_BOR=10) - parameter(MPI_BXOR=11) + parameter(MPI_INFO_NULL=-1) + parameter(MPI_COMM_NULL=-1) + parameter(MPI_COMM_SELF=-2) + parameter(MPI_GROUP_NULL=-1) + parameter(MPI_GROUP_EMPTY=-2) + parameter(MPI_WIN_NULL=-1) + +! These IDs have to be unique, consecutive +! and ordered as in smpi_f77.cpp. + parameter(MPI_COMM_WORLD=0) + + parameter(MPI_BYTE=1) + parameter(MPI_CHARACTER=2) + parameter(MPI_LOGICAL=3) + parameter(MPI_INTEGER=4) + parameter(MPI_INTEGER1=5) + parameter(MPI_INTEGER2=6) + parameter(MPI_INTEGER4=7) + parameter(MPI_INTEGER8=8) + parameter(MPI_REAL=9) + parameter(MPI_REAL4=10) + parameter(MPI_REAL8=11) + parameter(MPI_DOUBLE_PRECISION=12) + parameter(MPI_COMPLEX=13) + parameter(MPI_DOUBLE_COMPLEX=14) + parameter(MPI_2INTEGER=15) + parameter(MPI_LOGICAL1=16) + parameter(MPI_LOGICAL2=17) + parameter(MPI_LOGICAL4=18) + parameter(MPI_LOGICAL8=19) + parameter(MPI_2REAL=20) + parameter(MPI_2DOUBLE_PRECISION=21) + parameter(MPI_AINT=22) + parameter(MPI_OFFSET=23) + parameter(MPI_COUNT=24) + parameter(MPI_REAL16=25) + parameter(MPI_PACKED=26) + + parameter(MPI_MAX=27) + parameter(MPI_MIN=28) + parameter(MPI_MAXLOC=29) + parameter(MPI_MINLOC=30) + parameter(MPI_SUM=31) + parameter(MPI_PROD=32) + parameter(MPI_LAND=33) + parameter(MPI_LOR=34) + parameter(MPI_LXOR=35) + parameter(MPI_BAND=36) + parameter(MPI_BOR=37) + parameter(MPI_BXOR=38) INTEGER MPI_ADDRESS_KIND, MPI_OFFSET_KIND PARAMETER (MPI_ADDRESS_KIND=@CMAKE_SIZEOF_VOID_P@) diff --git a/src/smpi/private.h b/src/smpi/private.h index 67abdbd81a..e2c0cda3d6 100644 --- a/src/smpi/private.h +++ b/src/smpi/private.h @@ -15,6 +15,7 @@ #include "xbt/base.h" #include "xbt/synchro.h" #include "xbt/xbt_os_time.h" +#include "src/smpi/smpi_f2c.hpp" #include "src/smpi/smpi_group.hpp" #include "src/smpi/smpi_comm.hpp" #include "src/smpi/smpi_info.hpp" @@ -133,24 +134,6 @@ XBT_PRIVATE void smpi_mpi_init(); XBT_PRIVATE void smpi_empty_status(MPI_Status * status); XBT_PRIVATE int smpi_mpi_get_count(MPI_Status * status, MPI_Datatype datatype); -XBT_PRIVATE int smpi_comm_c2f(MPI_Comm comm); -XBT_PRIVATE int smpi_comm_add_f(MPI_Comm comm); -XBT_PRIVATE MPI_Comm smpi_comm_f2c(int comm); -XBT_PRIVATE int smpi_group_c2f(MPI_Group group); -XBT_PRIVATE int smpi_group_add_f(MPI_Group group); -XBT_PRIVATE MPI_Group smpi_group_f2c(int group); -XBT_PRIVATE int smpi_request_c2f(MPI_Request req); -XBT_PRIVATE int smpi_request_add_f(MPI_Request req); -XBT_PRIVATE MPI_Request smpi_request_f2c(int req); -XBT_PRIVATE int smpi_type_c2f(MPI_Datatype datatype); -XBT_PRIVATE int smpi_type_add_f(MPI_Datatype datatype); -XBT_PRIVATE MPI_Datatype smpi_type_f2c(int datatype); -XBT_PRIVATE int smpi_op_c2f(MPI_Op op); -XBT_PRIVATE int smpi_op_add_f(MPI_Op op); -XBT_PRIVATE MPI_Op smpi_op_f2c(int op); -XBT_PRIVATE int smpi_win_c2f(MPI_Win win); -XBT_PRIVATE int smpi_win_add_f(MPI_Win win); -XBT_PRIVATE MPI_Win smpi_win_f2c(int win); XBT_PRIVATE int smpi_info_c2f(MPI_Info info); XBT_PRIVATE int smpi_info_add_f(MPI_Info info); XBT_PRIVATE MPI_Info smpi_info_f2c(int info); diff --git a/src/smpi/smpi_comm.cpp b/src/smpi/smpi_comm.cpp index 54934b90ff..973b24db80 100644 --- a/src/smpi/smpi_comm.cpp +++ b/src/smpi/smpi_comm.cpp @@ -67,14 +67,14 @@ Comm::Comm(MPI_Group group, MPI_Topology topo) : group_(group), topo_(topo) attributes_=nullptr; } -void Comm::destroy() +void Comm::destroy(Comm* comm) { - if (this == MPI_COMM_UNINITIALIZED){ - smpi_process_comm_world()->destroy(); + if (comm == MPI_COMM_UNINITIALIZED){ + Comm::destroy(smpi_process_comm_world()); return; } - delete topo_; // there's no use count on topos - this->unuse(); + delete comm->topo_; // there's no use count on topos + Comm::unref(comm); } int Comm::dup(MPI_Comm* newcomm){ @@ -98,7 +98,7 @@ int Comm::dup(MPI_Comm* newcomm){ if (elem != nullptr && elem->copy_fn != MPI_NULL_COPY_FN) { ret = elem->copy_fn(this, atoi(key), nullptr, value_in, &value_out, &flag); if (ret != MPI_SUCCESS) { - (*newcomm)->destroy(); + Comm::destroy(*newcomm); *newcomm = MPI_COMM_NULL; xbt_dict_cursor_free(&cursor); return ret; @@ -260,7 +260,8 @@ MPI_Comm Comm::split(int color, int key) } } if(i != 0) { - group_out->destroy(); + if(group_out != MPI_COMM_WORLD->group() && group_out != MPI_GROUP_EMPTY) + Group::unref(group_out); } Request::waitall(reqs, requests, MPI_STATUS_IGNORE); xbt_free(requests); @@ -278,12 +279,12 @@ MPI_Comm Comm::split(int color, int key) return group_out!=nullptr ? new Comm(group_out, nullptr) : MPI_COMM_NULL; } -void Comm::use(){ +void Comm::ref(){ if (this == MPI_COMM_UNINITIALIZED){ - smpi_process_comm_world()->use(); + smpi_process_comm_world()->ref(); return; } - group_->use(); + group_->ref(); refcount_++; } @@ -304,27 +305,27 @@ void Comm::cleanup_attributes(){ void Comm::cleanup_smp(){ if (intra_comm_ != MPI_COMM_NULL) - intra_comm_->unuse(); + Comm::unref(intra_comm_); if (leaders_comm_ != MPI_COMM_NULL) - leaders_comm_->unuse(); + Comm::unref(leaders_comm_); if (non_uniform_map_ != nullptr) xbt_free(non_uniform_map_); if (leaders_map_ != nullptr) xbt_free(leaders_map_); } -void Comm::unuse(){ - if (this == MPI_COMM_UNINITIALIZED){ - smpi_process_comm_world()->unuse(); +void Comm::unref(Comm* comm){ + if (comm == MPI_COMM_UNINITIALIZED){ + Comm::unref(smpi_process_comm_world()); return; } - refcount_--; - group_->unuse(); + comm->refcount_--; + Group::unref(comm->group_); - if(refcount_==0){ - this->cleanup_smp(); - this->cleanup_attributes(); - delete this; + if(comm->refcount_==0){ + comm->cleanup_smp(); + comm->cleanup_attributes(); + delete comm; } } @@ -442,7 +443,7 @@ void Comm::init_smp(){ this->set_leaders_comm(leader_comm); }else{ leader_comm=this->get_leaders_comm(); - leaders_group->unuse(); + Group::unref(leaders_group); } smpi_process_set_comm_intra(comm_intra); } @@ -564,6 +565,36 @@ int Comm::attr_put(int keyval, void* attr_value){ return MPI_SUCCESS; } +MPI_Comm Comm::f2c(int id) { + if(id == -2) { + return MPI_COMM_SELF; + } else if(id==0){ + return MPI_COMM_WORLD; + } else if(Comm::f2c_lookup_ != nullptr && id >= 0) { + char key[KEY_SIZE]; + MPI_Comm tmp = static_cast(xbt_dict_get_or_null(Comm::f2c_lookup_,get_key_id(key, id))); + return tmp != nullptr ? tmp : MPI_COMM_NULL ; + } else { + return MPI_COMM_NULL; + } +} + +void Comm::free_f(int id) { + char key[KEY_SIZE]; + xbt_dict_remove(Comm::f2c_lookup_, id==0? get_key(key, id) : get_key_id(key, id)); +} + +int Comm::add_f() { + if(Comm::f2c_lookup_==nullptr){ + Comm::f2c_lookup_=xbt_dict_new_homogeneous(nullptr); + } + char key[KEY_SIZE]; + xbt_dict_set(Comm::f2c_lookup_, this==MPI_COMM_WORLD? get_key(key, Comm::f2c_id_) : get_key_id(key,Comm::f2c_id_), this, nullptr); + Comm::f2c_id_++; + return Comm::f2c_id_-1; +} + + } } diff --git a/src/smpi/smpi_comm.hpp b/src/smpi/smpi_comm.hpp index 700c9de6bd..ee313dcdde 100644 --- a/src/smpi/smpi_comm.hpp +++ b/src/smpi/smpi_comm.hpp @@ -12,7 +12,7 @@ namespace simgrid{ namespace smpi{ -class Comm { +class Comm : public F2C{ private: MPI_Group group_; @@ -32,7 +32,7 @@ class Comm { Comm(); Comm(MPI_Group group, MPI_Topology topo); - void destroy(); + int dup(MPI_Comm* newcomm); MPI_Group group(); MPI_Topology topo(); @@ -48,15 +48,20 @@ class Comm { int is_uniform(); int is_blocked(); MPI_Comm split(int color, int key); - void use(); void cleanup_attributes(); void cleanup_smp(); - void unuse(); + void ref(); + static void unref(MPI_Comm comm); + static void destroy(MPI_Comm comm); void init_smp(); int attr_delete(int keyval); int attr_get(int keyval, void* attr_value, int* flag); int attr_put(int keyval, void* attr_value); + int add_f(); + static void free_f(int id); + static Comm* f2c(int); + }; } diff --git a/src/smpi/smpi_datatype.cpp b/src/smpi/smpi_datatype.cpp index 7f603833a7..43cffe58d3 100644 --- a/src/smpi/smpi_datatype.cpp +++ b/src/smpi/smpi_datatype.cpp @@ -108,6 +108,8 @@ CREATE_MPI_DATATYPE(MPI_PTR, void*); namespace simgrid{ namespace smpi{ +MPI_Datatype Datatype::null_id_=MPI_DATATYPE_NULL; + Datatype::Datatype(int size,MPI_Aint lb, MPI_Aint ub, int flags) : name_(nullptr), size_(size), lb_(lb), ub_(ub), flags_(flags), attributes_(nullptr), in_use_(1){ #if HAVE_MC if(MC_is_active()) @@ -587,6 +589,10 @@ int Datatype::create_struct(int count, int* block_lengths, MPI_Aint* indices, MP return MPI_SUCCESS; } +Datatype* Datatype::f2c(int id){ + return static_cast(F2C::f2c(id)); +} + } } diff --git a/src/smpi/smpi_datatype.hpp b/src/smpi/smpi_datatype.hpp index 9c0cb86da8..b639ceb920 100644 --- a/src/smpi/smpi_datatype.hpp +++ b/src/smpi/smpi_datatype.hpp @@ -77,7 +77,7 @@ typedef struct { namespace simgrid{ namespace smpi{ -class Datatype{ +class Datatype : public F2C{ protected: char* name_; size_t size_; @@ -86,8 +86,9 @@ class Datatype{ int flags_; xbt_dict_t attributes_; int in_use_; - public: + static MPI_Datatype null_id_; + Datatype(int size,MPI_Aint lb, MPI_Aint ub, int flags); Datatype(char* name, int size,MPI_Aint lb, MPI_Aint ub, int flags); Datatype(Datatype *datatype, int* ret); @@ -127,8 +128,9 @@ class Datatype{ static int create_indexed(int count, int* blocklens, int* indices, MPI_Datatype old_type, MPI_Datatype* new_type); static int create_hindexed(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype old_type, MPI_Datatype* new_type); static int create_struct(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype* old_types, MPI_Datatype* new_type); -}; + static Datatype* f2c(int id); +}; } } diff --git a/src/smpi/smpi_deployment.cpp b/src/smpi/smpi_deployment.cpp index d33742e196..7a15f208dd 100644 --- a/src/smpi/smpi_deployment.cpp +++ b/src/smpi/smpi_deployment.cpp @@ -85,7 +85,7 @@ void smpi_deployment_cleanup_instances(){ char *name = nullptr; xbt_dict_foreach(smpi_instances, cursor, name, instance) { if(instance->comm_world!=MPI_COMM_NULL) - while (instance->comm_world->group()->unuse() > 0); + delete instance->comm_world->group(); delete instance->comm_world; MSG_barrier_destroy(instance->finalization_barrier); } diff --git a/src/smpi/smpi_f2c.cpp b/src/smpi/smpi_f2c.cpp new file mode 100644 index 0000000000..b7828d6fba --- /dev/null +++ b/src/smpi/smpi_f2c.cpp @@ -0,0 +1,74 @@ +/* Copyright (c) 2007-2015. The SimGrid Team. + * All rights reserved. */ + +/* This program is free software; you can redistribute it and/or modify it + * under the terms of the license (GNU LGPL) which comes with this package. */ + +#include "private.h" +#include + + +namespace simgrid{ +namespace smpi{ + +xbt_dict_t F2C::f2c_lookup_=nullptr; +int F2C::f2c_id_=0; + +char* F2C::get_key(char* key, int id) { + snprintf(key, KEY_SIZE, "%x",id); + return key; +} + +char* F2C::get_key_id(char* key, int id) { + snprintf(key, KEY_SIZE, "%x_%d",id, smpi_process_index()); + return key; +} + +void F2C::delete_lookup(){ + xbt_dict_free(&f2c_lookup_); +} + +xbt_dict_t F2C::lookup(){ + return f2c_lookup_; +} + +void F2C::free_f(int id){ + char key[KEY_SIZE]; + xbt_dict_remove(f2c_lookup_, get_key(key, id)); +} + +int F2C::add_f(){ + if(f2c_lookup_==nullptr){ + f2c_lookup_=xbt_dict_new_homogeneous(nullptr); + } + char key[KEY_SIZE]; + xbt_dict_set(f2c_lookup_, get_key(key, f2c_id_), this, nullptr); + f2c_id_++; + return f2c_id_-1; +} + +int F2C::c2f(){ + if(f2c_lookup_==nullptr){ + f2c_lookup_=xbt_dict_new_homogeneous(nullptr); + } + + char* existing_key = xbt_dict_get_key(f2c_lookup_, this); + if(existing_key!=nullptr){ + return atoi(existing_key);} + else{ + return this->add_f();} +} + +F2C* F2C::f2c(int id){ + if(f2c_lookup_==nullptr){ + f2c_lookup_=xbt_dict_new_homogeneous(nullptr); + } + char key[KEY_SIZE]; + if(id >= 0){ + return static_cast(xbt_dict_get_or_null(f2c_lookup_, get_key(key, id))); + }else + return NULL; +} + +} +} diff --git a/src/smpi/smpi_f2c.hpp b/src/smpi/smpi_f2c.hpp new file mode 100644 index 0000000000..a013e04180 --- /dev/null +++ b/src/smpi/smpi_f2c.hpp @@ -0,0 +1,46 @@ +/* Handle Fortan - C conversion for MPI Types*/ + +/* Copyright (c) 2010, 2013-2015. The SimGrid Team. + * All rights reserved. */ + +/* This program is free software; you can redistribute it and/or modify it + * under the terms of the license (GNU LGPL) which comes with this package. */ + +#ifndef SMPI_F2C_HPP_INCLUDED +#define SMPI_F2C_HPP_INCLUDED + +#include "private.h" + + +#define KEY_SIZE (sizeof(int) * 2 + 1) + +namespace simgrid{ +namespace smpi{ + +class F2C { + protected: + // We use a single lookup table for every type. + // Beware of collisions if id in mpif.h is not unique + static xbt_dict_t f2c_lookup_; + static int f2c_id_; + public: + static char* get_key(char* key, int id); + static char* get_key_id(char* key, int id); + static void delete_lookup(); + static xbt_dict_t lookup(); + + //Override these to handle specific values. + int add_f(); + static void free_f(int id); + int c2f(); + + //This method should be overriden in all subclasses + //to avoid casting the result when calling it. + //For the default one, the MPI_*_NULL returned is assumed to be NULL. + static F2C* f2c(int); +}; + +} +} + +#endif diff --git a/src/smpi/smpi_f77.cpp b/src/smpi/smpi_f77.cpp index e86d3c5980..732c82fa61 100644 --- a/src/smpi/smpi_f77.cpp +++ b/src/smpi/smpi_f77.cpp @@ -9,23 +9,6 @@ #include "private.h" #include "xbt.h" -//TODO : remove all this. -static xbt_dict_t comm_lookup = nullptr; -static xbt_dict_t group_lookup = nullptr; -static xbt_dict_t request_lookup = nullptr; -static xbt_dict_t type_lookup = nullptr; -static xbt_dict_t op_lookup = nullptr; -static xbt_dict_t win_lookup = nullptr; -static xbt_dict_t info_lookup = nullptr; -static int comm_id=0; -static int group_id=0; -static int request_id=0; -static int type_id=0; -static int op_id=0; -static int win_id=0; -static int info_id=0; - - static int running_processes = 0; #if defined(__alpha__) || defined(__sparc64__) || defined(__x86_64__) || defined(__ia64__) @@ -56,177 +39,61 @@ static char* get_key_id(char* key, int id) { } static void smpi_init_fortran_types(){ - if(comm_lookup == nullptr){ - comm_lookup = xbt_dict_new_homogeneous(nullptr); - smpi_comm_add_f(MPI_COMM_WORLD); - group_lookup = xbt_dict_new_homogeneous(nullptr); - request_lookup = xbt_dict_new_homogeneous(nullptr); - type_lookup = xbt_dict_new_homogeneous(nullptr); - win_lookup = xbt_dict_new_homogeneous(nullptr); - info_lookup = xbt_dict_new_homogeneous(nullptr); - smpi_type_add_f(MPI_BYTE);//MPI_BYTE - smpi_type_add_f(MPI_CHAR);//MPI_CHARACTER + if(F2C::lookup() == nullptr){ + MPI_COMM_WORLD->add_f(); + MPI_BYTE->add_f();//MPI_BYTE + MPI_CHAR->add_f();//MPI_CHARACTER #if defined(__alpha__) || defined(__sparc64__) || defined(__x86_64__) || defined(__ia64__) - smpi_type_add_f(MPI_C_BOOL);//MPI_LOGICAL - smpi_type_add_f(MPI_INT);//MPI_INTEGER + MPI_C_BOOL->add_f();//MPI_LOGICAL + MPI_INT->add_f();//MPI_INTEGER #else - smpi_type_add_f(MPI_C_BOOL);//MPI_LOGICAL - smpi_type_add_f(MPI_LONG);//MPI_INTEGER + MPI_C_BOOL->add_f();//MPI_LOGICAL + MPI_LONG->add_f();//MPI_INTEGER #endif - smpi_type_add_f(MPI_INT8_T);//MPI_INTEGER1 - smpi_type_add_f(MPI_INT16_T);//MPI_INTEGER2 - smpi_type_add_f(MPI_INT32_T);//MPI_INTEGER4 - smpi_type_add_f(MPI_INT64_T);//MPI_INTEGER8 - smpi_type_add_f(MPI_REAL);//MPI_REAL - smpi_type_add_f(MPI_REAL4);//MPI_REAL4 - smpi_type_add_f(MPI_REAL8);//MPI_REAL8 - smpi_type_add_f(MPI_DOUBLE);//MPI_DOUBLE_PRECISION - smpi_type_add_f(MPI_C_FLOAT_COMPLEX);//MPI_COMPLEX - smpi_type_add_f(MPI_C_DOUBLE_COMPLEX);//MPI_DOUBLE_COMPLEX + MPI_INT8_T->add_f();//MPI_INTEGER1 + MPI_INT16_T->add_f();//MPI_INTEGER2 + MPI_INT32_T->add_f();//MPI_INTEGER4 + MPI_INT64_T->add_f();//MPI_INTEGER8 + MPI_REAL->add_f();//MPI_REAL + MPI_REAL4->add_f();//MPI_REAL4 + MPI_REAL8->add_f();//MPI_REAL8 + MPI_DOUBLE->add_f();//MPI_DOUBLE_PRECISION + MPI_C_FLOAT_COMPLEX->add_f();//MPI_COMPLEX + MPI_C_DOUBLE_COMPLEX->add_f();//MPI_DOUBLE_COMPLEX #if defined(__alpha__) || defined(__sparc64__) || defined(__x86_64__) || defined(__ia64__) - smpi_type_add_f(MPI_2INT);//MPI_2INTEGER + MPI_2INT->add_f();//MPI_2INTEGER #else - smpi_type_add_f(MPI_2LONG);//MPI_2INTEGER + MPI_2LONG->add_f();//MPI_2INTEGER #endif - smpi_type_add_f(MPI_UINT8_T);//MPI_LOGICAL1 - smpi_type_add_f(MPI_UINT16_T);//MPI_LOGICAL2 - smpi_type_add_f(MPI_UINT32_T);//MPI_LOGICAL4 - smpi_type_add_f(MPI_UINT64_T);//MPI_LOGICAL8 - smpi_type_add_f(MPI_2FLOAT);//MPI_2REAL - smpi_type_add_f(MPI_2DOUBLE);//MPI_2DOUBLE_PRECISION - smpi_type_add_f(MPI_PTR);//MPI_AINT - smpi_type_add_f(MPI_OFFSET);//MPI_OFFSET - smpi_type_add_f(MPI_AINT);//MPI_COUNT - smpi_type_add_f(MPI_DATATYPE_NULL);//MPI_REAL16 - smpi_type_add_f(MPI_DATATYPE_NULL);//MPI_COMPLEX8 - smpi_type_add_f(MPI_DATATYPE_NULL);//MPI_COMPLEX16 - smpi_type_add_f(MPI_DATATYPE_NULL);//MPI_COMPLEX32 - smpi_type_add_f(MPI_DATATYPE_NULL);//MPI_PACKED - op_lookup = xbt_dict_new_homogeneous(nullptr); - smpi_op_add_f(MPI_MAX); - smpi_op_add_f(MPI_MIN); - smpi_op_add_f(MPI_MAXLOC); - smpi_op_add_f(MPI_MINLOC); - smpi_op_add_f(MPI_SUM); - smpi_op_add_f(MPI_PROD); - smpi_op_add_f(MPI_LAND); - smpi_op_add_f(MPI_LOR); - smpi_op_add_f(MPI_LXOR); - smpi_op_add_f(MPI_BAND); - smpi_op_add_f(MPI_BOR); - smpi_op_add_f(MPI_BXOR); + MPI_UINT8_T->add_f();//MPI_LOGICAL1 + MPI_UINT16_T->add_f();//MPI_LOGICAL2 + MPI_UINT32_T->add_f();//MPI_LOGICAL4 + MPI_UINT64_T->add_f();//MPI_LOGICAL8 + MPI_2FLOAT->add_f();//MPI_2REAL + MPI_2DOUBLE->add_f();//MPI_2DOUBLE_PRECISION + MPI_PTR->add_f();//MPI_AINT + MPI_OFFSET->add_f();//MPI_OFFSET + MPI_AINT->add_f();//MPI_COUNT + MPI_REAL16->add_f();//MPI_REAL16 + MPI_PACKED->add_f();//MPI_PACKED + + MPI_MAX->add_f(); + MPI_MIN->add_f(); + MPI_MAXLOC->add_f(); + MPI_MINLOC->add_f(); + MPI_SUM->add_f(); + MPI_PROD->add_f(); + MPI_LAND->add_f(); + MPI_LOR->add_f(); + MPI_LXOR->add_f(); + MPI_BAND->add_f(); + MPI_BOR->add_f(); + MPI_BXOR->add_f(); } } -template int smpi_add_f(T t, xbt_dict_t dict, int* id) { - char key[KEY_SIZE]; - xbt_dict_set(dict, get_key(key, *id), t, nullptr); - (*id)++; - return *id-1; -} - -template <> int smpi_add_f(MPI_Comm comm, xbt_dict_t dict, int* id) { - char key[KEY_SIZE]; - xbt_dict_set(dict, comm==MPI_COMM_WORLD? get_key(key, *id) : get_key_id(key, *id), comm, nullptr); - (*id)++; - return *id-1; -} - -template <> int smpi_add_f(MPI_Request request, xbt_dict_t dict, int* id) { - char key[KEY_SIZE]; - xbt_dict_set(dict, get_key_id(key, *id), request, nullptr); - (*id)++; - return *id-1; -} - -template int smpi_c2f(T t, xbt_dict_t dict, int* id) { - char* existing_key = xbt_dict_get_key(dict, t); - if(existing_key!=nullptr) - return atoi(existing_key); - else - return smpi_add_f(t,dict,id); -} - -template void free_f(int id, xbt_dict_t dict) { - char key[KEY_SIZE]; - xbt_dict_remove(dict, get_key(key, id)); -} - -template <> void free_f(int id, xbt_dict_t dict) { - char key[KEY_SIZE]; - xbt_dict_remove(dict, id==0? get_key(key, id) : get_key_id(key, id)); -} - -template <> void free_f(int id, xbt_dict_t dict) { - char key[KEY_SIZE]; - if(id!=MPI_FORTRAN_REQUEST_NULL) - xbt_dict_remove(dict, get_key_id(key, id)); -} - -template T smpi_f2c(int id, xbt_dict_t dict, void* null_id ) { - smpi_init_fortran_types(); - char key[KEY_SIZE]; - return id >= 0 ? static_cast(xbt_dict_get_or_null(dict, get_key(key, id))): static_cast(null_id); -} - -template <> MPI_Comm smpi_f2c(int comm, xbt_dict_t dict, void* null_id) { - smpi_init_fortran_types(); - if(comm == -2) { - return MPI_COMM_SELF; - } else if(comm==0){ - return MPI_COMM_WORLD; - } else if(dict != nullptr && comm >= 0) { - char key[KEY_SIZE]; - MPI_Comm tmp = static_cast(xbt_dict_get_or_null(dict,get_key_id(key, comm))); - return tmp != nullptr ? tmp : static_cast(null_id) ; - } else { - return static_cast(null_id); - } -} - -template <> MPI_Group smpi_f2c(int group, xbt_dict_t dict, void* null_id) { - smpi_init_fortran_types(); - if(group == -2) { - return MPI_GROUP_EMPTY; - } else if(dict != nullptr && group >= 0) { - char key[KEY_SIZE]; - return static_cast(xbt_dict_get_or_null(dict, get_key(key, group))); - } else { - return static_cast(null_id); - } -} - -template <> MPI_Request smpi_f2c(int request, xbt_dict_t dict, void* null_id) { - smpi_init_fortran_types(); - char key[KEY_SIZE]; - if(request==MPI_FORTRAN_REQUEST_NULL) - return static_cast(null_id); - return static_cast(xbt_dict_get(dict, get_key_id(key, request))); -} - -#define SMPI_F2C_C2F(type, name, null_id)\ -int smpi_##name##_add_f(type name){\ - return smpi_add_f(name, name##_lookup, &name##_id);\ -}\ -int smpi_##name##_c2f(type name){\ - return smpi_c2f(name, name##_lookup, &name##_id);\ -}\ -static void free_##name(int id) {\ - free_f(id, name##_lookup);\ -}\ -type smpi_##name##_f2c(int id){\ - return smpi_f2c(id, name##_lookup, static_cast(null_id));\ -} - extern "C" { // This should really use the C linkage to be usable from Fortran -SMPI_F2C_C2F(MPI_Comm, comm, MPI_COMM_NULL) -SMPI_F2C_C2F(MPI_Group, group, MPI_GROUP_NULL) -SMPI_F2C_C2F(MPI_Request, request, MPI_REQUEST_NULL) -SMPI_F2C_C2F(MPI_Datatype, type, MPI_DATATYPE_NULL) -SMPI_F2C_C2F(MPI_Win, win, MPI_WIN_NULL) -SMPI_F2C_C2F(MPI_Op, op, MPI_OP_NULL) -SMPI_F2C_C2F(MPI_Info, info, MPI_INFO_NULL) void mpi_init_(int* ierr) { smpi_init_fortran_types(); @@ -238,26 +105,20 @@ void mpi_finalize_(int* ierr) { *ierr = MPI_Finalize(); running_processes--; if(running_processes==0){ - xbt_dict_free(&op_lookup); - xbt_dict_free(&type_lookup); - xbt_dict_free(&request_lookup); - xbt_dict_free(&group_lookup); - xbt_dict_free(&comm_lookup); - xbt_dict_free(&win_lookup); - xbt_dict_free(&info_lookup); + F2C::delete_lookup(); } } void mpi_abort_(int* comm, int* errorcode, int* ierr) { - *ierr = MPI_Abort(smpi_comm_f2c(*comm), *errorcode); + *ierr = MPI_Abort(Comm::f2c(*comm), *errorcode); } void mpi_comm_rank_(int* comm, int* rank, int* ierr) { - *ierr = MPI_Comm_rank(smpi_comm_f2c(*comm), rank); + *ierr = MPI_Comm_rank(Comm::f2c(*comm), rank); } void mpi_comm_size_(int* comm, int* size, int* ierr) { - *ierr = MPI_Comm_size(smpi_comm_f2c(*comm), size); + *ierr = MPI_Comm_size(Comm::f2c(*comm), size); } double mpi_wtime_() { @@ -271,55 +132,55 @@ double mpi_wtick_() { void mpi_comm_dup_(int* comm, int* newcomm, int* ierr) { MPI_Comm tmp; - *ierr = MPI_Comm_dup(smpi_comm_f2c(*comm), &tmp); + *ierr = MPI_Comm_dup(Comm::f2c(*comm), &tmp); if(*ierr == MPI_SUCCESS) { - *newcomm = smpi_comm_add_f(tmp); + *newcomm = tmp->add_f(); } } void mpi_comm_create_(int* comm, int* group, int* newcomm, int* ierr) { MPI_Comm tmp; - *ierr = MPI_Comm_create(smpi_comm_f2c(*comm),smpi_group_f2c(*group), &tmp); + *ierr = MPI_Comm_create(Comm::f2c(*comm),Group::f2c(*group), &tmp); if(*ierr == MPI_SUCCESS) { - *newcomm = smpi_comm_add_f(tmp); + *newcomm = tmp->add_f(); } } void mpi_comm_free_(int* comm, int* ierr) { - MPI_Comm tmp = smpi_comm_f2c(*comm); + MPI_Comm tmp = Comm::f2c(*comm); *ierr = MPI_Comm_free(&tmp); if(*ierr == MPI_SUCCESS) { - free_comm(*comm); + Comm::free_f(*comm); } } void mpi_comm_split_(int* comm, int* color, int* key, int* comm_out, int* ierr) { MPI_Comm tmp; - *ierr = MPI_Comm_split(smpi_comm_f2c(*comm), *color, *key, &tmp); + *ierr = MPI_Comm_split(Comm::f2c(*comm), *color, *key, &tmp); if(*ierr == MPI_SUCCESS) { - *comm_out = smpi_comm_add_f(tmp); + *comm_out = tmp->add_f(); } } void mpi_group_incl_(int* group, int* n, int* ranks, int* group_out, int* ierr) { MPI_Group tmp; - *ierr = MPI_Group_incl(smpi_group_f2c(*group), *n, ranks, &tmp); + *ierr = MPI_Group_incl(Group::f2c(*group), *n, ranks, &tmp); if(*ierr == MPI_SUCCESS) { - *group_out = smpi_group_add_f(tmp); + *group_out = tmp->add_f(); } } void mpi_comm_group_(int* comm, int* group_out, int* ierr) { MPI_Group tmp; - *ierr = MPI_Comm_group(smpi_comm_f2c(*comm), &tmp); + *ierr = MPI_Comm_group(Comm::f2c(*comm), &tmp); if(*ierr == MPI_SUCCESS) { - *group_out = smpi_group_c2f(tmp); + *group_out = tmp->c2f(); } } @@ -330,73 +191,73 @@ 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 = static_cast(FORT_BOTTOM(buf)); - *ierr = MPI_Send_init(buf, *count, smpi_type_f2c(*datatype), *dst, *tag, smpi_comm_f2c(*comm), &req); + *ierr = MPI_Send_init(buf, *count, Datatype::f2c(*datatype), *dst, *tag, Comm::f2c(*comm), &req); if(*ierr == MPI_SUCCESS) { - *request = smpi_request_add_f(req); + *request = req->add_f(); } } void mpi_isend_(void *buf, int* count, int* datatype, int* dst, int* tag, int* comm, int* request, int* ierr) { MPI_Request req; buf = static_cast(FORT_BOTTOM(buf)); - *ierr = MPI_Isend(buf, *count, smpi_type_f2c(*datatype), *dst, *tag, smpi_comm_f2c(*comm), &req); + *ierr = MPI_Isend(buf, *count, Datatype::f2c(*datatype), *dst, *tag, Comm::f2c(*comm), &req); if(*ierr == MPI_SUCCESS) { - *request = smpi_request_add_f(req); + *request = req->add_f(); } } void mpi_irsend_(void *buf, int* count, int* datatype, int* dst, int* tag, int* comm, int* request, int* ierr) { MPI_Request req; buf = static_cast(FORT_BOTTOM(buf)); - *ierr = MPI_Irsend(buf, *count, smpi_type_f2c(*datatype), *dst, *tag, smpi_comm_f2c(*comm), &req); + *ierr = MPI_Irsend(buf, *count, Datatype::f2c(*datatype), *dst, *tag, Comm::f2c(*comm), &req); if(*ierr == MPI_SUCCESS) { - *request = smpi_request_add_f(req); + *request = req->add_f(); } } void mpi_send_(void* buf, int* count, int* datatype, int* dst, int* tag, int* comm, int* ierr) { buf = static_cast(FORT_BOTTOM(buf)); - *ierr = MPI_Send(buf, *count, smpi_type_f2c(*datatype), *dst, *tag, smpi_comm_f2c(*comm)); + *ierr = MPI_Send(buf, *count, Datatype::f2c(*datatype), *dst, *tag, Comm::f2c(*comm)); } void mpi_rsend_(void* buf, int* count, int* datatype, int* dst, int* tag, int* comm, int* ierr) { buf = static_cast(FORT_BOTTOM(buf)); - *ierr = MPI_Rsend(buf, *count, smpi_type_f2c(*datatype), *dst, *tag, smpi_comm_f2c(*comm)); + *ierr = MPI_Rsend(buf, *count, Datatype::f2c(*datatype), *dst, *tag, 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 = 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)); + *ierr = MPI_Sendrecv(sendbuf, *sendcount, Datatype::f2c(*sendtype), *dst, *sendtag, recvbuf, *recvcount, + Datatype::f2c(*recvtype), *src, *recvtag, 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 = static_cast( FORT_BOTTOM(buf)); - *ierr = MPI_Recv_init(buf, *count, smpi_type_f2c(*datatype), *src, *tag, smpi_comm_f2c(*comm), &req); + *ierr = MPI_Recv_init(buf, *count, Datatype::f2c(*datatype), *src, *tag, Comm::f2c(*comm), &req); if(*ierr == MPI_SUCCESS) { - *request = smpi_request_add_f(req); + *request = req->add_f(); } } void mpi_irecv_(void *buf, int* count, int* datatype, int* src, int* tag, int* comm, int* request, int* ierr) { MPI_Request req; buf = static_cast( FORT_BOTTOM(buf)); - *ierr = MPI_Irecv(buf, *count, smpi_type_f2c(*datatype), *src, *tag, smpi_comm_f2c(*comm), &req); + *ierr = MPI_Irecv(buf, *count, Datatype::f2c(*datatype), *src, *tag, Comm::f2c(*comm), &req); if(*ierr == MPI_SUCCESS) { - *request = smpi_request_add_f(req); + *request = req->add_f(); } } void mpi_recv_(void* buf, int* count, int* datatype, int* src, int* tag, int* comm, MPI_Status* status, int* ierr) { buf = static_cast( FORT_BOTTOM(buf)); - *ierr = MPI_Recv(buf, *count, smpi_type_f2c(*datatype), *src, *tag, smpi_comm_f2c(*comm), status); + *ierr = MPI_Recv(buf, *count, Datatype::f2c(*datatype), *src, *tag, Comm::f2c(*comm), status); } void mpi_start_(int* request, int* ierr) { - MPI_Request req = smpi_request_f2c(*request); + MPI_Request req = Request::f2c(*request); *ierr = MPI_Start(&req); } @@ -407,18 +268,18 @@ void mpi_startall_(int* count, int* requests, int* ierr) { reqs = xbt_new(MPI_Request, *count); for(i = 0; i < *count; i++) { - reqs[i] = smpi_request_f2c(requests[i]); + reqs[i] = Request::f2c(requests[i]); } *ierr = MPI_Startall(*count, reqs); xbt_free(reqs); } void mpi_wait_(int* request, MPI_Status* status, int* ierr) { - MPI_Request req = smpi_request_f2c(*request); + MPI_Request req = Request::f2c(*request); *ierr = MPI_Wait(&req, FORT_STATUS_IGNORE(status)); if(req==MPI_REQUEST_NULL){ - free_request(*request); + Request::free_f(*request); *request=MPI_FORTRAN_REQUEST_NULL; } } @@ -429,11 +290,11 @@ void mpi_waitany_(int* count, int* requests, int* index, MPI_Status* status, int reqs = xbt_new(MPI_Request, *count); for(i = 0; i < *count; i++) { - reqs[i] = smpi_request_f2c(requests[i]); + reqs[i] = Request::f2c(requests[i]); } *ierr = MPI_Waitany(*count, reqs, index, status); if(reqs[*index]==MPI_REQUEST_NULL){ - free_request(requests[*index]); + Request::free_f(requests[*index]); requests[*index]=MPI_FORTRAN_REQUEST_NULL; } xbt_free(reqs); @@ -445,12 +306,12 @@ void mpi_waitall_(int* count, int* requests, MPI_Status* status, int* ierr) { reqs = xbt_new(MPI_Request, *count); for(i = 0; i < *count; i++) { - reqs[i] = smpi_request_f2c(requests[i]); + reqs[i] = Request::f2c(requests[i]); } *ierr = MPI_Waitall(*count, reqs, FORT_STATUSES_IGNORE(status)); for(i = 0; i < *count; i++) { if(reqs[i]==MPI_REQUEST_NULL){ - free_request(requests[i]); + Request::free_f(requests[i]); requests[i]=MPI_FORTRAN_REQUEST_NULL; } } @@ -459,43 +320,43 @@ void mpi_waitall_(int* count, int* requests, MPI_Status* status, int* ierr) { } void mpi_barrier_(int* comm, int* ierr) { - *ierr = MPI_Barrier(smpi_comm_f2c(*comm)); + *ierr = MPI_Barrier(Comm::f2c(*comm)); } void mpi_bcast_(void *buf, int* count, int* datatype, int* root, int* comm, int* ierr) { - *ierr = MPI_Bcast(buf, *count, smpi_type_f2c(*datatype), *root, smpi_comm_f2c(*comm)); + *ierr = MPI_Bcast(buf, *count, Datatype::f2c(*datatype), *root, Comm::f2c(*comm)); } void mpi_reduce_(void* sendbuf, void* recvbuf, int* count, int* datatype, int* op, int* root, int* comm, int* ierr) { 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)); + *ierr = MPI_Reduce(sendbuf, recvbuf, *count, Datatype::f2c(*datatype), Op::f2c(*op), *root, Comm::f2c(*comm)); } void mpi_allreduce_(void* sendbuf, void* recvbuf, int* count, int* datatype, int* op, int* comm, int* ierr) { 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)); + *ierr = MPI_Allreduce(sendbuf, recvbuf, *count, Datatype::f2c(*datatype), Op::f2c(*op), Comm::f2c(*comm)); } void mpi_reduce_scatter_(void* sendbuf, void* recvbuf, int* recvcounts, int* datatype, int* op, int* comm, int* ierr) { 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)); + *ierr = MPI_Reduce_scatter(sendbuf, recvbuf, recvcounts, Datatype::f2c(*datatype), + Op::f2c(*op), 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 = 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)); + *ierr = MPI_Scatter(sendbuf, *sendcount, Datatype::f2c(*sendtype), + recvbuf, *recvcount, Datatype::f2c(*recvtype), *root, 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 = 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)); + *ierr = MPI_Scatterv(sendbuf, sendcounts, displs, Datatype::f2c(*sendtype), + recvbuf, *recvcount, Datatype::f2c(*recvtype), *root, Comm::f2c(*comm)); } void mpi_gather_(void* sendbuf, int* sendcount, int* sendtype, void* recvbuf, int* recvcount, int* recvtype, @@ -503,8 +364,8 @@ void mpi_gather_(void* sendbuf, int* sendcount, int* sendtype, void* recvbuf, in sendbuf = static_cast( FORT_IN_PLACE(sendbuf)); sendbuf = sendbuf!=MPI_IN_PLACE ? static_cast( FORT_BOTTOM(sendbuf)) : MPI_IN_PLACE; 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)); + *ierr = MPI_Gather(sendbuf, *sendcount, Datatype::f2c(*sendtype), + recvbuf, *recvcount, Datatype::f2c(*recvtype), *root, Comm::f2c(*comm)); } void mpi_gatherv_(void* sendbuf, int* sendcount, int* sendtype, @@ -512,46 +373,46 @@ void mpi_gatherv_(void* sendbuf, int* sendcount, int* sendtype, sendbuf = static_cast( FORT_IN_PLACE(sendbuf)); sendbuf = sendbuf!=MPI_IN_PLACE ? static_cast( FORT_BOTTOM(sendbuf)) : MPI_IN_PLACE; 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)); + *ierr = MPI_Gatherv(sendbuf, *sendcount, Datatype::f2c(*sendtype), + recvbuf, recvcounts, displs, Datatype::f2c(*recvtype), *root, Comm::f2c(*comm)); } void mpi_allgather_(void* sendbuf, int* sendcount, int* sendtype, void* recvbuf, int* recvcount, int* recvtype, int* comm, int* ierr) { 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)); + *ierr = MPI_Allgather(sendbuf, *sendcount, Datatype::f2c(*sendtype), + recvbuf, *recvcount, Datatype::f2c(*recvtype), 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 = 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)); + *ierr = MPI_Allgatherv(sendbuf, *sendcount, Datatype::f2c(*sendtype), + recvbuf, recvcounts, displs, Datatype::f2c(*recvtype), Comm::f2c(*comm)); } void mpi_scan_(void* sendbuf, void* recvbuf, int* count, int* datatype, int* op, int* comm, int* ierr) { - *ierr = MPI_Scan(sendbuf, recvbuf, *count, smpi_type_f2c(*datatype), - smpi_op_f2c(*op), smpi_comm_f2c(*comm)); + *ierr = MPI_Scan(sendbuf, recvbuf, *count, Datatype::f2c(*datatype), + Op::f2c(*op), Comm::f2c(*comm)); } void mpi_alltoall_(void* sendbuf, int* sendcount, int* sendtype, void* recvbuf, int* recvcount, int* recvtype, int* comm, int* ierr) { - *ierr = MPI_Alltoall(sendbuf, *sendcount, smpi_type_f2c(*sendtype), - recvbuf, *recvcount, smpi_type_f2c(*recvtype), smpi_comm_f2c(*comm)); + *ierr = MPI_Alltoall(sendbuf, *sendcount, Datatype::f2c(*sendtype), + recvbuf, *recvcount, Datatype::f2c(*recvtype), Comm::f2c(*comm)); } void mpi_alltoallv_(void* sendbuf, int* sendcounts, int* senddisps, int* sendtype, void* recvbuf, int* recvcounts, int* recvdisps, int* recvtype, int* comm, int* ierr) { - *ierr = MPI_Alltoallv(sendbuf, sendcounts, senddisps, smpi_type_f2c(*sendtype), - recvbuf, recvcounts, recvdisps, smpi_type_f2c(*recvtype), smpi_comm_f2c(*comm)); + *ierr = MPI_Alltoallv(sendbuf, sendcounts, senddisps, Datatype::f2c(*sendtype), + recvbuf, recvcounts, recvdisps, Datatype::f2c(*recvtype), Comm::f2c(*comm)); } void mpi_test_ (int * request, int *flag, MPI_Status * status, int* ierr){ - MPI_Request req = smpi_request_f2c(*request); + MPI_Request req = Request::f2c(*request); *ierr= MPI_Test(&req, flag, FORT_STATUS_IGNORE(status)); if(req==MPI_REQUEST_NULL){ - free_request(*request); + Request::free_f(*request); *request=MPI_FORTRAN_REQUEST_NULL; } } @@ -560,12 +421,12 @@ void mpi_testall_ (int* count, int * requests, int *flag, MPI_Status * statuses int i; MPI_Request* reqs = xbt_new(MPI_Request, *count); for(i = 0; i < *count; i++) { - reqs[i] = smpi_request_f2c(requests[i]); + reqs[i] = Request::f2c(requests[i]); } *ierr= MPI_Testall(*count, reqs, flag, FORT_STATUSES_IGNORE(statuses)); for(i = 0; i < *count; i++) { if(reqs[i]==MPI_REQUEST_NULL){ - free_request(requests[i]); + Request::free_f(requests[i]); requests[i]=MPI_FORTRAN_REQUEST_NULL; } } @@ -577,73 +438,73 @@ void mpi_get_processor_name_(char *name, int *resultlen, int* ierr){ } void mpi_get_count_(MPI_Status * status, int* datatype, int *count, int* ierr){ - *ierr = MPI_Get_count(FORT_STATUS_IGNORE(status), smpi_type_f2c(*datatype), count); + *ierr = MPI_Get_count(FORT_STATUS_IGNORE(status), Datatype::f2c(*datatype), count); } void mpi_attr_get_(int* comm, int* keyval, void* attr_value, int* flag, int* ierr ){ - *ierr = MPI_Attr_get(smpi_comm_f2c(*comm), *keyval, attr_value, flag); + *ierr = MPI_Attr_get(Comm::f2c(*comm), *keyval, attr_value, flag); } void mpi_type_extent_(int* datatype, MPI_Aint * extent, int* ierr){ - *ierr= MPI_Type_extent(smpi_type_f2c(*datatype), extent); + *ierr= MPI_Type_extent(Datatype::f2c(*datatype), extent); } void mpi_type_commit_(int* datatype, int* ierr){ - MPI_Datatype tmp= smpi_type_f2c(*datatype); + MPI_Datatype tmp= Datatype::f2c(*datatype); *ierr= MPI_Type_commit(&tmp); } void mpi_type_vector_(int* count, int* blocklen, int* stride, int* old_type, int* newtype, int* ierr){ MPI_Datatype tmp; - *ierr= MPI_Type_vector(*count, *blocklen, *stride, smpi_type_f2c(*old_type), &tmp); + *ierr= MPI_Type_vector(*count, *blocklen, *stride, Datatype::f2c(*old_type), &tmp); if(*ierr == MPI_SUCCESS) { - *newtype = smpi_type_add_f(tmp); + *newtype = tmp->add_f(); } } void mpi_type_create_vector_(int* count, int* blocklen, int* stride, int* old_type, int* newtype, int* ierr){ MPI_Datatype tmp; - *ierr= MPI_Type_vector(*count, *blocklen, *stride, smpi_type_f2c(*old_type), &tmp); + *ierr= MPI_Type_vector(*count, *blocklen, *stride, Datatype::f2c(*old_type), &tmp); if(*ierr == MPI_SUCCESS) { - *newtype = smpi_type_add_f(tmp); + *newtype = tmp->add_f(); } } void mpi_type_hvector_(int* count, int* blocklen, MPI_Aint* stride, int* old_type, int* newtype, int* ierr){ MPI_Datatype tmp; - *ierr= MPI_Type_hvector (*count, *blocklen, *stride, smpi_type_f2c(*old_type), &tmp); + *ierr= MPI_Type_hvector (*count, *blocklen, *stride, Datatype::f2c(*old_type), &tmp); if(*ierr == MPI_SUCCESS) { - *newtype = smpi_type_add_f(tmp); + *newtype = tmp->add_f(); } } void mpi_type_create_hvector_(int* count, int* blocklen, MPI_Aint* stride, int* old_type, int* newtype, int* ierr){ MPI_Datatype tmp; - *ierr= MPI_Type_hvector(*count, *blocklen, *stride, smpi_type_f2c(*old_type), &tmp); + *ierr= MPI_Type_hvector(*count, *blocklen, *stride, Datatype::f2c(*old_type), &tmp); if(*ierr == MPI_SUCCESS) { - *newtype = smpi_type_add_f(tmp); + *newtype = tmp->add_f(); } } void mpi_type_free_(int* datatype, int* ierr){ - MPI_Datatype tmp= smpi_type_f2c(*datatype); + MPI_Datatype tmp= Datatype::f2c(*datatype); *ierr= MPI_Type_free (&tmp); if(*ierr == MPI_SUCCESS) { - free_type(*datatype); + Datatype::free_f(*datatype); } } void mpi_type_ub_(int* datatype, MPI_Aint * disp, int* ierr){ - *ierr= MPI_Type_ub(smpi_type_f2c(*datatype), disp); + *ierr= MPI_Type_ub(Datatype::f2c(*datatype), disp); } void mpi_type_lb_(int* datatype, MPI_Aint * extent, int* ierr){ - *ierr= MPI_Type_extent(smpi_type_f2c(*datatype), extent); + *ierr= MPI_Type_extent(Datatype::f2c(*datatype), extent); } void mpi_type_size_(int* datatype, int *size, int* ierr) { - *ierr = MPI_Type_size(smpi_type_f2c(*datatype), size); + *ierr = MPI_Type_size(Datatype::f2c(*datatype), size); } void mpi_error_string_(int* errorcode, char* string, int* resultlen, int* ierr){ @@ -651,39 +512,39 @@ void mpi_error_string_(int* errorcode, char* string, int* resultlen, int* ierr){ } void mpi_win_fence_( int* assert, int* win, int* ierr){ - *ierr = MPI_Win_fence(* assert, smpi_win_f2c(*win)); + *ierr = MPI_Win_fence(* assert, Win::f2c(*win)); } void mpi_win_free_( int* win, int* ierr){ - MPI_Win tmp = smpi_win_f2c(*win); + MPI_Win tmp = Win::f2c(*win); *ierr = MPI_Win_free(&tmp); if(*ierr == MPI_SUCCESS) { - free_win(*win); + Win::free_f(*win); } } 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( static_cast(base), *size, *disp_unit, smpi_info_f2c(*info), smpi_comm_f2c(*comm),&tmp); + *ierr = MPI_Win_create( static_cast(base), *size, *disp_unit, Info::f2c(*info), Comm::f2c(*comm),&tmp); if(*ierr == MPI_SUCCESS) { - *win = smpi_win_add_f(tmp); + *win = tmp->add_f(); } } void mpi_win_post_(int* group, int assert, int* win, int* ierr){ - *ierr = MPI_Win_post(smpi_group_f2c(*group), assert, smpi_win_f2c(*win)); + *ierr = MPI_Win_post(Group::f2c(*group), assert, Win::f2c(*win)); } void mpi_win_start_(int* group, int assert, int* win, int* ierr){ - *ierr = MPI_Win_start(smpi_group_f2c(*group), assert, smpi_win_f2c(*win)); + *ierr = MPI_Win_start(Group::f2c(*group), assert, Win::f2c(*win)); } void mpi_win_complete_(int* win, int* ierr){ - *ierr = MPI_Win_complete(smpi_win_f2c(*win)); + *ierr = MPI_Win_complete(Win::f2c(*win)); } void mpi_win_wait_(int* win, int* ierr){ - *ierr = MPI_Win_wait(smpi_win_f2c(*win)); + *ierr = MPI_Win_wait(Win::f2c(*win)); } void mpi_win_set_name_ (int* win, char * name, int* ierr, int size){ @@ -697,12 +558,12 @@ void mpi_win_set_name_ (int* win, char * name, int* ierr, int size){ char* tname = xbt_new(char,size+1); strncpy(tname, name, size); tname[size]='\0'; - *ierr = MPI_Win_set_name(smpi_win_f2c(*win), tname); + *ierr = MPI_Win_set_name(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); + *ierr = MPI_Win_get_name(Win::f2c(*win),name,len); if(*len>0) name[*len]=' ';//blank padding, not \0 } @@ -711,7 +572,7 @@ void mpi_info_create_( int *info, int* ierr){ MPI_Info tmp; *ierr = MPI_Info_create(&tmp); if(*ierr == MPI_SUCCESS) { - *info = smpi_info_add_f(tmp); + *info = tmp->add_f(); } } @@ -737,7 +598,7 @@ void mpi_info_set_( int *info, char *key, char *value, int* ierr, unsigned int k strncpy(tvalue, value, valuelen); tvalue[valuelen]='\0'; - *ierr = MPI_Info_set( smpi_info_f2c(*info), tkey, tvalue); + *ierr = MPI_Info_set( Info::f2c(*info), tkey, tvalue); xbt_free(tkey); xbt_free(tvalue); } @@ -752,7 +613,7 @@ void mpi_info_get_ (int* info,char *key,int* valuelen, char *value, int *flag, i 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); + *ierr = MPI_Info_get(Info::f2c(*info),tkey,*valuelen, value, flag); xbt_free(tkey); if(*flag!=0){ int replace=0; @@ -767,29 +628,29 @@ void mpi_info_get_ (int* info,char *key,int* valuelen, char *value, int *flag, i } void mpi_info_free_(int* info, int* ierr){ - MPI_Info tmp = smpi_info_f2c(*info); + MPI_Info tmp = Info::f2c(*info); *ierr = MPI_Info_free(&tmp); if(*ierr == MPI_SUCCESS) { - free_info(*info); + Info::free_f(*info); } } 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( 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)); + *ierr = MPI_Get( static_cast(origin_addr),*origin_count, Datatype::f2c(*origin_datatype),*target_rank, + *target_disp, *target_count,Datatype::f2c(*tarsmpi_type_f2c), 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( 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)); + *ierr = MPI_Accumulate( static_cast(origin_addr),*origin_count, Datatype::f2c(*origin_datatype),*target_rank, + *target_disp, *target_count,Datatype::f2c(*tarsmpi_type_f2c), Op::f2c(*op), 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( 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)); + *ierr = MPI_Put( static_cast(origin_addr),*origin_count, Datatype::f2c(*origin_datatype),*target_rank, + *target_disp, *target_count,Datatype::f2c(*tarsmpi_type_f2c), Win::f2c(*win)); } //following are automatically generated, and have to be checked @@ -826,9 +687,9 @@ void mpi_get_address_ (void *location, MPI_Aint * address, int* ierr){ void mpi_type_dup_ (int* datatype, int* newdatatype, int* ierr){ MPI_Datatype tmp; - *ierr = MPI_Type_dup(smpi_type_f2c(*datatype), &tmp); + *ierr = MPI_Type_dup(Datatype::f2c(*datatype), &tmp); if(*ierr == MPI_SUCCESS) { - *newdatatype = smpi_type_add_f(tmp); + *newdatatype = tmp->add_f(); } } @@ -836,29 +697,29 @@ void mpi_type_set_name_ (int* datatype, char * name, int* ierr, int size){ char* tname = xbt_new(char, size+1); strncpy(tname, name, size); tname[size]='\0'; - *ierr = MPI_Type_set_name(smpi_type_f2c(*datatype), tname); + *ierr = MPI_Type_set_name(Datatype::f2c(*datatype), tname); xbt_free(tname); } void mpi_type_get_name_ (int* datatype, char * name, int* len, int* ierr){ - *ierr = MPI_Type_get_name(smpi_type_f2c(*datatype),name,len); + *ierr = MPI_Type_get_name(Datatype::f2c(*datatype),name,len); if(*len>0) name[*len]=' '; } void mpi_type_get_attr_ (int* type, int* type_keyval, void *attribute_val, int* flag, int* ierr){ - *ierr = MPI_Type_get_attr ( smpi_type_f2c(*type), *type_keyval, attribute_val,flag); + *ierr = MPI_Type_get_attr ( Datatype::f2c(*type), *type_keyval, attribute_val,flag); } void mpi_type_set_attr_ (int* type, int* type_keyval, void *attribute_val, int* ierr){ - *ierr = MPI_Type_set_attr ( smpi_type_f2c(*type), *type_keyval, attribute_val); + *ierr = MPI_Type_set_attr ( Datatype::f2c(*type), *type_keyval, attribute_val); } void mpi_type_delete_attr_ (int* type, int* type_keyval, int* ierr){ - *ierr = MPI_Type_delete_attr ( smpi_type_f2c(*type), *type_keyval); + *ierr = MPI_Type_delete_attr ( Datatype::f2c(*type), *type_keyval); } void mpi_type_create_keyval_ (void* copy_fn, void* delete_fn, int* keyval, void* extra_state, int* ierr){ @@ -877,12 +738,12 @@ void mpi_pcontrol_ (int* level , int* ierr){ void mpi_type_get_extent_ (int* datatype, MPI_Aint * lb, MPI_Aint * extent, int* ierr){ - *ierr = MPI_Type_get_extent(smpi_type_f2c(*datatype), lb, extent); + *ierr = MPI_Type_get_extent(Datatype::f2c(*datatype), lb, extent); } void mpi_type_get_true_extent_ (int* datatype, MPI_Aint * lb, MPI_Aint * extent, int* ierr){ - *ierr = MPI_Type_get_true_extent(smpi_type_f2c(*datatype), lb, extent); + *ierr = MPI_Type_get_true_extent(Datatype::f2c(*datatype), lb, extent); } void mpi_op_create_ (void * function, int* commute, int* op, int* ierr){ @@ -890,110 +751,110 @@ void mpi_op_create_ (void * function, int* commute, int* op, int* ierr){ *ierr = MPI_Op_create(reinterpret_cast(function),*commute, &tmp); if(*ierr == MPI_SUCCESS) { tmp->set_fortran_op(); - *op = smpi_op_add_f(tmp); + *op = tmp->add_f(); } } void mpi_op_free_ (int* op, int* ierr){ - MPI_Op tmp=smpi_op_f2c(*op); + MPI_Op tmp=Op::f2c(*op); *ierr = MPI_Op_free(& tmp); if(*ierr == MPI_SUCCESS) { - free_op(*op); + Op::free_f(*op); } } void mpi_group_free_ (int* group, int* ierr){ - MPI_Group tmp=smpi_group_f2c(*group); + MPI_Group tmp=Group::f2c(*group); *ierr = MPI_Group_free(&tmp); if(*ierr == MPI_SUCCESS) { - free_group(*group); + Group::free_f(*group); } } void mpi_group_size_ (int* group, int *size, int* ierr){ - *ierr = MPI_Group_size(smpi_group_f2c(*group), size); + *ierr = MPI_Group_size(Group::f2c(*group), size); } void mpi_group_rank_ (int* group, int *rank, int* ierr){ - *ierr = MPI_Group_rank(smpi_group_f2c(*group), rank); + *ierr = MPI_Group_rank(Group::f2c(*group), rank); } void mpi_group_translate_ranks_ (int* group1, int* n, int *ranks1, int* group2, int *ranks2, int* ierr) { - *ierr = MPI_Group_translate_ranks(smpi_group_f2c(*group1), *n, ranks1, smpi_group_f2c(*group2), ranks2); + *ierr = MPI_Group_translate_ranks(Group::f2c(*group1), *n, ranks1, Group::f2c(*group2), ranks2); } void mpi_group_compare_ (int* group1, int* group2, int *result, int* ierr){ - *ierr = MPI_Group_compare(smpi_group_f2c(*group1), smpi_group_f2c(*group2), result); + *ierr = MPI_Group_compare(Group::f2c(*group1), Group::f2c(*group2), result); } void mpi_group_union_ (int* group1, int* group2, int* newgroup, int* ierr){ MPI_Group tmp; - *ierr = MPI_Group_union(smpi_group_f2c(*group1), smpi_group_f2c(*group2), &tmp); + *ierr = MPI_Group_union(Group::f2c(*group1), Group::f2c(*group2), &tmp); if(*ierr == MPI_SUCCESS) { - *newgroup = smpi_group_add_f(tmp); + *newgroup = tmp->add_f(); } } void mpi_group_intersection_ (int* group1, int* group2, int* newgroup, int* ierr){ MPI_Group tmp; - *ierr = MPI_Group_intersection(smpi_group_f2c(*group1), smpi_group_f2c(*group2), &tmp); + *ierr = MPI_Group_intersection(Group::f2c(*group1), Group::f2c(*group2), &tmp); if(*ierr == MPI_SUCCESS) { - *newgroup = smpi_group_add_f(tmp); + *newgroup = tmp->add_f(); } } void mpi_group_difference_ (int* group1, int* group2, int* newgroup, int* ierr){ MPI_Group tmp; - *ierr = MPI_Group_difference(smpi_group_f2c(*group1), smpi_group_f2c(*group2), &tmp); + *ierr = MPI_Group_difference(Group::f2c(*group1), Group::f2c(*group2), &tmp); if(*ierr == MPI_SUCCESS) { - *newgroup = smpi_group_add_f(tmp); + *newgroup = tmp->add_f(); } } void mpi_group_excl_ (int* group, int* n, int *ranks, int* newgroup, int* ierr){ MPI_Group tmp; - *ierr = MPI_Group_excl(smpi_group_f2c(*group), *n, ranks, &tmp); + *ierr = MPI_Group_excl(Group::f2c(*group), *n, ranks, &tmp); if(*ierr == MPI_SUCCESS) { - *newgroup = smpi_group_add_f(tmp); + *newgroup = tmp->add_f(); } } void mpi_group_range_incl_ (int* group, int* n, int ranges[][3], int* newgroup, int* ierr) { MPI_Group tmp; - *ierr = MPI_Group_range_incl(smpi_group_f2c(*group), *n, ranges, &tmp); + *ierr = MPI_Group_range_incl(Group::f2c(*group), *n, ranges, &tmp); if(*ierr == MPI_SUCCESS) { - *newgroup = smpi_group_add_f(tmp); + *newgroup = tmp->add_f(); } } void mpi_group_range_excl_ (int* group, int* n, int ranges[][3], int* newgroup, int* ierr) { MPI_Group tmp; - *ierr = MPI_Group_range_excl(smpi_group_f2c(*group), *n, ranges, &tmp); + *ierr = MPI_Group_range_excl(Group::f2c(*group), *n, ranges, &tmp); if(*ierr == MPI_SUCCESS) { - *newgroup = smpi_group_add_f(tmp); + *newgroup = tmp->add_f(); } } void mpi_comm_get_attr_ (int* comm, int* comm_keyval, void *attribute_val, int *flag, int* ierr){ - *ierr = MPI_Comm_get_attr (smpi_comm_f2c(*comm), *comm_keyval, attribute_val, flag); + *ierr = MPI_Comm_get_attr (Comm::f2c(*comm), *comm_keyval, attribute_val, flag); } void mpi_comm_set_attr_ (int* comm, int* comm_keyval, void *attribute_val, int* ierr){ - *ierr = MPI_Comm_set_attr ( smpi_comm_f2c(*comm), *comm_keyval, attribute_val); + *ierr = MPI_Comm_set_attr ( Comm::f2c(*comm), *comm_keyval, attribute_val); } void mpi_comm_delete_attr_ (int* comm, int* comm_keyval, int* ierr){ - *ierr = MPI_Comm_delete_attr (smpi_comm_f2c(*comm), *comm_keyval); + *ierr = MPI_Comm_delete_attr (Comm::f2c(*comm), *comm_keyval); } void mpi_comm_create_keyval_ (void* copy_fn, void* delete_fn, int* keyval, void* extra_state, int* ierr){ @@ -1007,37 +868,37 @@ 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); + *ierr = MPI_Comm_get_name(Comm::f2c(*comm), name, len); if(*len>0) name[*len]=' '; } void mpi_comm_compare_ (int* comm1, int* comm2, int *result, int* ierr){ - *ierr = MPI_Comm_compare(smpi_comm_f2c(*comm1), smpi_comm_f2c(*comm2), result); + *ierr = MPI_Comm_compare(Comm::f2c(*comm1), Comm::f2c(*comm2), result); } void mpi_comm_disconnect_ (int* comm, int* ierr){ - MPI_Comm tmp=smpi_comm_f2c(*comm); + MPI_Comm tmp=Comm::f2c(*comm); *ierr = MPI_Comm_disconnect(&tmp); if(*ierr == MPI_SUCCESS) { - free_comm(*comm); + Comm::free_f(*comm); } } void mpi_request_free_ (int* request, int* ierr){ - MPI_Request tmp=smpi_request_f2c(*request); + MPI_Request tmp=Request::f2c(*request); *ierr = MPI_Request_free(&tmp); if(*ierr == MPI_SUCCESS) { - free_request(*request); + Request::free_f(*request); } } void mpi_sendrecv_replace_ (void *buf, int* count, int* datatype, int* dst, int* sendtag, int* src, int* recvtag, int* comm, MPI_Status* status, int* ierr) { - *ierr = MPI_Sendrecv_replace(buf, *count, smpi_type_f2c(*datatype), *dst, *sendtag, *src, - *recvtag, smpi_comm_f2c(*comm), FORT_STATUS_IGNORE(status)); + *ierr = MPI_Sendrecv_replace(buf, *count, Datatype::f2c(*datatype), *dst, *sendtag, *src, + *recvtag, Comm::f2c(*comm), FORT_STATUS_IGNORE(status)); } void mpi_testany_ (int* count, int* requests, int *index, int *flag, MPI_Status* status, int* ierr) @@ -1047,11 +908,11 @@ void mpi_testany_ (int* count, int* requests, int *index, int *flag, MPI_Status* reqs = xbt_new(MPI_Request, *count); for(i = 0; i < *count; i++) { - reqs[i] = smpi_request_f2c(requests[i]); + reqs[i] = Request::f2c(requests[i]); } *ierr = MPI_Testany(*count, reqs, index, flag, FORT_STATUS_IGNORE(status)); if(*index!=MPI_UNDEFINED && reqs[*index]==MPI_REQUEST_NULL){ - free_request(requests[*index]); + Request::free_f(requests[*index]); requests[*index]=MPI_FORTRAN_REQUEST_NULL; } xbt_free(reqs); @@ -1064,12 +925,12 @@ void mpi_waitsome_ (int* incount, int* requests, int *outcount, int *indices, MP reqs = xbt_new(MPI_Request, *incount); for(i = 0; i < *incount; i++) { - reqs[i] = smpi_request_f2c(requests[i]); + reqs[i] = Request::f2c(requests[i]); } *ierr = MPI_Waitsome(*incount, reqs, outcount, indices, status); for(i=0;i<*outcount;i++){ if(reqs[indices[i]]==MPI_REQUEST_NULL){ - free_request(requests[indices[i]]); + Request::free_f(requests[indices[i]]); requests[indices[i]]=MPI_FORTRAN_REQUEST_NULL; } } @@ -1078,91 +939,91 @@ void mpi_waitsome_ (int* incount, int* requests, int *outcount, int *indices, MP void mpi_reduce_local_ (void *inbuf, void *inoutbuf, int* count, int* datatype, int* op, int* ierr){ - *ierr = MPI_Reduce_local(inbuf, inoutbuf, *count, smpi_type_f2c(*datatype), smpi_op_f2c(*op)); + *ierr = MPI_Reduce_local(inbuf, inoutbuf, *count, Datatype::f2c(*datatype), Op::f2c(*op)); } void mpi_reduce_scatter_block_ (void *sendbuf, void *recvbuf, int* recvcount, int* datatype, int* op, int* comm, int* ierr) { 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)); + *ierr = MPI_Reduce_scatter_block(sendbuf, recvbuf, *recvcount, Datatype::f2c(*datatype), Op::f2c(*op), + Comm::f2c(*comm)); } void mpi_pack_size_ (int* incount, int* datatype, int* comm, int* size, int* ierr) { - *ierr = MPI_Pack_size(*incount, smpi_type_f2c(*datatype), smpi_comm_f2c(*comm), size); + *ierr = MPI_Pack_size(*incount, Datatype::f2c(*datatype), Comm::f2c(*comm), size); } void mpi_cart_coords_ (int* comm, int* rank, int* maxdims, int* coords, int* ierr) { - *ierr = MPI_Cart_coords(smpi_comm_f2c(*comm), *rank, *maxdims, coords); + *ierr = MPI_Cart_coords(Comm::f2c(*comm), *rank, *maxdims, coords); } void mpi_cart_create_ (int* comm_old, int* ndims, int* dims, int* periods, int* reorder, int* comm_cart, int* ierr) { MPI_Comm tmp; - *ierr = MPI_Cart_create(smpi_comm_f2c(*comm_old), *ndims, dims, periods, *reorder, &tmp); + *ierr = MPI_Cart_create(Comm::f2c(*comm_old), *ndims, dims, periods, *reorder, &tmp); if(*ierr == MPI_SUCCESS) { - *comm_cart = smpi_comm_add_f(tmp); + *comm_cart = tmp->add_f(); } } void mpi_cart_get_ (int* comm, int* maxdims, int* dims, int* periods, int* coords, int* ierr) { - *ierr = MPI_Cart_get(smpi_comm_f2c(*comm), *maxdims, dims, periods, coords); + *ierr = MPI_Cart_get(Comm::f2c(*comm), *maxdims, dims, periods, coords); } void mpi_cart_map_ (int* comm_old, int* ndims, int* dims, int* periods, int* newrank, int* ierr) { - *ierr = MPI_Cart_map(smpi_comm_f2c(*comm_old), *ndims, dims, periods, newrank); + *ierr = MPI_Cart_map(Comm::f2c(*comm_old), *ndims, dims, periods, newrank); } void mpi_cart_rank_ (int* comm, int* coords, int* rank, int* ierr) { - *ierr = MPI_Cart_rank(smpi_comm_f2c(*comm), coords, rank); + *ierr = MPI_Cart_rank(Comm::f2c(*comm), coords, rank); } void mpi_cart_shift_ (int* comm, int* direction, int* displ, int* source, int* dest, int* ierr) { - *ierr = MPI_Cart_shift(smpi_comm_f2c(*comm), *direction, *displ, source, dest); + *ierr = MPI_Cart_shift(Comm::f2c(*comm), *direction, *displ, source, dest); } void mpi_cart_sub_ (int* comm, int* remain_dims, int* comm_new, int* ierr) { MPI_Comm tmp; - *ierr = MPI_Cart_sub(smpi_comm_f2c(*comm), remain_dims, &tmp); + *ierr = MPI_Cart_sub(Comm::f2c(*comm), remain_dims, &tmp); if(*ierr == MPI_SUCCESS) { - *comm_new = smpi_comm_add_f(tmp); + *comm_new = tmp->add_f(); } } void mpi_cartdim_get_ (int* comm, int* ndims, int* ierr) { - *ierr = MPI_Cartdim_get(smpi_comm_f2c(*comm), ndims); + *ierr = MPI_Cartdim_get(Comm::f2c(*comm), ndims); } void mpi_graph_create_ (int* comm_old, int* nnodes, int* index, int* edges, int* reorder, int* comm_graph, int* ierr) { MPI_Comm tmp; - *ierr = MPI_Graph_create(smpi_comm_f2c(*comm_old), *nnodes, index, edges, *reorder, &tmp); + *ierr = MPI_Graph_create(Comm::f2c(*comm_old), *nnodes, index, edges, *reorder, &tmp); if(*ierr == MPI_SUCCESS) { - *comm_graph = smpi_comm_add_f(tmp); + *comm_graph = tmp->add_f(); } } void mpi_graph_get_ (int* comm, int* maxindex, int* maxedges, int* index, int* edges, int* ierr) { - *ierr = MPI_Graph_get(smpi_comm_f2c(*comm), *maxindex, *maxedges, index, edges); + *ierr = MPI_Graph_get(Comm::f2c(*comm), *maxindex, *maxedges, index, edges); } void mpi_graph_map_ (int* comm_old, int* nnodes, int* index, int* edges, int* newrank, int* ierr) { - *ierr = MPI_Graph_map(smpi_comm_f2c(*comm_old), *nnodes, index, edges, newrank); + *ierr = MPI_Graph_map(Comm::f2c(*comm_old), *nnodes, index, edges, newrank); } void mpi_graph_neighbors_ (int* comm, int* rank, int* maxneighbors, int* neighbors, int* ierr) { - *ierr = MPI_Graph_neighbors(smpi_comm_f2c(*comm), *rank, *maxneighbors, neighbors); + *ierr = MPI_Graph_neighbors(Comm::f2c(*comm), *rank, *maxneighbors, neighbors); } void mpi_graph_neighbors_count_ (int* comm, int* rank, int* nneighbors, int* ierr) { - *ierr = MPI_Graph_neighbors_count(smpi_comm_f2c(*comm), *rank, nneighbors); + *ierr = MPI_Graph_neighbors_count(Comm::f2c(*comm), *rank, nneighbors); } void mpi_graphdims_get_ (int* comm, int* nnodes, int* nedges, int* ierr) { - *ierr = MPI_Graphdims_get(smpi_comm_f2c(*comm), nnodes, nedges); + *ierr = MPI_Graphdims_get(Comm::f2c(*comm), nnodes, nedges); } void mpi_topo_test_ (int* comm, int* top_type, int* ierr) { - *ierr = MPI_Topo_test(smpi_comm_f2c(*comm), top_type); + *ierr = MPI_Topo_test(Comm::f2c(*comm), top_type); } void mpi_error_class_ (int* errorcode, int* errorclass, int* ierr) { @@ -1178,31 +1039,31 @@ void mpi_errhandler_free_ (void* errhandler, int* ierr) { } void mpi_errhandler_get_ (int* comm, void* errhandler, int* ierr) { - *ierr = MPI_Errhandler_get(smpi_comm_f2c(*comm), static_cast(errhandler)); + *ierr = MPI_Errhandler_get(Comm::f2c(*comm), static_cast(errhandler)); } void mpi_errhandler_set_ (int* comm, void* errhandler, int* ierr) { - *ierr = MPI_Errhandler_set(smpi_comm_f2c(*comm), *static_cast(errhandler)); + *ierr = MPI_Errhandler_set(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), *static_cast(errhandler)); + *ierr = MPI_Errhandler_set(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), static_cast(errhandler)); + *ierr = MPI_Errhandler_set(Comm::f2c(*comm), static_cast(errhandler)); } void mpi_type_contiguous_ (int* count, int* old_type, int* newtype, int* ierr) { MPI_Datatype tmp; - *ierr = MPI_Type_contiguous(*count, smpi_type_f2c(*old_type), &tmp); + *ierr = MPI_Type_contiguous(*count, Datatype::f2c(*old_type), &tmp); if(*ierr == MPI_SUCCESS) { - *newtype = smpi_type_add_f(tmp); + *newtype = tmp->add_f(); } } void mpi_cancel_ (int* request, int* ierr) { - MPI_Request tmp=smpi_request_f2c(*request); + MPI_Request tmp=Request::f2c(*request); *ierr = MPI_Cancel(&tmp); } @@ -1220,13 +1081,13 @@ void mpi_testsome_ (int* incount, int* requests, int* outcount, int* indices, M reqs = xbt_new(MPI_Request, *incount); for(i = 0; i < *incount; i++) { - reqs[i] = smpi_request_f2c(requests[i]); + reqs[i] = Request::f2c(requests[i]); indices[i]=0; } *ierr = MPI_Testsome(*incount, reqs, outcount, indices, FORT_STATUSES_IGNORE(statuses)); for(i=0;i<*incount;i++){ if(indices[i] && reqs[indices[i]]==MPI_REQUEST_NULL){ - free_request(requests[indices[i]]); + Request::free_f(requests[indices[i]]); requests[indices[i]]=MPI_FORTRAN_REQUEST_NULL; } } @@ -1234,67 +1095,67 @@ void mpi_testsome_ (int* incount, int* requests, int* outcount, int* indices, M } void mpi_comm_test_inter_ (int* comm, int* flag, int* ierr) { - *ierr = MPI_Comm_test_inter(smpi_comm_f2c(*comm), flag); + *ierr = MPI_Comm_test_inter(Comm::f2c(*comm), flag); } void mpi_unpack_ (void* inbuf, int* insize, int* position, void* outbuf, int* outcount, int* type, int* comm, int* ierr) { - *ierr = MPI_Unpack(inbuf, *insize, position, outbuf, *outcount, smpi_type_f2c(*type), smpi_comm_f2c(*comm)); + *ierr = MPI_Unpack(inbuf, *insize, position, outbuf, *outcount, Datatype::f2c(*type), Comm::f2c(*comm)); } void mpi_pack_external_size_ (char *datarep, int* incount, int* datatype, MPI_Aint *size, int* ierr){ - *ierr = MPI_Pack_external_size(datarep, *incount, smpi_type_f2c(*datatype), size); + *ierr = MPI_Pack_external_size(datarep, *incount, Datatype::f2c(*datatype), size); } void mpi_pack_external_ (char *datarep, void *inbuf, int* incount, int* datatype, void *outbuf, MPI_Aint* outcount, MPI_Aint *position, int* ierr){ - *ierr = MPI_Pack_external(datarep, inbuf, *incount, smpi_type_f2c(*datatype), outbuf, *outcount, position); + *ierr = MPI_Pack_external(datarep, inbuf, *incount, Datatype::f2c(*datatype), outbuf, *outcount, position); } void mpi_unpack_external_ ( char *datarep, void *inbuf, MPI_Aint* insize, MPI_Aint *position, void *outbuf, int* outcount, int* datatype, int* ierr){ - *ierr = MPI_Unpack_external( datarep, inbuf, *insize, position, outbuf, *outcount, smpi_type_f2c(*datatype)); + *ierr = MPI_Unpack_external( datarep, inbuf, *insize, position, outbuf, *outcount, Datatype::f2c(*datatype)); } void mpi_type_hindexed_ (int* count, int* blocklens, MPI_Aint* indices, int* old_type, int* newtype, int* ierr) { MPI_Datatype tmp; - *ierr = MPI_Type_hindexed(*count, blocklens, indices, smpi_type_f2c(*old_type), &tmp); + *ierr = MPI_Type_hindexed(*count, blocklens, indices, Datatype::f2c(*old_type), &tmp); if(*ierr == MPI_SUCCESS) { - *newtype = smpi_type_add_f(tmp); + *newtype = tmp->add_f(); } } void mpi_type_create_hindexed_(int* count, int* blocklens, MPI_Aint* indices, int* old_type, int* newtype, int* ierr){ MPI_Datatype tmp; - *ierr = MPI_Type_create_hindexed(*count, blocklens, indices, smpi_type_f2c(*old_type), &tmp); + *ierr = MPI_Type_create_hindexed(*count, blocklens, indices, Datatype::f2c(*old_type), &tmp); if(*ierr == MPI_SUCCESS) { - *newtype = smpi_type_add_f(tmp); + *newtype = tmp->add_f(); } } void mpi_type_create_hindexed_block_ (int* count, int* blocklength, MPI_Aint* indices, int* old_type, int* newtype, int* ierr) { MPI_Datatype tmp; - *ierr = MPI_Type_create_hindexed_block(*count, *blocklength, indices, smpi_type_f2c(*old_type), &tmp); + *ierr = MPI_Type_create_hindexed_block(*count, *blocklength, indices, Datatype::f2c(*old_type), &tmp); if(*ierr == MPI_SUCCESS) { - *newtype = smpi_type_add_f(tmp); + *newtype = tmp->add_f(); } } void mpi_type_indexed_ (int* count, int* blocklens, int* indices, int* old_type, int* newtype, int* ierr) { MPI_Datatype tmp; - *ierr = MPI_Type_indexed(*count, blocklens, indices, smpi_type_f2c(*old_type), &tmp); + *ierr = MPI_Type_indexed(*count, blocklens, indices, Datatype::f2c(*old_type), &tmp); if(*ierr == MPI_SUCCESS) { - *newtype = smpi_type_add_f(tmp); + *newtype = tmp->add_f(); } } void mpi_type_create_indexed_block_ (int* count, int* blocklength, int* indices, int* old_type, int*newtype, int* ierr){ MPI_Datatype tmp; - *ierr = MPI_Type_create_indexed_block(*count, *blocklength, indices, smpi_type_f2c(*old_type), &tmp); + *ierr = MPI_Type_create_indexed_block(*count, *blocklength, indices, Datatype::f2c(*old_type), &tmp); if(*ierr == MPI_SUCCESS) { - *newtype = smpi_type_add_f(tmp); + *newtype = tmp->add_f(); } } @@ -1303,11 +1164,11 @@ void mpi_type_struct_ (int* count, int* blocklens, MPI_Aint* indices, int* old_t int i=0; 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]); + types[i] = Datatype::f2c(old_types[i]); } *ierr = MPI_Type_struct(*count, blocklens, indices, types, &tmp); if(*ierr == MPI_SUCCESS) { - *newtype = smpi_type_add_f(tmp); + *newtype = tmp->add_f(); } xbt_free(types); } @@ -1317,102 +1178,102 @@ void mpi_type_create_struct_(int* count, int* blocklens, MPI_Aint* indices, int* int i=0; 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]); + types[i] = Datatype::f2c(old_types[i]); } *ierr = MPI_Type_create_struct(*count, blocklens, indices, types, &tmp); if(*ierr == MPI_SUCCESS) { - *newtype = smpi_type_add_f(tmp); + *newtype = tmp->add_f(); } xbt_free(types); } void mpi_ssend_ (void* buf, int* count, int* datatype, int* dest, int* tag, int* comm, int* ierr) { - *ierr = MPI_Ssend(buf, *count, smpi_type_f2c(*datatype), *dest, *tag, smpi_comm_f2c(*comm)); + *ierr = MPI_Ssend(buf, *count, Datatype::f2c(*datatype), *dest, *tag, Comm::f2c(*comm)); } void mpi_ssend_init_ (void* buf, int* count, int* datatype, int* dest, int* tag, int* comm, int* request, int* ierr) { MPI_Request tmp; - *ierr = MPI_Ssend_init(buf, *count, smpi_type_f2c(*datatype), *dest, *tag, smpi_comm_f2c(*comm), &tmp); + *ierr = MPI_Ssend_init(buf, *count, Datatype::f2c(*datatype), *dest, *tag, Comm::f2c(*comm), &tmp); if(*ierr == MPI_SUCCESS) { - *request = smpi_request_add_f(tmp); + *request = tmp->add_f(); } } void mpi_intercomm_create_ (int* local_comm, int *local_leader, int* peer_comm, int* remote_leader, int* tag, int* comm_out, int* ierr) { MPI_Comm tmp; - *ierr = MPI_Intercomm_create(smpi_comm_f2c(*local_comm), *local_leader,smpi_comm_f2c(*peer_comm), *remote_leader, + *ierr = MPI_Intercomm_create(Comm::f2c(*local_comm), *local_leader,Comm::f2c(*peer_comm), *remote_leader, *tag, &tmp); if(*ierr == MPI_SUCCESS) { - *comm_out = smpi_comm_add_f(tmp); + *comm_out = tmp->add_f(); } } void mpi_intercomm_merge_ (int* comm, int* high, int* comm_out, int* ierr) { MPI_Comm tmp; - *ierr = MPI_Intercomm_merge(smpi_comm_f2c(*comm), *high, &tmp); + *ierr = MPI_Intercomm_merge(Comm::f2c(*comm), *high, &tmp); if(*ierr == MPI_SUCCESS) { - *comm_out = smpi_comm_add_f(tmp); + *comm_out = tmp->add_f(); } } void mpi_bsend_ (void* buf, int* count, int* datatype, int *dest, int* tag, int* comm, int* ierr) { - *ierr = MPI_Bsend(buf, *count, smpi_type_f2c(*datatype), *dest, *tag, smpi_comm_f2c(*comm)); + *ierr = MPI_Bsend(buf, *count, Datatype::f2c(*datatype), *dest, *tag, Comm::f2c(*comm)); } void mpi_bsend_init_ (void* buf, int* count, int* datatype, int *dest, int* tag, int* comm, int* request, int* ierr) { MPI_Request tmp; - *ierr = MPI_Bsend_init(buf, *count, smpi_type_f2c(*datatype), *dest, *tag, smpi_comm_f2c(*comm), &tmp); + *ierr = MPI_Bsend_init(buf, *count, Datatype::f2c(*datatype), *dest, *tag, Comm::f2c(*comm), &tmp); if(*ierr == MPI_SUCCESS) { - *request = smpi_request_add_f(tmp); + *request = tmp->add_f(); } } void mpi_ibsend_ (void* buf, int* count, int* datatype, int *dest, int* tag, int* comm, int* request, int* ierr) { MPI_Request tmp; - *ierr = MPI_Ibsend(buf, *count, smpi_type_f2c(*datatype), *dest, *tag, smpi_comm_f2c(*comm), &tmp); + *ierr = MPI_Ibsend(buf, *count, Datatype::f2c(*datatype), *dest, *tag, Comm::f2c(*comm), &tmp); if(*ierr == MPI_SUCCESS) { - *request = smpi_request_add_f(tmp); + *request = tmp->add_f(); } } void mpi_comm_remote_group_ (int* comm, int* group, int* ierr) { MPI_Group tmp; - *ierr = MPI_Comm_remote_group(smpi_comm_f2c(*comm), &tmp); + *ierr = MPI_Comm_remote_group(Comm::f2c(*comm), &tmp); if(*ierr == MPI_SUCCESS) { - *group = smpi_group_c2f(tmp); + *group = tmp->c2f(); } } void mpi_comm_remote_size_ (int* comm, int* size, int* ierr) { - *ierr = MPI_Comm_remote_size(smpi_comm_f2c(*comm), size); + *ierr = MPI_Comm_remote_size(Comm::f2c(*comm), size); } void mpi_issend_ (void* buf, int* count, int* datatype, int *dest, int* tag, int* comm, int* request, int* ierr) { MPI_Request tmp; - *ierr = MPI_Issend(buf, *count, smpi_type_f2c(*datatype), *dest, *tag, smpi_comm_f2c(*comm), &tmp); + *ierr = MPI_Issend(buf, *count, Datatype::f2c(*datatype), *dest, *tag, Comm::f2c(*comm), &tmp); if(*ierr == MPI_SUCCESS) { - *request = smpi_request_add_f(tmp); + *request = tmp->add_f(); } } void mpi_probe_ (int* source, int* tag, int* comm, MPI_Status* status, int* ierr) { - *ierr = MPI_Probe(*source, *tag, smpi_comm_f2c(*comm), FORT_STATUS_IGNORE(status)); + *ierr = MPI_Probe(*source, *tag, Comm::f2c(*comm), FORT_STATUS_IGNORE(status)); } void mpi_attr_delete_ (int* comm, int* keyval, int* ierr) { - *ierr = MPI_Attr_delete(smpi_comm_f2c(*comm), *keyval); + *ierr = MPI_Attr_delete(Comm::f2c(*comm), *keyval); } void mpi_attr_put_ (int* comm, int* keyval, void* attr_value, int* ierr) { - *ierr = MPI_Attr_put(smpi_comm_f2c(*comm), *keyval, attr_value); + *ierr = MPI_Attr_put(Comm::f2c(*comm), *keyval, attr_value); } void mpi_rsend_init_ (void* buf, int* count, int* datatype, int *dest, int* tag, int* comm, int* request, int* ierr) { MPI_Request tmp; - *ierr = MPI_Rsend_init(buf, *count, smpi_type_f2c(*datatype), *dest, *tag, smpi_comm_f2c(*comm), &tmp); + *ierr = MPI_Rsend_init(buf, *count, Datatype::f2c(*datatype), *dest, *tag, Comm::f2c(*comm), &tmp); if(*ierr == MPI_SUCCESS) { - *request = smpi_request_add_f(tmp); + *request = tmp->add_f(); } } @@ -1429,11 +1290,11 @@ void mpi_test_cancelled_ (MPI_Status* status, int* flag, int* ierr) { } void mpi_pack_ (void* inbuf, int* incount, int* type, void* outbuf, int* outcount, int* position, int* comm, int* ierr) { - *ierr = MPI_Pack(inbuf, *incount, smpi_type_f2c(*type), outbuf, *outcount, position, smpi_comm_f2c(*comm)); + *ierr = MPI_Pack(inbuf, *incount, Datatype::f2c(*type), outbuf, *outcount, position, Comm::f2c(*comm)); } void mpi_get_elements_ (MPI_Status* status, int* datatype, int* elements, int* ierr) { - *ierr = MPI_Get_elements(status, smpi_type_f2c(*datatype), elements); + *ierr = MPI_Get_elements(status, Datatype::f2c(*datatype), elements); } void mpi_dims_create_ (int* nnodes, int* ndims, int* dims, int* ierr) { @@ -1441,19 +1302,19 @@ void mpi_dims_create_ (int* nnodes, int* ndims, int* dims, int* ierr) { } void mpi_iprobe_ (int* source, int* tag, int* comm, int* flag, MPI_Status* status, int* ierr) { - *ierr = MPI_Iprobe(*source, *tag, smpi_comm_f2c(*comm), flag, status); + *ierr = MPI_Iprobe(*source, *tag, Comm::f2c(*comm), flag, status); } void mpi_type_get_envelope_ ( int* datatype, int *num_integers, int *num_addresses, int *num_datatypes, int *combiner, int* ierr){ - *ierr = MPI_Type_get_envelope( smpi_type_f2c(*datatype), num_integers, + *ierr = MPI_Type_get_envelope( Datatype::f2c(*datatype), num_integers, num_addresses, num_datatypes, combiner); } void mpi_type_get_contents_ (int* datatype, int* max_integers, int* max_addresses, int* max_datatypes, 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, + *ierr = MPI_Type_get_contents(Datatype::f2c(*datatype), *max_integers, *max_addresses,*max_datatypes, array_of_integers, array_of_addresses, reinterpret_cast(array_of_datatypes)); } @@ -1463,17 +1324,17 @@ void mpi_type_create_darray_ (int* size, int* rank, int* ndims, int* array_of_gs MPI_Datatype tmp; *ierr = MPI_Type_create_darray(*size, *rank, *ndims, array_of_gsizes, array_of_distribs, array_of_dargs, array_of_psizes, - *order, smpi_type_f2c(*oldtype), &tmp) ; + *order, Datatype::f2c(*oldtype), &tmp) ; if(*ierr == MPI_SUCCESS) { - *newtype = smpi_type_add_f(tmp); + *newtype = tmp->add_f(); } } void mpi_type_create_resized_ (int* oldtype,MPI_Aint* lb, MPI_Aint* extent, int*newtype, int* ierr){ MPI_Datatype tmp; - *ierr = MPI_Type_create_resized(smpi_type_f2c(*oldtype),*lb, *extent, &tmp); + *ierr = MPI_Type_create_resized(Datatype::f2c(*oldtype),*lb, *extent, &tmp); if(*ierr == MPI_SUCCESS) { - *newtype = smpi_type_add_f(tmp); + *newtype = tmp->add_f(); } } @@ -1481,9 +1342,9 @@ void mpi_type_create_subarray_ (int* ndims,int *array_of_sizes, int *array_of_su int* order, int* oldtype, int*newtype, int* ierr){ MPI_Datatype tmp; *ierr = MPI_Type_create_subarray(*ndims,array_of_sizes, array_of_subsizes, array_of_starts, *order, - smpi_type_f2c(*oldtype), &tmp); + Datatype::f2c(*oldtype), &tmp); if(*ierr == MPI_SUCCESS) { - *newtype = smpi_type_add_f(tmp); + *newtype = tmp->add_f(); } } @@ -1491,53 +1352,53 @@ void mpi_type_match_size_ (int* typeclass,int* size,int* datatype, int* ierr){ MPI_Datatype tmp; *ierr = MPI_Type_match_size(*typeclass,*size,&tmp); if(*ierr == MPI_SUCCESS) { - *datatype = smpi_type_c2f(tmp); + *datatype = tmp->c2f(); } } 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, reinterpret_cast(sendtypes), recvbuf, recvcnts, rdispls, - reinterpret_cast(recvtypes), smpi_comm_f2c(*comm)); + reinterpret_cast(recvtypes), Comm::f2c(*comm)); } void mpi_exscan_ (void *sendbuf, void *recvbuf, int* count, int* datatype, int* op, int* comm, int* ierr){ - *ierr = MPI_Exscan(sendbuf, recvbuf, *count, smpi_type_f2c(*datatype), smpi_op_f2c(*op), smpi_comm_f2c(*comm)); + *ierr = MPI_Exscan(sendbuf, recvbuf, *count, Datatype::f2c(*datatype), Op::f2c(*op), Comm::f2c(*comm)); } void mpi_comm_set_name_ (int* comm, char* name, int* ierr, int size){ char* tname = xbt_new(char, size+1); strncpy(tname, name, size); tname[size]='\0'; - *ierr = MPI_Comm_set_name (smpi_comm_f2c(*comm), tname); + *ierr = MPI_Comm_set_name (Comm::f2c(*comm), tname); xbt_free(tname); } void mpi_comm_dup_with_info_ (int* comm, int* info, int* newcomm, int* ierr){ MPI_Comm tmp; - *ierr = MPI_Comm_dup_with_info(smpi_comm_f2c(*comm),smpi_info_f2c(*info),&tmp); + *ierr = MPI_Comm_dup_with_info(Comm::f2c(*comm),Info::f2c(*info),&tmp); if(*ierr == MPI_SUCCESS) { - *newcomm = smpi_comm_add_f(tmp); + *newcomm = tmp->add_f(); } } void mpi_comm_split_type_ (int* comm, int* split_type, int* key, int* info, int* newcomm, int* ierr){ MPI_Comm tmp; - *ierr = MPI_Comm_split_type(smpi_comm_f2c(*comm), *split_type, *key, smpi_info_f2c(*info), &tmp); + *ierr = MPI_Comm_split_type(Comm::f2c(*comm), *split_type, *key, Info::f2c(*info), &tmp); if(*ierr == MPI_SUCCESS) { - *newcomm = smpi_comm_add_f(tmp); + *newcomm = tmp->add_f(); } } void mpi_comm_set_info_ (int* comm, int* info, int* ierr){ - *ierr = MPI_Comm_set_info (smpi_comm_f2c(*comm), smpi_info_f2c(*info)); + *ierr = MPI_Comm_set_info (Comm::f2c(*comm), Info::f2c(*info)); } void mpi_comm_get_info_ (int* comm, int* info, int* ierr){ MPI_Info tmp; - *ierr = MPI_Comm_get_info (smpi_comm_f2c(*comm), &tmp); + *ierr = MPI_Comm_get_info (Comm::f2c(*comm), &tmp); if(*ierr==MPI_SUCCESS){ - *info = smpi_info_c2f(tmp); + *info = tmp->c2f(); } } @@ -1558,14 +1419,14 @@ void mpi_add_error_string_ ( int* errorcode, char *string, int* ierr){ } void mpi_comm_call_errhandler_ (int* comm,int* errorcode, int* ierr){ - *ierr = MPI_Comm_call_errhandler(smpi_comm_f2c(*comm), *errorcode); + *ierr = MPI_Comm_call_errhandler(Comm::f2c(*comm), *errorcode); } void mpi_info_dup_ (int* info, int* newinfo, int* ierr){ MPI_Info tmp; - *ierr = MPI_Info_dup(smpi_info_f2c(*info), &tmp); + *ierr = MPI_Info_dup(Info::f2c(*info), &tmp); if(*ierr==MPI_SUCCESS){ - *newinfo= smpi_info_add_f(tmp); + *newinfo= tmp->add_f(); } } @@ -1579,7 +1440,7 @@ void mpi_info_get_valuelen_ ( int* info, char *key, int *valuelen, int *flag, in 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); + *ierr = MPI_Info_get_valuelen( Info::f2c(*info), tkey, valuelen, flag); xbt_free(tkey); } @@ -1593,16 +1454,16 @@ void mpi_info_delete_ (int* info, char *key, int* ierr, unsigned int keylen){ char* tkey = xbt_new(char, keylen+1); strncpy(tkey, key, keylen); tkey[keylen]='\0'; - *ierr = MPI_Info_delete(smpi_info_f2c(*info), tkey); + *ierr = MPI_Info_delete(Info::f2c(*info), tkey); xbt_free(tkey); } void mpi_info_get_nkeys_ ( int* info, int *nkeys, int* ierr){ - *ierr = MPI_Info_get_nkeys( smpi_info_f2c(*info), nkeys); + *ierr = MPI_Info_get_nkeys( Info::f2c(*info), nkeys); } 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); + *ierr = MPI_Info_get_nthkey( 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_add_f(tmp); + *request = tmp->add_f(); } } void mpi_grequest_complete_ ( int* request, int* ierr){ - *ierr = MPI_Grequest_complete( smpi_request_f2c(*request)); + *ierr = MPI_Grequest_complete( Request::f2c(*request)); } void mpi_status_set_cancelled_ (MPI_Status* status,int* flag, int* ierr){ @@ -1638,14 +1499,14 @@ void mpi_status_set_cancelled_ (MPI_Status* status,int* flag, int* ierr){ } void mpi_status_set_elements_ ( MPI_Status* status, int* datatype, int* count, int* ierr){ - *ierr = MPI_Status_set_elements( status, smpi_type_f2c(*datatype), *count); + *ierr = MPI_Status_set_elements( status, Datatype::f2c(*datatype), *count); } 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, *reinterpret_cast(info), *root, smpi_comm_f2c(*comm), &tmp); + *ierr = MPI_Comm_connect( port_name, *reinterpret_cast(info), *root, Comm::f2c(*comm), &tmp); if(*ierr == MPI_SUCCESS) { - *newcomm = smpi_comm_add_f(tmp); + *newcomm = tmp->add_f(); } } @@ -1665,7 +1526,7 @@ void mpi_comm_join_ ( int* fd, int* intercomm, int* ierr){ MPI_Comm tmp; *ierr = MPI_Comm_join( *fd, &tmp); if(*ierr == MPI_SUCCESS) { - *intercomm = smpi_comm_add_f(tmp); + *intercomm = tmp->add_f(); } } @@ -1679,19 +1540,19 @@ 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, *reinterpret_cast(info), *root, smpi_comm_f2c(*comm), &tmp); + *ierr = MPI_Comm_accept( port_name, *reinterpret_cast(info), *root, Comm::f2c(*comm), &tmp); if(*ierr == MPI_SUCCESS) { - *newcomm = smpi_comm_add_f(tmp); + *newcomm = tmp->add_f(); } } 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, nullptr, *maxprocs, *reinterpret_cast(info), *root, smpi_comm_f2c(*comm), &tmp, + *ierr = MPI_Comm_spawn( command, nullptr, *maxprocs, *reinterpret_cast(info), *root, Comm::f2c(*comm), &tmp, array_of_errcodes); if(*ierr == MPI_SUCCESS) { - *intercomm = smpi_comm_add_f(tmp); + *intercomm = tmp->add_f(); } } @@ -1700,9 +1561,9 @@ 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, - reinterpret_cast(array_of_info), *root, smpi_comm_f2c(*comm), &tmp, array_of_errcodes); + reinterpret_cast(array_of_info), *root, Comm::f2c(*comm), &tmp, array_of_errcodes); if(*ierr == MPI_SUCCESS) { - *intercomm = smpi_comm_add_f(tmp); + *intercomm = tmp->add_f(); } } @@ -1710,7 +1571,7 @@ void mpi_comm_get_parent_ ( int* parent, int* ierr){ MPI_Comm tmp; *ierr = MPI_Comm_get_parent( &tmp); if(*ierr == MPI_SUCCESS) { - *parent = smpi_comm_c2f(tmp); + *parent = tmp->c2f(); } } @@ -1719,23 +1580,23 @@ void mpi_file_close_ ( int* file, int* ierr){ } void mpi_file_delete_ ( char* filename, int* info, int* ierr){ - *ierr= MPI_File_delete(filename, smpi_info_f2c(*info)); + *ierr= MPI_File_delete(filename, Info::f2c(*info)); } void mpi_file_open_ ( int* comm, char* filename, int* amode, int* info, int* fh, int* ierr){ - *ierr= MPI_File_open(smpi_comm_f2c(*comm), filename, *amode, smpi_info_f2c(*info), reinterpret_cast(*fh)); + *ierr= MPI_File_open(Comm::f2c(*comm), filename, *amode, Info::f2c(*info), reinterpret_cast(*fh)); } void mpi_file_set_view_ ( int* fh, long long int* offset, int* etype, int* filetype, char* datarep, int* info, int* ierr){ - *ierr= MPI_File_set_view(reinterpret_cast(*fh) , reinterpret_cast(*offset), smpi_type_f2c(*etype), smpi_type_f2c(*filetype), datarep, smpi_info_f2c(*info)); + *ierr= MPI_File_set_view(reinterpret_cast(*fh) , reinterpret_cast(*offset), Datatype::f2c(*etype), Datatype::f2c(*filetype), datarep, Info::f2c(*info)); } void mpi_file_read_ ( int* fh, void* buf, int* count, int* datatype, MPI_Status* status, int* ierr){ - *ierr= MPI_File_read(reinterpret_cast(*fh), buf, *count, smpi_type_f2c(*datatype), status); + *ierr= MPI_File_read(reinterpret_cast(*fh), buf, *count, Datatype::f2c(*datatype), status); } void mpi_file_write_ ( int* fh, void* buf, int* count, int* datatype, MPI_Status* status, int* ierr){ - *ierr= MPI_File_write(reinterpret_cast(*fh), buf, *count, smpi_type_f2c(*datatype), status); + *ierr= MPI_File_write(reinterpret_cast(*fh), buf, *count, Datatype::f2c(*datatype), status); } } // extern "C" diff --git a/src/smpi/smpi_global.cpp b/src/smpi/smpi_global.cpp index d38a752b44..b70008be57 100644 --- a/src/smpi/smpi_global.cpp +++ b/src/smpi/smpi_global.cpp @@ -614,17 +614,17 @@ void smpi_global_destroy() smpi_bench_destroy(); if (MPI_COMM_WORLD != MPI_COMM_UNINITIALIZED){ - while (MPI_COMM_WORLD->group()->unuse() > 0); + delete MPI_COMM_WORLD->group(); MSG_barrier_destroy(process_data[0]->finalization_barrier); }else{ smpi_deployment_cleanup_instances(); } for (int i = 0; i < count; i++) { if(process_data[i]->comm_self!=MPI_COMM_NULL){ - process_data[i]->comm_self->destroy(); + Comm::destroy(process_data[i]->comm_self); } if(process_data[i]->comm_intra!=MPI_COMM_NULL){ - process_data[i]->comm_intra->destroy(); + Comm::destroy(process_data[i]->comm_intra); } xbt_os_timer_free(process_data[i]->timer); xbt_mutex_destroy(process_data[i]->mailboxes_mutex); diff --git a/src/smpi/smpi_group.cpp b/src/smpi/smpi_group.cpp index f8f2f86a96..c5bcb02620 100644 --- a/src/smpi/smpi_group.cpp +++ b/src/smpi/smpi_group.cpp @@ -64,13 +64,6 @@ Group::~Group() xbt_dict_free(&index_to_rank_map_); } -void Group::destroy() -{ - if(this != MPI_COMM_WORLD->group() - && this != MPI_GROUP_EMPTY) - this->unuse(); -} - void Group::set_mapping(int index, int rank) { int * val_rank; @@ -112,20 +105,17 @@ int Group::rank(int index) return *ptr_rank; } -int Group::use() +void Group::ref() { refcount_++; - return refcount_; } -int Group::unuse() +void Group::unref(Group* group) { - refcount_--; - if (refcount_ <= 0) { - delete this; - return 0; + group->refcount_--; + if (group->refcount_ <= 0) { + delete group; } - return refcount_; } int Group::size() @@ -172,7 +162,7 @@ int Group::incl(int n, int* ranks, MPI_Group* newgroup) if(this!= MPI_COMM_WORLD->group() && this != MPI_COMM_SELF->group() && this != MPI_GROUP_EMPTY) - this->use(); + this->ref(); } else { *newgroup = new Group(n); for (i = 0; i < n; i++) { @@ -389,5 +379,16 @@ int Group::range_excl(int n, int ranges[][3], MPI_Group * newgroup){ return MPI_SUCCESS; } +MPI_Group Group::f2c(int id) { + if(id == -2) { + return MPI_GROUP_EMPTY; + } else if(f2c_lookup_ != nullptr && id >= 0) { + char key[KEY_SIZE]; + return static_cast(xbt_dict_get_or_null(f2c_lookup_, get_key(key, id))); + } else { + return static_cast(MPI_GROUP_NULL); + } +} + } } diff --git a/src/smpi/smpi_group.hpp b/src/smpi/smpi_group.hpp index f7c2572eee..6e1a45d97a 100644 --- a/src/smpi/smpi_group.hpp +++ b/src/smpi/smpi_group.hpp @@ -12,25 +12,23 @@ namespace simgrid{ namespace smpi{ -class Group { +class Group : public F2C{ private: int size_; int *rank_to_index_map_; xbt_dict_t index_to_rank_map_; int refcount_; public: - Group(); Group(int size); Group(Group* origin); ~Group(); - void destroy(); void set_mapping(int index, int rank); int index(int rank); int rank(int index); - int use(); - int unuse(); + void ref(); + static void unref(MPI_Group group); int size(); int compare(MPI_Group group2); int incl(int n, int* ranks, MPI_Group* newgroup); @@ -40,6 +38,9 @@ class Group { int difference(MPI_Group group2, MPI_Group* newgroup); int range_incl(int n, int ranges[][3], MPI_Group * newgroup); int range_excl(int n, int ranges[][3], MPI_Group * newgroup); + + static Group* f2c(int id); + }; } } diff --git a/src/smpi/smpi_info.cpp b/src/smpi/smpi_info.cpp index 0171e11188..8b9fb64ba8 100644 --- a/src/smpi/smpi_info.cpp +++ b/src/smpi/smpi_info.cpp @@ -11,8 +11,6 @@ namespace simgrid{ namespace smpi{ -MPI_Info Info::null_id_=MPI_INFO_NULL; - Info::Info():refcount_(1){ dict_= xbt_dict_new_homogeneous(xbt_free_f); } @@ -31,8 +29,8 @@ Info::~Info(){ xbt_dict_free(&dict_); } -void Info::ref(Info* info){ - info->refcount_++; +void Info::ref(){ + refcount_++; } void Info::unref(Info* info){ @@ -101,6 +99,10 @@ int Info::get_valuelen(char *key, int *valuelen, int *flag){ return MPI_SUCCESS; } +Info* Info::f2c(int id){ + return static_cast(F2C::f2c(id)); +} + } } diff --git a/src/smpi/smpi_info.hpp b/src/smpi/smpi_info.hpp index 8e1f52555c..c89558b7be 100644 --- a/src/smpi/smpi_info.hpp +++ b/src/smpi/smpi_info.hpp @@ -19,12 +19,10 @@ class Info : public F2C{ xbt_dict_t dict_; int refcount_; public: - static MPI_Info null_id_; - Info(); Info(Info* orig); ~Info(); - static void ref(MPI_Info info); + void ref(); static void unref(MPI_Info info); void set(char *key, char *value); int get(char *key,int valuelen, char *value, int *flag); @@ -32,6 +30,7 @@ class Info : public F2C{ int get_nkeys(int *nkeys); int get_nthkey(int n, char *key); int get_valuelen(char *key, int *valuelen, int *flag); + static Info* f2c(int id); }; } diff --git a/src/smpi/smpi_op.cpp b/src/smpi/smpi_op.cpp index 3cd260ea7c..8251f94263 100644 --- a/src/smpi/smpi_op.cpp +++ b/src/smpi/smpi_op.cpp @@ -241,7 +241,7 @@ void Op::apply(void *invec, void *inoutvec, int *len, MPI_Datatype datatype) if(! is_fortran_op_) this->func_(invec, inoutvec, len, &datatype); else{ - int tmp = smpi_type_c2f(datatype); + int tmp = datatype->c2f(); /* Unfortunately, the C and Fortran version of the MPI standard do not agree on the type here, thus the reinterpret_cast. */ this->func_(invec, inoutvec, len, reinterpret_cast(&tmp) ); @@ -249,5 +249,9 @@ void Op::apply(void *invec, void *inoutvec, int *len, MPI_Datatype datatype) } } +Op* Op::f2c(int id){ + return static_cast(F2C::f2c(id)); +} + } } diff --git a/src/smpi/smpi_op.hpp b/src/smpi/smpi_op.hpp index 1e3c127695..0bb8ce8a51 100644 --- a/src/smpi/smpi_op.hpp +++ b/src/smpi/smpi_op.hpp @@ -14,17 +14,19 @@ namespace simgrid{ namespace smpi{ -class Op { +class Op : public F2C{ private: MPI_User_function *func_; bool is_commutative_; bool is_fortran_op_; public: + Op(MPI_User_function * function, bool commutative); bool is_commutative(); bool is_fortran_op(); void set_fortran_op(); void apply(void *invec, void *inoutvec, int *len, MPI_Datatype datatype); + static Op* f2c(int id); }; } diff --git a/src/smpi/smpi_pmpi.cpp b/src/smpi/smpi_pmpi.cpp index 73ed8e5119..7dc9eaee3d 100644 --- a/src/smpi/smpi_pmpi.cpp +++ b/src/smpi/smpi_pmpi.cpp @@ -4,7 +4,6 @@ * under the terms of the license (GNU LGPL) which comes with this package. */ #include -#include #include "private.h" @@ -276,7 +275,8 @@ int PMPI_Group_free(MPI_Group * group) if (group == nullptr) { return MPI_ERR_ARG; } else { - (*group)->destroy(); + if(*group != MPI_COMM_WORLD->group() && *group != MPI_GROUP_EMPTY) + Group::unref(*group); *group = MPI_GROUP_NULL; return MPI_SUCCESS; } @@ -392,7 +392,7 @@ int PMPI_Group_excl(MPI_Group group, int n, int *ranks, MPI_Group * newgroup) *newgroup = group; if (group != MPI_COMM_WORLD->group() && group != MPI_COMM_SELF->group() && group != MPI_GROUP_EMPTY) - group->use(); + group->ref(); return MPI_SUCCESS; } else if (n == group->size()) { *newgroup = MPI_GROUP_EMPTY; @@ -430,7 +430,7 @@ int PMPI_Group_range_excl(MPI_Group group, int n, int ranges[][3], MPI_Group * n *newgroup = group; if (group != MPI_COMM_WORLD->group() && group != MPI_COMM_SELF->group() && group != MPI_GROUP_EMPTY) - group->use(); + group->ref(); return MPI_SUCCESS; } else { return group->range_excl(n,ranges,newgroup); @@ -483,7 +483,7 @@ int PMPI_Comm_group(MPI_Comm comm, MPI_Group * group) } else { *group = comm->group(); if (*group != MPI_COMM_WORLD->group() && *group != MPI_GROUP_NULL && *group != MPI_GROUP_EMPTY) - (*group)->use(); + (*group)->ref(); return MPI_SUCCESS; } } @@ -530,7 +530,7 @@ int PMPI_Comm_create(MPI_Comm comm, MPI_Group group, MPI_Comm * newcomm) *newcomm= MPI_COMM_NULL; return MPI_SUCCESS; }else{ - group->use(); + group->ref(); *newcomm = new Comm(group, nullptr); return MPI_SUCCESS; } @@ -543,7 +543,7 @@ int PMPI_Comm_free(MPI_Comm * comm) } else if (*comm == MPI_COMM_NULL) { return MPI_ERR_COMM; } else { - (*comm)->destroy(); + Comm::destroy(*comm); *comm = MPI_COMM_NULL; return MPI_SUCCESS; } @@ -557,7 +557,7 @@ int PMPI_Comm_disconnect(MPI_Comm * comm) } else if (*comm == MPI_COMM_NULL) { return MPI_ERR_COMM; } else { - (*comm)->destroy(); + Comm::destroy(*comm); *comm = MPI_COMM_NULL; return MPI_SUCCESS; } @@ -2452,7 +2452,7 @@ int PMPI_Win_free( MPI_Win* win){ if (win == nullptr || *win == MPI_WIN_NULL) { retval = MPI_ERR_WIN; }else{ - delete(*win); + delete *win; retval=MPI_SUCCESS; } smpi_bench_begin(); @@ -2488,7 +2488,7 @@ int PMPI_Win_get_group(MPI_Win win, MPI_Group * group){ return MPI_ERR_WIN; }else { win->get_group(group); - (*group)->use(); + (*group)->ref(); return MPI_SUCCESS; } } @@ -2719,59 +2719,59 @@ int PMPI_Type_get_name(MPI_Datatype datatype, char * name, int* len) } MPI_Datatype PMPI_Type_f2c(MPI_Fint datatype){ - return smpi_type_f2c(datatype); + return static_cast(F2C::f2c(datatype)); } MPI_Fint PMPI_Type_c2f(MPI_Datatype datatype){ - return smpi_type_c2f( datatype); + return datatype->c2f(); } MPI_Group PMPI_Group_f2c(MPI_Fint group){ - return smpi_group_f2c( group); + return Group::f2c(group); } MPI_Fint PMPI_Group_c2f(MPI_Group group){ - return smpi_group_c2f(group); + return group->c2f(); } MPI_Request PMPI_Request_f2c(MPI_Fint request){ - return smpi_request_f2c(request); + return static_cast(Request::f2c(request)); } MPI_Fint PMPI_Request_c2f(MPI_Request request) { - return smpi_request_c2f(request); + return request->c2f(); } MPI_Win PMPI_Win_f2c(MPI_Fint win){ - return smpi_win_f2c(win); + return static_cast(Win::f2c(win)); } MPI_Fint PMPI_Win_c2f(MPI_Win win){ - return smpi_win_c2f(win); + return win->c2f(); } MPI_Op PMPI_Op_f2c(MPI_Fint op){ - return smpi_op_f2c(op); + return static_cast(Op::f2c(op)); } MPI_Fint PMPI_Op_c2f(MPI_Op op){ - return smpi_op_c2f(op); + return op->c2f(); } MPI_Comm PMPI_Comm_f2c(MPI_Fint comm){ - return smpi_comm_f2c(comm); + return static_cast(Comm::f2c(comm)); } MPI_Fint PMPI_Comm_c2f(MPI_Comm comm){ - return smpi_comm_c2f(comm); + return comm->c2f(); } MPI_Info PMPI_Info_f2c(MPI_Fint info){ - return smpi_info_f2c(info); + return static_cast(Info::f2c(info)); } MPI_Fint PMPI_Info_c2f(MPI_Info info){ - return smpi_info_c2f(info); + return info->c2f(); } int PMPI_Keyval_create(MPI_Copy_function* copy_fn, MPI_Delete_function* delete_fn, int* keyval, void* extra_state) { diff --git a/src/smpi/smpi_request.cpp b/src/smpi/smpi_request.cpp index 50c6f3816a..978e3355c8 100644 --- a/src/smpi/smpi_request.cpp +++ b/src/smpi/smpi_request.cpp @@ -109,6 +109,7 @@ static double smpi_or(size_t size) namespace simgrid{ namespace smpi{ + Request::Request(){} Request::Request(void *buf, int count, MPI_Datatype datatype, int src, int dst, int tag, MPI_Comm comm, unsigned flags) : buf_(buf), old_type_(datatype), src_(src), dst_(dst), tag_(tag), comm_(comm), flags_(flags) { @@ -126,7 +127,7 @@ Request::Request(void *buf, int count, MPI_Datatype datatype, int src, int dst, old_buf_ = old_buf; size_ = datatype->size() * count; datatype->use(); - comm_->use(); + comm_->ref(); action_ = nullptr; detached_ = 0; detached_sender_ = nullptr; @@ -189,7 +190,7 @@ void Request::unuse(MPI_Request* request) if((*request)->refcount_==0){ (*request)->old_type_->unuse(); - (*request)->comm_->unuse(); + Comm::unref((*request)->comm_); (*request)->print_request("Destroying"); delete *request; *request = MPI_REQUEST_NULL; @@ -1000,6 +1001,30 @@ int Request::waitsome(int incount, MPI_Request requests[], int *indices, MPI_Sta return count; } +MPI_Request Request::f2c(int id) { + char key[KEY_SIZE]; + if(id==MPI_FORTRAN_REQUEST_NULL) + return static_cast(MPI_REQUEST_NULL); + return static_cast(xbt_dict_get(Request::f2c_lookup_, get_key_id(key, id))); +} + +int Request::add_f() { + if(Request::f2c_lookup_==nullptr){ + Request::f2c_lookup_=xbt_dict_new_homogeneous(nullptr); + } + char key[KEY_SIZE]; + xbt_dict_set(Request::f2c_lookup_, get_key_id(key, Request::f2c_id_), this, nullptr); + Request::f2c_id_++; + return Request::f2c_id_-1; +} + +void Request::free_f(int id) { + char key[KEY_SIZE]; + if(id!=MPI_FORTRAN_REQUEST_NULL) + xbt_dict_remove(Request::f2c_lookup_, get_key_id(key, id)); +} + + } } diff --git a/src/smpi/smpi_request.hpp b/src/smpi/smpi_request.hpp index 561dbf509e..e4e2e4b28f 100644 --- a/src/smpi/smpi_request.hpp +++ b/src/smpi/smpi_request.hpp @@ -12,7 +12,7 @@ namespace simgrid{ namespace smpi{ -class Request { +class Request : public F2C{ private : void *buf_; /* in the case of non-contiguous memory the user address should be keep @@ -90,8 +90,14 @@ class Request { static int match_send(void* a, void* b,smx_activity_t ignored); static int match_recv(void* a, void* b,smx_activity_t ignored); + + int add_f(); + static void free_f(int id); + static Request* f2c(int); + }; + } } diff --git a/src/smpi/smpi_win.cpp b/src/smpi/smpi_win.cpp index 1e1b4134ba..16a465a60d 100644 --- a/src/smpi/smpi_win.cpp +++ b/src/smpi/smpi_win.cpp @@ -17,7 +17,7 @@ Win::Win(void *base, MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm) int rank = comm->rank(); XBT_DEBUG("Creating window"); if(info!=MPI_INFO_NULL) - Info::ref(info); + info->ref(); name_ = nullptr; opened_ = 0; group_ = MPI_GROUP_NULL; @@ -279,7 +279,7 @@ int Win::start(MPI_Group group, int assert){ xbt_free(reqs); opened_++; //we're open for business ! group_=group; - group->use(); + group->ref(); return MPI_SUCCESS; } @@ -308,7 +308,7 @@ int Win::post(MPI_Group group, int assert){ xbt_free(reqs); opened_++; //we're open for business ! group_=group; - group->use(); + group->ref(); return MPI_SUCCESS; } @@ -359,7 +359,7 @@ int Win::complete(){ } xbt_mutex_release(mut_); - group_->unuse(); + Group::unref(group_); opened_--; //we're closed for business ! return MPI_SUCCESS; } @@ -405,10 +405,14 @@ int Win::wait(){ } xbt_mutex_release(mut_); - group_->unuse(); + Group::unref(group_); opened_--; //we're opened for business ! return MPI_SUCCESS; } +Win* Win::f2c(int id){ + return static_cast(F2C::f2c(id)); +} + } } diff --git a/src/smpi/smpi_win.hpp b/src/smpi/smpi_win.hpp index 85ed320355..c821210253 100644 --- a/src/smpi/smpi_win.hpp +++ b/src/smpi/smpi_win.hpp @@ -13,7 +13,7 @@ namespace simgrid{ namespace smpi{ -class Win { +class Win : public F2C { private : void* base_; MPI_Aint size_; @@ -47,6 +47,7 @@ public: MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype); int 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); + static Win* f2c(int id); }; diff --git a/tools/cmake/DefinePackages.cmake b/tools/cmake/DefinePackages.cmake index 484491f53c..ad723417a0 100644 --- a/tools/cmake/DefinePackages.cmake +++ b/tools/cmake/DefinePackages.cmake @@ -215,11 +215,15 @@ set(SMPI_SRC src/smpi/smpi_deployment.cpp src/smpi/smpi_dvfs.cpp src/smpi/smpi_global.cpp + src/smpi/smpi_f2c.cpp + src/smpi/smpi_f2c.hpp src/smpi/smpi_group.cpp src/smpi/smpi_group.hpp src/smpi/smpi_mpi.cpp src/smpi/smpi_datatype.cpp src/smpi/smpi_datatype.hpp + src/smpi/smpi_info.cpp + src/smpi/smpi_info.hpp src/smpi/smpi_datatype_derived.cpp src/smpi/smpi_datatype_derived.hpp src/smpi/smpi_op.cpp