Reduce code duplication.

The only difference between Vector and Hvector, and between Indexed and
Hindexed is that stride and block_indices are given in multiples of
old_type->get_extent() in the former case, while it's given in bytes in the
latter case.
Thus, make Vector a subclass of Hvector, and Indexed a subclass of Hindexed.

diff --git a/src/smpi/include/smpi_datatype_derived.hpp b/src/smpi/include/smpi_datatype_derived.hpp
index 5c46639..9e1f4c8 100644 (file)
--- a/src/smpi/include/smpi_datatype_derived.hpp
+++ b/src/smpi/include/smpi_datatype_derived.hpp
@@ -23,20 +23,6 @@ public:
   void unserialize(void* contiguous_vector, void* noncontiguous_vector, int count, MPI_Op op);
 };
 
   void unserialize(void* contiguous_vector, void* noncontiguous_vector, int count, MPI_Op op);
 };
 

-class Type_Vector: public Datatype{
-  int block_count_;
-  int block_length_;
-  int block_stride_;
-  MPI_Datatype old_type_;
-
-public:
-  Type_Vector(int size, MPI_Aint lb, MPI_Aint ub, int flags, int count, int blocklen, int stride,
-              MPI_Datatype old_type);
-  ~Type_Vector();
-  void serialize(void* noncontiguous, void* contiguous, int count);
-  void unserialize(void* contiguous_vector, void* noncontiguous_vector, int count, MPI_Op op);
-};
-

 class Type_Hvector: public Datatype{
   int block_count_;
   int block_length_;
 class Type_Hvector: public Datatype{
   int block_count_;
   int block_length_;


@@ -51,18 +37,10 @@ public:
   void unserialize(void* contiguous_vector, void* noncontiguous_vector, int count, MPI_Op op);
 };
 
   void unserialize(void* contiguous_vector, void* noncontiguous_vector, int count, MPI_Op op);
 };
 

