Continuing work on datatypes

[simgrid.git] / src / smpi / smpi_request.cpp

diff --git a/src/smpi/smpi_request.cpp b/src/smpi/smpi_request.cpp
index 89bab5ae687523cb24dff5494268df3f9c512d11..d6e0fccbe00eb3c73d73fc87bf61a017b32e15ed 100644 (file)
--- a/src/smpi/smpi_request.cpp
+++ b/src/smpi/smpi_request.cpp
@@ -113,20 +113,20 @@ 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) 
 {
   void *old_buf = nullptr;
-  s_smpi_subtype_t *subtype = static_cast<s_smpi_subtype_t*>(datatype->substruct);
-
-  if((((flags & RECV) != 0) && ((flags & ACCUMULATE) !=0)) || (datatype->sizeof_substruct != 0)){
-    // This part handles the problem of non-contiguous memory
-    old_buf = buf;
-    buf_ = count==0 ? nullptr : xbt_malloc(count*smpi_datatype_size(datatype));
-    if ((datatype->sizeof_substruct != 0) && ((flags & SEND) != 0)) {
-      subtype->serialize(old_buf, buf_, count, datatype->substruct);
-    }
-  }
+//  s_smpi_subtype_t *subtype = static_cast<s_smpi_subtype_t*>(datatype->substruct);
+
+//  if((((flags & RECV) != 0) && ((flags & ACCUMULATE) !=0)) || (datatype->sizeof_substruct != 0)){
+//    // This part handles the problem of non-contiguous memory
+//    old_buf = buf;
+//    buf_ = count==0 ? nullptr : xbt_malloc(count*datatype->size());
+//    if ((datatype->sizeof_substruct != 0) && ((flags & SEND) != 0)) {
+//      subtype->serialize(old_buf, buf_, count, datatype->substruct);
+//    }
+//  }
   // This part handles the problem of non-contiguous memory (for the unserialisation at the reception)
   old_buf_  = old_buf;
-  size_ = smpi_datatype_size(datatype) * count;
-  smpi_datatype_use(datatype);
+  size_ = datatype->size() * count;
+  datatype->use();
   comm_->use();
   action_          = nullptr;
   detached_        = 0;
@@ -181,7 +181,7 @@ void Request::unuse(MPI_Request* request)
     if((*request)->refcount_<0) xbt_die("wrong refcount");
 
     if((*request)->refcount_==0){
-        smpi_datatype_unuse((*request)->old_type_);
+        (*request)->old_type_->unuse();
         (*request)->comm_->unuse();
         (*request)->print_request("Destroying");
         delete *request;
@@ -391,7 +391,7 @@ void Request::sendrecv(void *sendbuf, int sendcount, MPI_Datatype sendtype,int d
   MPI_Status stats[2];
   int myid=smpi_process_index();
   if ((comm->group()->index(dst) == myid) && (comm->group()->index(src) == myid)){
-      smpi_datatype_copy(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype);
+      Datatype::copy(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype);
       return;
   }
   requests[0] = isend_init(sendbuf, sendcount, sendtype, dst, sendtag, comm);
@@ -482,24 +482,24 @@ void Request::start()
     void* buf = buf_;
     if ((flags_ & SSEND) == 0 && ( (flags_ & RMA) != 0
         || static_cast<int>(size_) < xbt_cfg_get_int("smpi/send-is-detached-thresh") ) ) {
-      void *oldbuf = nullptr;
+//      void *oldbuf = nullptr;
       detached_ = 1;
       XBT_DEBUG("Send request %p is detached", this);
       refcount_++;
-      if(old_type_->sizeof_substruct == 0){
-        oldbuf = buf_;
-        if (!smpi_process_get_replaying() && oldbuf != nullptr && size_!=0){
-          if((smpi_privatize_global_variables != 0)
-            && (static_cast<char*>(buf_) >= smpi_start_data_exe)
-            && (static_cast<char*>(buf_) < smpi_start_data_exe + smpi_size_data_exe )){
-            XBT_DEBUG("Privatization : We are sending from a zone inside global memory. Switch data segment ");
-            smpi_switch_data_segment(src_);
-          }
-          buf = xbt_malloc(size_);
-          memcpy(buf,oldbuf,size_);
-          XBT_DEBUG("buf %p copied into %p",oldbuf,buf);
-        }
-      }
+//      if(old_type_->sizeof_substruct == 0){
+//        oldbuf = buf_;
+//        if (!smpi_process_get_replaying() && oldbuf != nullptr && size_!=0){
+//          if((smpi_privatize_global_variables != 0)
+//            && (static_cast<char*>(buf_) >= smpi_start_data_exe)
+//            && (static_cast<char*>(buf_) < smpi_start_data_exe + smpi_size_data_exe )){
+//            XBT_DEBUG("Privatization : We are sending from a zone inside global memory. Switch data segment ");
+//            smpi_switch_data_segment(src_);
+//          }
+//          buf = xbt_malloc(size_);
+//          memcpy(buf,oldbuf,size_);
+//          XBT_DEBUG("buf %p copied into %p",oldbuf,buf);
+//        }
+//      }
     }
 
     //if we are giving back the control to the user without waiting for completion, we have to inject timings
@@ -792,7 +792,7 @@ void Request::finish_wait(MPI_Request* request, MPI_Status * status)
     req->print_request("Finishing");
     MPI_Datatype datatype = req->old_type_;
 
-    if(((req->flags_ & ACCUMULATE) != 0) || (datatype->sizeof_substruct != 0)){
+    if(((req->flags_ & ACCUMULATE) != 0)/* || (datatype->sizeof_substruct != 0)*/){
       if (!smpi_process_get_replaying()){
         if( smpi_privatize_global_variables != 0 && (static_cast<char*>(req->old_buf_) >= smpi_start_data_exe)
             && ((char*)req->old_buf_ < smpi_start_data_exe + smpi_size_data_exe )){
@@ -801,16 +801,17 @@ void Request::finish_wait(MPI_Request* request, MPI_Status * status)
         }
       }
 
-      if(datatype->sizeof_substruct != 0){
-        // This part handles the problem of non-contignous memory the unserialization at the reception
-        s_smpi_subtype_t *subtype = static_cast<s_smpi_subtype_t*>(datatype->substruct);
-        if(req->flags_ & RECV)
-          subtype->unserialize(req->buf_, req->old_buf_, req->real_size_/smpi_datatype_size(datatype) ,
-                               datatype->substruct, req->op_);
-        xbt_free(req->buf_);
-      }else if(req->flags_ & RECV){//apply op on contiguous buffer for accumulate
-          int n =req->real_size_/smpi_datatype_size(datatype);
-          req->op_->apply(req->buf_, req->old_buf_, &n, &datatype);
+//      if(datatype->sizeof_substruct != 0){
+//        // This part handles the problem of non-contignous memory the unserialization at the reception
+//        s_smpi_subtype_t *subtype = static_cast<s_smpi_subtype_t*>(datatype->substruct);
+//        if(req->flags_ & RECV)
+//          subtype->unserialize(req->buf_, req->old_buf_, req->real_size_/datatype->size() ,
+//                               datatype->substruct, req->op_);
+//        xbt_free(req->buf_);
+//      }else 
+    if(req->flags_ & RECV){//apply op on contiguous buffer for accumulate
+          int n =req->real_size_/datatype->size();
+          req->op_->apply(req->buf_, req->old_buf_, &n, datatype);
           xbt_free(req->buf_);
       }
     }