Add checks for comms and datatypes as well

[simgrid.git] / 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 69b7eaa..20a79ae 100644 (file)
--- a/src/smpi/bindings/smpi_pmpi_type.cpp
+++ b/src/smpi/bindings/smpi_pmpi_type.cpp
@@ -1,4 +1,4 @@
-/* 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. */
@@ -9,13 +9,12 @@
 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);
   }
@@ -229,6 +232,9 @@ int PMPI_Type_struct(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype*
   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);
   }
 }
@@ -238,18 +244,32 @@ int PMPI_Type_create_struct(int count, int* blocklens, MPI_Aint* indices, MPI_Da
   return PMPI_Type_struct(count, blocklens, indices, old_types, new_type);
 }
 
+
+int PMPI_Type_create_subarray(int ndims, int* array_of_sizes,
+                             int* array_of_subsizes, 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);
 }
 
 
@@ -312,8 +332,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);
 }
 
@@ -322,36 +342,42 @@ int PMPI_Type_free_keyval(int* 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)
+  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)
+  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 == MPI_BOTTOM ? nullptr : 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;
+  }
 }