-class Type_Indexed: public Datatype{
-  int block_count_;
-  int* block_lengths_;
-  int* block_indices_;
-  MPI_Datatype old_type_;
-
+class Type_Vector : public Type_Hvector {

 public:
 public:

-  Type_Indexed(int size, MPI_Aint lb, MPI_Aint ub, int flags, int block_count, int* block_lengths, int* block_indices,
-               MPI_Datatype old_type);
-  ~Type_Indexed();
-  void serialize(void* noncontiguous, void* contiguous, int count);
-  void unserialize(void* contiguous_vector, void* noncontiguous_vector, int count, MPI_Op op);
+  Type_Vector(int size, MPI_Aint lb, MPI_Aint ub, int flags, int count, int blocklen, int stride,
+              MPI_Datatype old_type);

 };
 
 class Type_Hindexed: public Datatype{
 };
 
 class Type_Hindexed: public Datatype{


@@ -74,11 +52,19 @@ class Type_Hindexed: public Datatype{
 public:
   Type_Hindexed(int size, MPI_Aint lb, MPI_Aint ub, int flags, int block_count, int* block_lengths,
                 MPI_Aint* block_indices, MPI_Datatype old_type);
 public:
   Type_Hindexed(int size, MPI_Aint lb, MPI_Aint ub, int flags, int block_count, int* block_lengths,
                 MPI_Aint* block_indices, MPI_Datatype old_type);

+  Type_Hindexed(int size, MPI_Aint lb, MPI_Aint ub, int flags, int block_count, int* block_lengths, int* block_indices,
+                MPI_Datatype old_type, MPI_Aint factor);

   ~Type_Hindexed();
   void serialize(void* noncontiguous, void* contiguous, int count);
   void unserialize(void* contiguous_vector, void* noncontiguous_vector, int count, MPI_Op op);
 };
 
   ~Type_Hindexed();
   void serialize(void* noncontiguous, void* contiguous, int count);
   void unserialize(void* contiguous_vector, void* noncontiguous_vector, int count, MPI_Op op);
 };
 

+class Type_Indexed : public Type_Hindexed {
+public:
+  Type_Indexed(int size, MPI_Aint lb, MPI_Aint ub, int flags, int block_count, int* block_lengths, int* block_indices,
+               MPI_Datatype old_type);
+};
+

 class Type_Struct: public Datatype{
   int block_count_;
   int* block_lengths_;
 class Type_Struct: public Datatype{
   int block_count_;
   int* block_lengths_;

diff --git a/src/smpi/mpi/smpi_datatype_derived.cpp b/src/smpi/mpi/smpi_datatype_derived.cpp
index 2624ca3..b620511 100644 (file)
--- a/src/smpi/mpi/smpi_datatype_derived.cpp
+++ b/src/smpi/mpi/smpi_datatype_derived.cpp
@@ -38,56 +38,6 @@ void Type_Contiguous::unserialize(void* contiguous_buf, void* noncontiguous_buf,
     op->apply( contiguous_buf_char, noncontiguous_buf_char, &n, old_type_);
 }
 
     op->apply( contiguous_buf_char, noncontiguous_buf_char, &n, old_type_);
 }
 

-
-Type_Vector::Type_Vector(int size,MPI_Aint lb, MPI_Aint ub, int flags, int count, int block_length, int stride, MPI_Datatype old_type): Datatype(size, lb, ub, flags), block_count_(count), block_length_(block_length),block_stride_(stride),  old_type_(old_type){
-  old_type_->ref();
-}
-
-Type_Vector::~Type_Vector(){
-  Datatype::unref(old_type_);
-}
-
-
-void Type_Vector::serialize( void* noncontiguous_buf, void *contiguous_buf,
-                            int count){
-  char* contiguous_buf_char = static_cast<char*>(contiguous_buf);
-  char* noncontiguous_buf_char = static_cast<char*>(noncontiguous_buf);
-
-  for (int i = 0; i < block_count_ * count; i++) {
-    if (not(old_type_->flags() & DT_FLAG_DERIVED))
-      memcpy(contiguous_buf_char, noncontiguous_buf_char, block_length_ * old_type_->size());
-    else
-      old_type_->serialize(noncontiguous_buf_char, contiguous_buf_char, block_length_);
-
-    contiguous_buf_char += block_length_*old_type_->size();
-    if((i+1)%block_count_ ==0)
-      noncontiguous_buf_char += block_length_*old_type_->get_extent();
-    else
-      noncontiguous_buf_char += block_stride_*old_type_->get_extent();
-  }
-}
-
-void Type_Vector::unserialize( void* contiguous_buf, void *noncontiguous_buf,
-                              int count, MPI_Op op){
-  char* contiguous_buf_char = static_cast<char*>(contiguous_buf);
-  char* noncontiguous_buf_char = static_cast<char*>(noncontiguous_buf);
-
-  for (int i = 0; i < block_count_ * count; i++) {
-    if (not(old_type_->flags() & DT_FLAG_DERIVED)) {
-      if(op != MPI_OP_NULL)
-        op->apply(contiguous_buf_char, noncontiguous_buf_char, &block_length_,
-          old_type_);
-    }else
-      old_type_->unserialize(contiguous_buf_char, noncontiguous_buf_char, block_length_, op);
-
-    contiguous_buf_char += block_length_*old_type_->size();
-    if((i+1)%block_count_ ==0)
-      noncontiguous_buf_char += block_length_*old_type_->get_extent();
-    else
-      noncontiguous_buf_char += block_stride_*old_type_->get_extent();
-  }
-}
-

 Type_Hvector::Type_Hvector(int size,MPI_Aint lb, MPI_Aint ub, int flags, int count, int block_length, MPI_Aint stride, MPI_Datatype old_type): Datatype(size, lb, ub, flags), block_count_(count), block_length_(block_length), block_stride_(stride), old_type_(old_type){
   old_type->ref();
 }
 Type_Hvector::Type_Hvector(int size,MPI_Aint lb, MPI_Aint ub, int flags, int count, int block_length, MPI_Aint stride, MPI_Datatype old_type): Datatype(size, lb, ub, flags), block_count_(count), block_length_(block_length), block_stride_(stride), old_type_(old_type){
   old_type->ref();
 }


@@ -114,7 +64,6 @@ void Type_Hvector::serialize( void* noncontiguous_buf, void *contiguous_buf,
   }
 }
 
   }
 }
 

