X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/43f7ca1cac5ab1858e318fdd6239d0a0c3b3d893..fbcf6ab31cae1988be858f9f894dafe529c575d7:/src/smpi/bindings/smpi_pmpi_type.cpp

diff --git a/src/smpi/bindings/smpi_pmpi_type.cpp b/src/smpi/bindings/smpi_pmpi_type.cpp
index e150b2b418..868a2a9622 100644
--- a/src/smpi/bindings/smpi_pmpi_type.cpp
+++ b/src/smpi/bindings/smpi_pmpi_type.cpp
@@ -1,21 +1,20 @@
-/* Copyright (c) 2007-2017. The SimGrid Team. All rights reserved.          */
+/* Copyright (c) 2007-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 "private.h"
+#include "private.hpp"
 #include "smpi_datatype_derived.hpp"
 
 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(smpi_pmpi);
 
 /* PMPI User level calls */
-extern "C" { // Obviously, the C MPI interface should use the C linkage
 
 int PMPI_Type_free(MPI_Datatype * datatype)
 {
   /* Free a predefined datatype is an error according to the standard, and should be checked for */
-  if (*datatype == MPI_DATATYPE_NULL) {
-    return MPI_ERR_ARG;
+  if (*datatype == MPI_DATATYPE_NULL || (*datatype)->flags() & DT_FLAG_PREDEFINED) {
+    return MPI_ERR_TYPE;
   } else {
     simgrid::smpi::Datatype::unref(*datatype);
     return MPI_SUCCESS;
@@ -135,8 +134,10 @@ int PMPI_Type_commit(MPI_Datatype* datatype) {
 int PMPI_Type_vector(int count, int blocklen, int stride, MPI_Datatype old_type, MPI_Datatype* new_type) {
   if (old_type == MPI_DATATYPE_NULL) {
     return MPI_ERR_TYPE;
-  } else if (count<0 || blocklen<0){
+  } else if (count<0){
     return MPI_ERR_COUNT;
+  } else if(blocklen<0){
+    return MPI_ERR_ARG;
   } else {
     return simgrid::smpi::Datatype::create_vector(count, blocklen, stride, old_type, new_type);
   }
@@ -145,8 +146,10 @@ int PMPI_Type_vector(int count, int blocklen, int stride, MPI_Datatype old_type,
 int PMPI_Type_hvector(int count, int blocklen, MPI_Aint stride, MPI_Datatype old_type, MPI_Datatype* new_type) {
   if (old_type == MPI_DATATYPE_NULL) {
     return MPI_ERR_TYPE;
-  } else if (count<0 || blocklen<0){
+  } else if (count<0){
     return MPI_ERR_COUNT;
+  } else if(blocklen<0){
+    return MPI_ERR_ARG;
   } else {
     return simgrid::smpi::Datatype::create_hvector(count, blocklen, stride, old_type, new_type);
   }
@@ -156,7 +159,7 @@ int PMPI_Type_create_hvector(int count, int blocklen, MPI_Aint stride, MPI_Datat
   return MPI_Type_hvector(count, blocklen, stride, old_type, new_type);
 }
 
-int PMPI_Type_indexed(int count, int* blocklens, int* indices, MPI_Datatype old_type, MPI_Datatype* new_type) {
+int PMPI_Type_indexed(int count, const int* blocklens, const int* indices, MPI_Datatype old_type, MPI_Datatype* new_type) {
   if (old_type == MPI_DATATYPE_NULL) {
     return MPI_ERR_TYPE;
   } else if (count<0){
@@ -166,7 +169,7 @@ int PMPI_Type_indexed(int count, int* blocklens, int* indices, MPI_Datatype old_
   }
 }
 
-int PMPI_Type_create_indexed(int count, int* blocklens, int* indices, MPI_Datatype old_type, MPI_Datatype* new_type) {
+int PMPI_Type_create_indexed(int count, const int* blocklens, const int* indices, MPI_Datatype old_type, MPI_Datatype* new_type) {
   if (old_type == MPI_DATATYPE_NULL) {
     return MPI_ERR_TYPE;
   } else if (count<0){
@@ -176,7 +179,7 @@ int PMPI_Type_create_indexed(int count, int* blocklens, int* indices, MPI_Dataty
   }
 }
 
-int PMPI_Type_create_indexed_block(int count, int blocklength, int* indices, MPI_Datatype old_type,
+int PMPI_Type_create_indexed_block(int count, int blocklength, const int* indices, MPI_Datatype old_type,
                                    MPI_Datatype* new_type)
 {
   if (old_type == MPI_DATATYPE_NULL) {
@@ -193,7 +196,8 @@ int PMPI_Type_create_indexed_block(int count, int blocklength, int* indices, MPI
   }
 }
 
-int PMPI_Type_hindexed(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype old_type, MPI_Datatype* new_type)
+int PMPI_Type_hindexed(int count, const int* blocklens, const MPI_Aint* indices, MPI_Datatype old_type,
+                       MPI_Datatype* new_type)
 {
   if (old_type == MPI_DATATYPE_NULL) {
     return MPI_ERR_TYPE;
@@ -204,12 +208,12 @@ int PMPI_Type_hindexed(int count, int* blocklens, MPI_Aint* indices, MPI_Datatyp
   }
 }
 
-int PMPI_Type_create_hindexed(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype old_type,
+int PMPI_Type_create_hindexed(int count, const int* blocklens, const MPI_Aint* indices, MPI_Datatype old_type,
                               MPI_Datatype* new_type) {
-  return PMPI_Type_hindexed(count, blocklens,indices,old_type,new_type);
+  return PMPI_Type_hindexed(count, blocklens, indices, old_type, new_type);
 }
 
-int PMPI_Type_create_hindexed_block(int count, int blocklength, MPI_Aint* indices, MPI_Datatype old_type,
+int PMPI_Type_create_hindexed_block(int count, int blocklength, const MPI_Aint* indices, MPI_Datatype old_type,
                                     MPI_Datatype* new_type) {
   if (old_type == MPI_DATATYPE_NULL) {
     return MPI_ERR_TYPE;
@@ -225,35 +229,54 @@ int PMPI_Type_create_hindexed_block(int count, int blocklength, MPI_Aint* indice
   }
 }
 
-int PMPI_Type_struct(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype* old_types, MPI_Datatype* new_type) {
+int PMPI_Type_struct(int count, const int* blocklens, const MPI_Aint* indices, const MPI_Datatype* old_types,
+                     MPI_Datatype* new_type)
+{
   if (count<0){
     return MPI_ERR_COUNT;
   } else {
+    for(int i=0; i<count; i++)
+      if(old_types[i]==MPI_DATATYPE_NULL)
+        return MPI_ERR_TYPE;
     return simgrid::smpi::Datatype::create_struct(count, blocklens, indices, old_types, new_type);
   }
 }
 
-int PMPI_Type_create_struct(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype* old_types,
+int PMPI_Type_create_struct(int count, const int* blocklens, const MPI_Aint* indices, const MPI_Datatype* old_types,
                             MPI_Datatype* new_type) {
   return PMPI_Type_struct(count, blocklens, indices, old_types, new_type);
 }
 
+
+int PMPI_Type_create_subarray(int ndims, const int* array_of_sizes,
+                             const int* array_of_subsizes, const int* array_of_starts,
+                             int order, MPI_Datatype oldtype, MPI_Datatype *newtype) {
+  if (ndims<0){
+    return MPI_ERR_COUNT;
+  } else if (ndims==0){
+    *newtype = MPI_DATATYPE_NULL;
+    return MPI_SUCCESS;
+  } else if (ndims==1){
+    simgrid::smpi::Datatype::create_contiguous( array_of_subsizes[0], oldtype, array_of_starts[0]*oldtype->get_extent(), newtype);
+    return MPI_SUCCESS;
+  } else if (oldtype == MPI_DATATYPE_NULL || not oldtype->is_valid() ) {
+    return MPI_ERR_TYPE;
+  } else if (order != MPI_ORDER_FORTRAN && order != MPI_ORDER_C){
+    return MPI_ERR_ARG;
+  } else {
+    return simgrid::smpi::Datatype::create_subarray(ndims, array_of_sizes, array_of_subsizes, array_of_starts, order, oldtype, newtype);
+  }
+}
+
 int PMPI_Type_create_resized(MPI_Datatype oldtype,MPI_Aint lb, MPI_Aint extent, MPI_Datatype *newtype){
   if (oldtype == MPI_DATATYPE_NULL) {
     return MPI_ERR_TYPE;
   }
-  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;
+  return simgrid::smpi::Datatype::create_resized(oldtype, lb, extent, newtype);
 }
 
 
-int PMPI_Type_set_name(MPI_Datatype  datatype, char * name)
+int PMPI_Type_set_name(MPI_Datatype  datatype, const char * name)
 {
   if (datatype == MPI_DATATYPE_NULL)  {
     return MPI_ERR_TYPE;
@@ -312,8 +335,8 @@ int PMPI_Type_delete_attr (MPI_Datatype type, int type_keyval)
 int PMPI_Type_create_keyval(MPI_Type_copy_attr_function* copy_fn, MPI_Type_delete_attr_function* delete_fn, int* keyval,
                             void* extra_state)
 {
-  smpi_copy_fn _copy_fn={nullptr,copy_fn,nullptr};
-  smpi_delete_fn _delete_fn={nullptr,delete_fn,nullptr};
+  smpi_copy_fn _copy_fn={nullptr,copy_fn,nullptr,nullptr,nullptr,nullptr};
+  smpi_delete_fn _delete_fn={nullptr,delete_fn,nullptr,nullptr,nullptr,nullptr};
   return simgrid::smpi::Keyval::keyval_create<simgrid::smpi::Datatype>(_copy_fn, _delete_fn, keyval, extra_state);
 }
 
@@ -321,37 +344,43 @@ int PMPI_Type_free_keyval(int* keyval) {
   return simgrid::smpi::Keyval::keyval_free<simgrid::smpi::Datatype>(keyval);
 }
 
-int PMPI_Unpack(void* inbuf, int incount, int* position, void* outbuf, int outcount, MPI_Datatype type, MPI_Comm comm) {
-  if(incount<0 || outcount < 0 || inbuf==nullptr || outbuf==nullptr)
+int PMPI_Unpack(const void* inbuf, int incount, int* position, void* outbuf, int outcount, MPI_Datatype type, MPI_Comm comm) {
+  if(incount<0 || outcount < 0){
+    return MPI_ERR_COUNT;
+  } else if (inbuf==nullptr || outbuf==nullptr){
     return MPI_ERR_ARG;
-  if (not type->is_valid())
+  } else if (type == MPI_DATATYPE_NULL || not type->is_valid()){
     return MPI_ERR_TYPE;
-  if(comm==MPI_COMM_NULL)
+  } else if(comm==MPI_COMM_NULL){
     return MPI_ERR_COMM;
-  return type->unpack(inbuf, incount, position, outbuf,outcount, comm);
+  } else{
+    return type->unpack(inbuf, incount, position, outbuf,outcount, comm);
+  }
 }
 
-int PMPI_Pack(void* inbuf, int incount, MPI_Datatype type, void* outbuf, int outcount, int* position, MPI_Comm comm) {
-  if(incount<0 || outcount < 0|| inbuf==nullptr || outbuf==nullptr)
+int PMPI_Pack(const void* inbuf, int incount, MPI_Datatype type, void* outbuf, int outcount, int* position, MPI_Comm comm) {
+  if(incount<0){
+    return MPI_ERR_COUNT;
+  } else if(inbuf==nullptr || outbuf==nullptr || outcount < 0){
     return MPI_ERR_ARG;
-  if (not type->is_valid())
+  } else if (type == MPI_DATATYPE_NULL || not type->is_valid()){
     return MPI_ERR_TYPE;
-  if(comm==MPI_COMM_NULL)
+  } else if(comm==MPI_COMM_NULL){
     return MPI_ERR_COMM;
-  return type->pack(inbuf, incount, outbuf,outcount,position, comm);
+  } else {
+    return type->pack(inbuf == MPI_BOTTOM ? nullptr : inbuf, incount, outbuf, outcount, position, comm);
+  }
 }
 
 int PMPI_Pack_size(int incount, MPI_Datatype datatype, MPI_Comm comm, int* size) {
-  if(incount<0)
-    return MPI_ERR_ARG;
-  if (not datatype->is_valid())
+  if(incount<0){
+    return MPI_ERR_COUNT;
+  } else if (datatype == MPI_DATATYPE_NULL || not datatype->is_valid()){
     return MPI_ERR_TYPE;
-  if(comm==MPI_COMM_NULL)
+  } else if(comm==MPI_COMM_NULL){
     return MPI_ERR_COMM;
-
-  *size=incount*datatype->size();
-
-  return MPI_SUCCESS;
-}
-
+  } else {
+    *size=incount*datatype->size();
+    return MPI_SUCCESS;
+  }
 }