/* smpi_datatype.cpp -- MPI primitives to handle datatypes */
-/* Copyright (c) 2009-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2009-2019. 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 "simgrid/modelchecker.h"
#include "private.hpp"
+#include "simgrid/modelchecker.h"
#include "smpi_datatype_derived.hpp"
#include "smpi_op.hpp"
-#include "smpi_process.hpp"
+#include "src/instr/instr_private.hpp"
+#include "src/smpi/include/smpi_actor.hpp"
+
+#include <string>
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_datatype, smpi, "Logging specific to SMPI (datatype)");
-#define CREATE_MPI_DATATYPE(name, type) \
- static simgrid::smpi::Datatype mpi_##name ( \
- (char*) # name, \
- sizeof(type), /* size */ \
- 0, /* lb */ \
- sizeof(type), /* ub = lb + size */ \
- DT_FLAG_BASIC /* flags */ \
- ); \
-const MPI_Datatype name = &mpi_##name;
-
-#define CREATE_MPI_DATATYPE_NULL(name) \
- static simgrid::smpi::Datatype mpi_##name ( \
- (char*) # name, \
- 0, /* size */ \
- 0, /* lb */ \
- 0, /* ub = lb + size */ \
- DT_FLAG_BASIC /* flags */ \
- ); \
-const MPI_Datatype name = &mpi_##name;
+static std::unordered_map<std::string, simgrid::smpi::Datatype*> id2type_lookup;
+
+#define CREATE_MPI_DATATYPE(name, id, type) \
+ static simgrid::smpi::Datatype mpi_##name((char*)#name, id, sizeof(type), /* size */ \
+ 0, /* lb */ \
+ sizeof(type), /* ub = lb + size */ \
+ DT_FLAG_BASIC /* flags */ \
+ ); \
+ const MPI_Datatype name = &mpi_##name;
+
+#define CREATE_MPI_DATATYPE_NULL(name, id) \
+ static simgrid::smpi::Datatype mpi_##name((char*)#name, id, 0, /* size */ \
+ 0, /* lb */ \
+ 0, /* ub = lb + size */ \
+ DT_FLAG_BASIC /* flags */ \
+ ); \
+ const MPI_Datatype name = &mpi_##name;
// Predefined data types
-CREATE_MPI_DATATYPE(MPI_CHAR, char);
-CREATE_MPI_DATATYPE(MPI_SHORT, short);
-CREATE_MPI_DATATYPE(MPI_INT, int);
-CREATE_MPI_DATATYPE(MPI_LONG, long);
-CREATE_MPI_DATATYPE(MPI_LONG_LONG, long long);
-CREATE_MPI_DATATYPE(MPI_SIGNED_CHAR, signed char);
-CREATE_MPI_DATATYPE(MPI_UNSIGNED_CHAR, unsigned char);
-CREATE_MPI_DATATYPE(MPI_UNSIGNED_SHORT, unsigned short);
-CREATE_MPI_DATATYPE(MPI_UNSIGNED, unsigned int);
-CREATE_MPI_DATATYPE(MPI_UNSIGNED_LONG, unsigned long);
-CREATE_MPI_DATATYPE(MPI_UNSIGNED_LONG_LONG, unsigned long long);
-CREATE_MPI_DATATYPE(MPI_FLOAT, float);
-CREATE_MPI_DATATYPE(MPI_DOUBLE, double);
-CREATE_MPI_DATATYPE(MPI_LONG_DOUBLE, long double);
-CREATE_MPI_DATATYPE(MPI_WCHAR, wchar_t);
-CREATE_MPI_DATATYPE(MPI_C_BOOL, bool);
-CREATE_MPI_DATATYPE(MPI_BYTE, int8_t);
-CREATE_MPI_DATATYPE(MPI_INT8_T, int8_t);
-CREATE_MPI_DATATYPE(MPI_INT16_T, int16_t);
-CREATE_MPI_DATATYPE(MPI_INT32_T, int32_t);
-CREATE_MPI_DATATYPE(MPI_INT64_T, int64_t);
-CREATE_MPI_DATATYPE(MPI_UINT8_T, uint8_t);
-CREATE_MPI_DATATYPE(MPI_UINT16_T, uint16_t);
-CREATE_MPI_DATATYPE(MPI_UINT32_T, uint32_t);
-CREATE_MPI_DATATYPE(MPI_UINT64_T, uint64_t);
-CREATE_MPI_DATATYPE(MPI_C_FLOAT_COMPLEX, float _Complex);
-CREATE_MPI_DATATYPE(MPI_C_DOUBLE_COMPLEX, double _Complex);
-CREATE_MPI_DATATYPE(MPI_C_LONG_DOUBLE_COMPLEX, long double _Complex);
-CREATE_MPI_DATATYPE(MPI_AINT, MPI_Aint);
-CREATE_MPI_DATATYPE(MPI_OFFSET, MPI_Offset);
-
-CREATE_MPI_DATATYPE(MPI_FLOAT_INT, float_int);
-CREATE_MPI_DATATYPE(MPI_LONG_INT, long_int);
-CREATE_MPI_DATATYPE(MPI_DOUBLE_INT, double_int);
-CREATE_MPI_DATATYPE(MPI_SHORT_INT, short_int);
-CREATE_MPI_DATATYPE(MPI_2INT, int_int);
-CREATE_MPI_DATATYPE(MPI_2FLOAT, float_float);
-CREATE_MPI_DATATYPE(MPI_2DOUBLE, double_double);
-CREATE_MPI_DATATYPE(MPI_2LONG, long_long);
-
-CREATE_MPI_DATATYPE(MPI_REAL, float);
-CREATE_MPI_DATATYPE(MPI_REAL4, float);
-CREATE_MPI_DATATYPE(MPI_REAL8, float);
-CREATE_MPI_DATATYPE(MPI_REAL16, double);
-CREATE_MPI_DATATYPE_NULL(MPI_COMPLEX8);
-CREATE_MPI_DATATYPE_NULL(MPI_COMPLEX16);
-CREATE_MPI_DATATYPE_NULL(MPI_COMPLEX32);
-CREATE_MPI_DATATYPE(MPI_INTEGER1, int);
-CREATE_MPI_DATATYPE(MPI_INTEGER2, int16_t);
-CREATE_MPI_DATATYPE(MPI_INTEGER4, int32_t);
-CREATE_MPI_DATATYPE(MPI_INTEGER8, int64_t);
-CREATE_MPI_DATATYPE(MPI_INTEGER16, integer128_t);
-
-CREATE_MPI_DATATYPE(MPI_LONG_DOUBLE_INT, long_double_int);
-
-CREATE_MPI_DATATYPE_NULL(MPI_UB);
-CREATE_MPI_DATATYPE_NULL(MPI_LB);
-CREATE_MPI_DATATYPE(MPI_PACKED, char);
+CREATE_MPI_DATATYPE(MPI_CHAR, 2, char);
+CREATE_MPI_DATATYPE(MPI_SHORT, 3, short);
+CREATE_MPI_DATATYPE(MPI_INT, 1, int);
+CREATE_MPI_DATATYPE(MPI_LONG, 4, long);
+CREATE_MPI_DATATYPE(MPI_LONG_LONG, 7, long long);
+CREATE_MPI_DATATYPE(MPI_SIGNED_CHAR, 8, signed char);
+CREATE_MPI_DATATYPE(MPI_UNSIGNED_CHAR, 9, unsigned char);
+CREATE_MPI_DATATYPE(MPI_UNSIGNED_SHORT, 10, unsigned short);
+CREATE_MPI_DATATYPE(MPI_UNSIGNED, 11, unsigned int);
+CREATE_MPI_DATATYPE(MPI_UNSIGNED_LONG, 12, unsigned long);
+CREATE_MPI_DATATYPE(MPI_UNSIGNED_LONG_LONG, 13, unsigned long long);
+CREATE_MPI_DATATYPE(MPI_FLOAT, 5, float);
+CREATE_MPI_DATATYPE(MPI_DOUBLE, 0, double);
+CREATE_MPI_DATATYPE(MPI_LONG_DOUBLE, 14, long double);
+CREATE_MPI_DATATYPE(MPI_WCHAR, 15, wchar_t);
+CREATE_MPI_DATATYPE(MPI_C_BOOL, 16, bool);
+CREATE_MPI_DATATYPE(MPI_BYTE, 6, int8_t);
+CREATE_MPI_DATATYPE(MPI_INT8_T, 17, int8_t);
+CREATE_MPI_DATATYPE(MPI_INT16_T, 18, int16_t);
+CREATE_MPI_DATATYPE(MPI_INT32_T, 19, int32_t);
+CREATE_MPI_DATATYPE(MPI_INT64_T, 20, int64_t);
+CREATE_MPI_DATATYPE(MPI_UINT8_T, 21, uint8_t);
+CREATE_MPI_DATATYPE(MPI_UINT16_T, 22, uint16_t);
+CREATE_MPI_DATATYPE(MPI_UINT32_T, 23, uint32_t);
+CREATE_MPI_DATATYPE(MPI_UINT64_T, 24, uint64_t);
+CREATE_MPI_DATATYPE(MPI_C_FLOAT_COMPLEX, 25, float _Complex);
+CREATE_MPI_DATATYPE(MPI_C_DOUBLE_COMPLEX, 26, double _Complex);
+CREATE_MPI_DATATYPE(MPI_C_LONG_DOUBLE_COMPLEX, 27, long double _Complex);
+CREATE_MPI_DATATYPE(MPI_AINT, 28, MPI_Aint);
+CREATE_MPI_DATATYPE(MPI_OFFSET, 29, MPI_Offset);
+
+CREATE_MPI_DATATYPE(MPI_FLOAT_INT, 30, float_int);
+CREATE_MPI_DATATYPE(MPI_LONG_INT, 31, long_int);
+CREATE_MPI_DATATYPE(MPI_DOUBLE_INT, 32, double_int);
+CREATE_MPI_DATATYPE(MPI_SHORT_INT, 33, short_int);
+CREATE_MPI_DATATYPE(MPI_2INT, 34, int_int);
+CREATE_MPI_DATATYPE(MPI_2FLOAT, 35, float_float);
+CREATE_MPI_DATATYPE(MPI_2DOUBLE, 36, double_double);
+CREATE_MPI_DATATYPE(MPI_2LONG, 37, long_long);
+
+CREATE_MPI_DATATYPE(MPI_REAL, 38, float);
+CREATE_MPI_DATATYPE(MPI_REAL4, 39, float);
+CREATE_MPI_DATATYPE(MPI_REAL8, 40, double);
+CREATE_MPI_DATATYPE(MPI_REAL16, 41, long double);
+CREATE_MPI_DATATYPE_NULL(MPI_DATATYPE_NULL, -1);
+CREATE_MPI_DATATYPE_NULL(MPI_COMPLEX8, 42);
+CREATE_MPI_DATATYPE_NULL(MPI_COMPLEX16, 43);
+CREATE_MPI_DATATYPE_NULL(MPI_COMPLEX32, 44);
+CREATE_MPI_DATATYPE(MPI_INTEGER1, 45, int);
+CREATE_MPI_DATATYPE(MPI_INTEGER2, 46, int16_t);
+CREATE_MPI_DATATYPE(MPI_INTEGER4, 47, int32_t);
+CREATE_MPI_DATATYPE(MPI_INTEGER8, 48, int64_t);
+CREATE_MPI_DATATYPE(MPI_INTEGER16, 49, integer128_t);
+
+CREATE_MPI_DATATYPE(MPI_LONG_DOUBLE_INT, 50, long_double_int);
+
+CREATE_MPI_DATATYPE_NULL(MPI_UB, 51);
+CREATE_MPI_DATATYPE_NULL(MPI_LB, 52);
+CREATE_MPI_DATATYPE(MPI_PACKED, 53, char);
// Internal use only
-CREATE_MPI_DATATYPE(MPI_PTR, void*);
+CREATE_MPI_DATATYPE(MPI_PTR, 54, void*);
namespace simgrid{
namespace smpi{
-std::unordered_map<int, smpi_key_elem> Datatype::keyvals_;
-int Datatype::keyval_id_=0;
-
+std::unordered_map<int, smpi_key_elem> Datatype::keyvals_; // required by the Keyval class implementation
+int Datatype::keyval_id_=0; // required by the Keyval class implementation
+Datatype::Datatype(int ident, int size, MPI_Aint lb, MPI_Aint ub, int flags) : Datatype(size, lb, ub, flags)
+{
+ id = std::to_string(ident);
+}
Datatype::Datatype(int size,MPI_Aint lb, MPI_Aint ub, int flags) : name_(nullptr), size_(size), lb_(lb), ub_(ub), flags_(flags), refcount_(1){
#if SIMGRID_HAVE_MC
if(MC_is_active())
}
//for predefined types, so in_use = 0.
-Datatype::Datatype(char* name, int size,MPI_Aint lb, MPI_Aint ub, int flags) : name_(name), size_(size), lb_(lb), ub_(ub), flags_(flags), refcount_(0){
+Datatype::Datatype(char* name, int ident, int size, MPI_Aint lb, MPI_Aint ub, int flags)
+ : name_(name), id(std::to_string(ident)), size_(size), lb_(lb), ub_(ub), flags_(flags), refcount_(0)
+{
+ id2type_lookup.insert({id, this});
#if SIMGRID_HAVE_MC
if(MC_is_active())
MC_ignore(&(refcount_), sizeof(refcount_));
*ret = MPI_SUCCESS;
if(datatype->name_)
name_ = xbt_strdup(datatype->name_);
-
+
if (not datatype->attributes()->empty()) {
- int flag;
+ int flag=0;
void* value_out;
- for(auto it = datatype->attributes()->begin(); it != datatype->attributes()->end(); it++){
- smpi_key_elem elem = keyvals_.at((*it).first);
-
- if (elem != nullptr && elem->copy_fn.type_copy_fn != MPI_NULL_COPY_FN) {
- *ret = elem->copy_fn.type_copy_fn(datatype, (*it).first, nullptr, (*it).second, &value_out, &flag);
+ for (auto const& it : *(datatype->attributes())) {
+ smpi_key_elem elem = keyvals_.at(it.first);
+ if (elem != nullptr){
+ if( elem->copy_fn.type_copy_fn != MPI_NULL_COPY_FN &&
+ elem->copy_fn.type_copy_fn != MPI_TYPE_DUP_FN)
+ *ret = elem->copy_fn.type_copy_fn(datatype, it.first, elem->extra_state, it.second, &value_out, &flag);
+ else if ( elem->copy_fn.type_copy_fn_fort != MPI_NULL_COPY_FN &&
+ (*(int*)*elem->copy_fn.type_copy_fn_fort) != 1){
+ value_out=(int*)xbt_malloc(sizeof(int));
+ elem->copy_fn.type_copy_fn_fort(datatype, it.first, elem->extra_state, it.second, value_out, &flag,ret);
+ }
if (*ret != MPI_SUCCESS) {
break;
}
- if (flag){
+ if(elem->copy_fn.type_copy_fn == MPI_TYPE_DUP_FN ||
+ ((elem->copy_fn.type_copy_fn_fort != MPI_NULL_COPY_FN) && (*(int*)*elem->copy_fn.type_copy_fn_fort == 1))){
+ elem->refcount++;
+ attributes()->insert({it.first, it.second});
+ } else if (flag){
elem->refcount++;
- attributes()->insert({(*it).first, value_out});
+ attributes()->insert({it.first, value_out});
}
}
}
flags_ |= DT_FLAG_COMMITED;
}
-
bool Datatype::is_valid(){
return (flags_ & DT_FLAG_COMMITED);
}
+bool Datatype::is_basic()
+{
+ return (flags_ & DT_FLAG_BASIC);
+}
+
+const char* Datatype::encode(MPI_Datatype dt)
+{
+ return dt->id.c_str();
+}
+
+MPI_Datatype Datatype::decode(std::string datatype_id)
+{
+ return id2type_lookup.find(datatype_id)->second;
+}
+
+bool Datatype::is_replayable()
+{
+ return (simgrid::instr::trace_format == simgrid::instr::TraceFormat::Ti) &&
+ ((this == MPI_BYTE) || (this == MPI_DOUBLE) || (this == MPI_INT) || (this == MPI_CHAR) ||
+ (this == MPI_SHORT) || (this == MPI_LONG) || (this == MPI_FLOAT));
+}
+
size_t Datatype::size(){
return size_;
}
// FIXME Handle the case of a partial shared malloc.
- if(smpi_privatize_global_variables == SMPI_PRIVATIZE_MMAP){
- smpi_switch_data_segment(smpi_process()->index());
+ if (smpi_privatize_global_variables == SmpiPrivStrategies::MMAP) {
+ smpi_switch_data_segment(simgrid::s4u::Actor::self());
}
/* First check if we really have something to do */
if (recvcount > 0 && recvbuf != sendbuf) {
if (not smpi_process()->replaying())
memcpy(recvbuf, sendbuf, count);
} else if (not(sendtype->flags() & DT_FLAG_DERIVED)) {
- recvtype->unserialize( sendbuf, recvbuf, recvcount/recvtype->size(), MPI_REPLACE);
+ recvtype->unserialize(sendbuf, recvbuf, count / recvtype->size(), MPI_REPLACE);
} else if (not(recvtype->flags() & DT_FLAG_DERIVED)) {
- sendtype->serialize(sendbuf, recvbuf, sendcount/sendtype->size());
+ sendtype->serialize(sendbuf, recvbuf, count / sendtype->size());
}else{
void * buf_tmp = xbt_malloc(count);
return MPI_SUCCESS;
}
+int Datatype::create_subarray(int ndims, int* array_of_sizes,
+ int* array_of_subsizes, int* array_of_starts,
+ int order, MPI_Datatype oldtype, MPI_Datatype *newtype){
+ MPI_Datatype tmp;
+
+ for (int i = 0; i < ndims; i++) {
+ if (array_of_subsizes[i] > array_of_sizes[i]){
+ XBT_WARN("subarray : array_of_subsizes > array_of_sizes for dim %d",i);
+ return MPI_ERR_ARG;
+ }
+ if (array_of_starts[i] + array_of_subsizes[i] > array_of_sizes[i]){
+ XBT_WARN("subarray : array_of_starts + array_of_subsizes > array_of_sizes for dim %d",i);
+ return MPI_ERR_ARG;
+ }
+ }
+
+ MPI_Aint extent = oldtype->get_extent();
+
+ int i;
+ int step;
+ int end;
+ if( order==MPI_ORDER_C ) {
+ i = ndims - 1;
+ step = -1;
+ end = -1;
+ } else {
+ i = 0;
+ step = 1;
+ end = ndims;
+ }
+
+ MPI_Aint size = (MPI_Aint)array_of_sizes[i] * (MPI_Aint)array_of_sizes[i+step];
+ MPI_Aint lb = (MPI_Aint)array_of_starts[i] + (MPI_Aint)array_of_starts[i+step] *(MPI_Aint)array_of_sizes[i];
+
+ create_vector( array_of_subsizes[i+step], array_of_subsizes[i], array_of_sizes[i],
+ oldtype, newtype );
+
+ tmp = *newtype;
+
+ for( i += 2 * step; i != end; i += step ) {
+ create_hvector( array_of_subsizes[i], 1, size * extent,
+ tmp, newtype );
+ unref(tmp);
+ lb += size * array_of_starts[i];
+ size *= array_of_sizes[i];
+ tmp = *newtype;
+ }
+
+ MPI_Aint lbs[1] = {lb * extent};
+ int sizes [1]={1};
+ //handle LB and UB with a resized call
+ create_hindexed( 1, sizes, lbs, tmp, newtype);
+ unref(tmp);
+
+ tmp = *newtype;
+ create_resized(tmp, 0, extent, newtype);
+
+ unref(tmp);
+ return MPI_SUCCESS;
+}
+
+int Datatype::create_resized(MPI_Datatype oldtype,MPI_Aint lb, MPI_Aint extent, MPI_Datatype *newtype){
+ int blocks[3] = {1, 1, 1};
+ MPI_Aint disps[3] = {lb, 0, lb + extent};
+ MPI_Datatype types[3] = {MPI_LB, oldtype, MPI_UB};
+
+ *newtype = new simgrid::smpi::Type_Struct(oldtype->size(), lb, lb + extent, DT_FLAG_DERIVED, 3, blocks, disps, types);
+
+ (*newtype)->addflag(~DT_FLAG_COMMITED);
+ return MPI_SUCCESS;
+}
+
Datatype* Datatype::f2c(int id){
return static_cast<Datatype*>(F2C::f2c(id));
}