-

 void Type_Hvector::unserialize( void* contiguous_buf, void *noncontiguous_buf,
                               int count, MPI_Op op){
   char* contiguous_buf_char = static_cast<char*>(contiguous_buf);
 void Type_Hvector::unserialize( void* contiguous_buf, void *noncontiguous_buf,
                               int count, MPI_Op op){
   char* contiguous_buf_char = static_cast<char*>(contiguous_buf);


@@ -134,86 +83,40 @@ void Type_Hvector::unserialize( void* contiguous_buf, void *noncontiguous_buf,
   }
 }
 
   }
 }
 

-Type_Indexed::Type_Indexed(int size,MPI_Aint lb, MPI_Aint ub, int flags, int count, int* block_lengths, int* block_indices, MPI_Datatype old_type): Datatype(size, lb, ub, flags), block_count_(count), old_type_(old_type){
-  old_type->ref();
-  block_lengths_ = new int[count];
-  block_indices_ = new int[count];
-  for (int i = 0; i < count; i++) {
-    block_lengths_[i]=block_lengths[i];
-    block_indices_[i]=block_indices[i];
-  }
-}
-
-Type_Indexed::~Type_Indexed(){
-  Datatype::unref(old_type_);
-  if(refcount()==0){
-    delete[] block_lengths_;
-    delete[] block_indices_;
-  }
-}
-
-
-void Type_Indexed::serialize( void* noncontiguous_buf, void *contiguous_buf,
-                        int count){
-  char* contiguous_buf_char = static_cast<char*>(contiguous_buf);
-  char* noncontiguous_buf_char = static_cast<char*>(noncontiguous_buf)+block_indices_[0] * old_type_->size();
-  for (int j = 0; j < count; j++) {
-    for (int i = 0; i < block_count_; i++) {
-      if (not(old_type_->flags() & DT_FLAG_DERIVED))
-        memcpy(contiguous_buf_char, noncontiguous_buf_char, block_lengths_[i] * old_type_->size());
-      else
-        old_type_->serialize( noncontiguous_buf_char, contiguous_buf_char, block_lengths_[i]);
-
-      contiguous_buf_char += block_lengths_[i]*old_type_->size();
-      if (i<block_count_-1)
-        noncontiguous_buf_char =
-          static_cast<char*>(noncontiguous_buf) + block_indices_[i+1]*old_type_->get_extent();
-      else
-        noncontiguous_buf_char += block_lengths_[i]*old_type_->get_extent();
-    }
-    noncontiguous_buf=static_cast< void*>(noncontiguous_buf_char);
-  }
+Type_Vector::Type_Vector(int size, MPI_Aint lb, MPI_Aint ub, int flags, int count, int block_length, int stride,
+                         MPI_Datatype old_type)
+    : Type_Hvector(size, lb, ub, flags, count, block_length, stride * old_type->get_extent(), old_type)
+{

 }
 
 }
 

