X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/b87fc0829538ec066fd077e6c30ee6270b8abd78..601c8897d16bf062ab099ade6df403f4f6cba545:/src/smpi/include/smpi_keyvals.hpp diff --git a/src/smpi/include/smpi_keyvals.hpp b/src/smpi/include/smpi_keyvals.hpp index 986540f4e9..6835f52ef2 100644 --- a/src/smpi/include/smpi_keyvals.hpp +++ b/src/smpi/include/smpi_keyvals.hpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2010-2017. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2010-2021. 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. */ @@ -7,29 +7,35 @@ #define SMPI_KEYVALS_HPP_INCLUDED #include "smpi/smpi.h" -#include "xbt/ex.hpp" #include -typedef struct smpi_delete_fn{ +struct smpi_delete_fn { MPI_Comm_delete_attr_function *comm_delete_fn; MPI_Type_delete_attr_function *type_delete_fn; MPI_Win_delete_attr_function *win_delete_fn; -} smpi_delete_fn; + MPI_Comm_delete_attr_function_fort *comm_delete_fn_fort; + MPI_Type_delete_attr_function_fort *type_delete_fn_fort; + MPI_Win_delete_attr_function_fort *win_delete_fn_fort; +}; -typedef struct smpi_copy_fn{ +struct smpi_copy_fn { MPI_Comm_copy_attr_function *comm_copy_fn; MPI_Type_copy_attr_function *type_copy_fn; MPI_Win_copy_attr_function *win_copy_fn; -} smpi_copy_fn; + MPI_Comm_copy_attr_function_fort *comm_copy_fn_fort; + MPI_Type_copy_attr_function_fort *type_copy_fn_fort; + MPI_Win_copy_attr_function_fort *win_copy_fn_fort; +}; -typedef struct s_smpi_key_elem { +struct s_smpi_key_elem_t { smpi_copy_fn copy_fn; smpi_delete_fn delete_fn; + void* extra_state; int refcount; -} s_smpi_mpi_key_elem_t; +}; -typedef struct s_smpi_key_elem *smpi_key_elem; +using smpi_key_elem = s_smpi_key_elem_t*; namespace simgrid{ namespace smpi{ @@ -38,26 +44,32 @@ class Keyval{ private: std::unordered_map attributes_; protected: - std::unordered_map* attributes(); + std::unordered_map& attributes() { return attributes_; } + public: // Each subclass should have two members, as we want to separate the ones for Win, Comm, and Datatypes : // static std::unordered_map keyvals_; // static int keyval_id_; - template static int keyval_create(smpi_copy_fn copy_fn, smpi_delete_fn delete_fn, int* keyval, void* extra_statee); + template + static int keyval_create(const smpi_copy_fn& copy_fn, const smpi_delete_fn& delete_fn, int* keyval, + void* extra_state); template static int keyval_free(int* keyval); template int attr_delete(int keyval); template int attr_get(int keyval, void* attr_value, int* flag); template int attr_put(int keyval, void* attr_value); - template static int call_deleter(T* obj, smpi_key_elem elem, int keyval, void * value, int* flag); + template + static int call_deleter(T* obj, const s_smpi_key_elem_t* elem, int keyval, void* value, int* flag); template void cleanup_attr(); }; -template int Keyval::keyval_create(smpi_copy_fn copy_fn, smpi_delete_fn delete_fn, int* keyval, void* extra_state){ - - smpi_key_elem value = (smpi_key_elem) xbt_new0(s_smpi_mpi_key_elem_t,1); +template +int Keyval::keyval_create(const smpi_copy_fn& copy_fn, const smpi_delete_fn& delete_fn, int* keyval, void* extra_state) +{ + auto* value = new s_smpi_key_elem_t; value->copy_fn=copy_fn; value->delete_fn=delete_fn; + value->extra_state=extra_state; value->refcount=1; *keyval = T::keyval_id_; @@ -70,15 +82,16 @@ template int Keyval::keyval_free(int* keyval){ /* See MPI-1, 5.7.1. Freeing the keyval does not remove it if it * is in use in an attribute */ smpi_key_elem elem = T::keyvals_.at(*keyval); - if(elem==0){ + if (elem == nullptr) { return MPI_ERR_ARG; } if(elem->refcount==1){ T::keyvals_.erase(*keyval); - xbt_free(elem); + delete elem; }else{ elem->refcount--; } + *keyval = MPI_KEYVAL_INVALID; return MPI_SUCCESS; } @@ -94,24 +107,20 @@ template int Keyval::attr_delete(int keyval){ if(ret!=MPI_SUCCESS) return ret; } - if(attributes()->empty()) + if (attributes().empty()) return MPI_ERR_ARG; - attributes()->erase(keyval); + attributes().erase(keyval); return MPI_SUCCESS; } template int Keyval::attr_get(int keyval, void* attr_value, int* flag){ - smpi_key_elem elem = T::keyvals_.at(keyval); + const s_smpi_key_elem_t* elem = T::keyvals_.at(keyval); if(elem==nullptr) return MPI_ERR_ARG; - if(attributes()->empty()){ - *flag=0; - return MPI_SUCCESS; - } - const auto& attribs = attributes(); - auto attr = attribs->find(keyval); - if (attr != attribs->end()) { + + auto attr = attributes().find(keyval); + if (attr != attributes().end()) { *static_cast(attr_value) = attr->second; *flag=1; } else { @@ -125,32 +134,30 @@ template int Keyval::attr_put(int keyval, void* attr_value){ if(elem==nullptr) return MPI_ERR_ARG; elem->refcount++; - void * value = nullptr; int flag=0; - this->attr_get(keyval, &value, &flag); - if(flag!=0){ - int ret = call_deleter((T*)this, elem, keyval,value,&flag); + auto p = attributes().insert({keyval, attr_value}); + if (not p.second) { + int ret = call_deleter((T*)this, elem, keyval,p.first->second,&flag); + // overwrite previous value + p.first->second = attr_value; if(ret!=MPI_SUCCESS) - return ret; + return ret; } - attributes()->insert({keyval, attr_value}); return MPI_SUCCESS; } template void Keyval::cleanup_attr(){ - if (not attributes()->empty()) { - int flag=0; - for(auto it : attributes_){ - auto elm = T::keyvals_.find(it.first); - if (elm != T::keyvals_.end()) { - smpi_key_elem elem = elm->second; - if(elem != nullptr){ - call_deleter((T*)this, elem, it.first,it.second,&flag); - } - } else { - //already deleted, not a problem; - flag=0; + int flag = 0; + for (auto const& it : attributes()) { + auto elm = T::keyvals_.find(it.first); + if (elm != T::keyvals_.end()) { + smpi_key_elem elem = elm->second; + if (elem != nullptr) { + call_deleter((T*)this, elem, it.first, it.second, &flag); } + } else { + // already deleted, not a problem + flag = 0; } } }