-
-void Type_Indexed::unserialize( void* contiguous_buf, void *noncontiguous_buf,
-                      int count, MPI_Op op){
-  char* contiguous_buf_char = static_cast<char*>(contiguous_buf);
-  char* noncontiguous_buf_char =
-    static_cast<char*>(noncontiguous_buf)+block_indices_[0]*old_type_->get_extent();
-  for (int j = 0; j < count; j++) {
-    for (int i = 0; i < block_count_; i++) {
-      if (not(old_type_->flags() & DT_FLAG_DERIVED)) {
-        if(op!=MPI_OP_NULL)
-          op->apply( contiguous_buf_char, noncontiguous_buf_char, &block_lengths_[i],
-                    old_type_);
-      }else
-        old_type_->unserialize( contiguous_buf_char,noncontiguous_buf_char,block_lengths_[i], op);
-
-      contiguous_buf_char += block_lengths_[i]*old_type_->size();
-      if (i<block_count_-1)
-        noncontiguous_buf_char =
-          static_cast<char*>(noncontiguous_buf) + block_indices_[i+1]*old_type_->get_extent();
-      else
-        noncontiguous_buf_char += block_lengths_[i]*old_type_->get_extent();
-    }
-    noncontiguous_buf=static_cast<void*>(noncontiguous_buf_char);
+Type_Hindexed::Type_Hindexed(int size, MPI_Aint lb, MPI_Aint ub, int flags, int count, int* block_lengths,
+                             MPI_Aint* block_indices, MPI_Datatype old_type)
+    : Datatype(size, lb, ub, flags), block_count_(count), old_type_(old_type)
+{
+  old_type_->ref();
+  block_lengths_ = new int[count];
+  block_indices_ = new MPI_Aint[count];
+  for (int i = 0; i < count; i++) {
+    block_lengths_[i] = block_lengths[i];
+    block_indices_[i] = block_indices[i];

   }
 }
 
   }
 }
 

-Type_Hindexed::Type_Hindexed(int size,MPI_Aint lb, MPI_Aint ub, int flags, int count, int* block_lengths, MPI_Aint* block_indices, MPI_Datatype old_type)
-: Datatype(size, lb, ub, flags), block_count_(count), old_type_(old_type)
+Type_Hindexed::Type_Hindexed(int size, MPI_Aint lb, MPI_Aint ub, int flags, int count, int* block_lengths,
+                             int* block_indices, MPI_Datatype old_type, MPI_Aint factor)
+    : Datatype(size, lb, ub, flags), block_count_(count), old_type_(old_type)

 {
   old_type_->ref();
   block_lengths_ = new int[count];
   block_indices_ = new MPI_Aint[count];
   for (int i = 0; i < count; i++) {
 {
   old_type_->ref();
   block_lengths_ = new int[count];
   block_indices_ = new MPI_Aint[count];
   for (int i = 0; i < count; i++) {

-    block_lengths_[i]=block_lengths[i];
-    block_indices_[i]=block_indices[i];
+    block_lengths_[i] = block_lengths[i];
+    block_indices_[i] = block_indices[i] * factor;

   }
 }
 
   }
 }
 

-    Type_Hindexed::~Type_Hindexed(){
+Type_Hindexed::~Type_Hindexed()
+{

   Datatype::unref(old_type_);
   if(refcount()==0){
     delete[] block_lengths_;
   Datatype::unref(old_type_);
   if(refcount()==0){
     delete[] block_lengths_;


@@ -265,6 +168,12 @@ void Type_Hindexed::unserialize( void* contiguous_buf, void *noncontiguous_buf,
   }
 }
 
   }
 }
 

+Type_Indexed::Type_Indexed(int size, MPI_Aint lb, MPI_Aint ub, int flags, int count, int* block_lengths,
+                           int* block_indices, MPI_Datatype old_type)
+    : Type_Hindexed(size, lb, ub, flags, count, block_lengths, block_indices, old_type, old_type->get_extent())
+{
+}
+

 Type_Struct::Type_Struct(int size,MPI_Aint lb, MPI_Aint ub, int flags, int count, int* block_lengths, MPI_Aint* block_indices, MPI_Datatype* old_types): Datatype(size, lb, ub, flags), block_count_(count), block_lengths_(block_lengths), block_indices_(block_indices), old_types_(old_types){
   block_lengths_= new int[count];
   block_indices_= new MPI_Aint[count];
 Type_Struct::Type_Struct(int size,MPI_Aint lb, MPI_Aint ub, int flags, int count, int* block_lengths, MPI_Aint* block_indices, MPI_Datatype* old_types): Datatype(size, lb, ub, flags), block_count_(count), block_lengths_(block_lengths), block_indices_(block_indices), old_types_(old_types){
   block_lengths_= new int[count];
   block_indices_= new MPI_Aint[count];