Support #1725: Improving pup_stl testing 49/3949/4
authorSamarth Kulshreshtha <smkuls@gmail.com>
Wed, 4 Apr 2018 23:44:35 +0000 (18:44 -0500)
committerRaghavendra K <raghavendra066@gmail.com>
Thu, 4 Apr 2019 19:05:14 +0000 (14:05 -0500)
* The PUP routine for std::vector has different specializations for
vector<bool> and vector<T> where T is an arithmetic type. Adding test
cases for int, bool and float.

Change-Id: I16710bff9c62b69c620411310d31f77f853b07af

examples/charm++/PUP/Makefile
examples/charm++/PUP/STLPUP/HeapObjectSTL.h
examples/charm++/PUP/STLPUP/SimplePUP.C
examples/charm++/PUP/STLPUP/SimplePUP.ci
examples/charm++/PUP/STLPUP/SimplePUP.h

index 9607b63dad5cf24f5ed4b9a0c7f601da7b44fca8..4979d45da0fea17580443841b61e10ce851a7778 100644 (file)
@@ -1,25 +1,44 @@
 -include ../../common.mk
 CHARMC=../../../bin/charmc $(OPTS)
 
-OBJS = SimplePUP.o
+DIRS = \
+  STLPUP \
 
-all: SimplePUP
+TESTDIRS = $(DIRS)
 
-SimplePUP: $(OBJS)
-       $(CHARMC) -language charm++ -o SimplePUP $(OBJS)
+all: SimplePUP $(foreach i,$(DIRS),build-$i)
 
-SimplePUP.decl.h: SimplePUP.ci
-       $(CHARMC)  SimplePUP.ci
+test: test-SimplePUP $(foreach i,$(TESTDIRS),test-$i)
+
+bgtest: bgtest-SimplePUP $(foreach i,$(TESTDIRS),bgtest-$i)
 
-clean:
+clean: $(foreach i,$(DIRS),clean-$i)
        rm -f *.decl.h *.def.h conv-host *.o SimplePUP charmrun
 
+$(foreach i,$(DIRS),build-$i):
+       $(MAKE) -C $(subst build-,,$@) all OPTS='$(OPTS)'
+
+$(foreach i,$(DIRS),test-$i):
+       $(MAKE) -C $(subst test-,,$@) test OPTS='$(OPTS)' TESTOPTS='$(TESTOPTS)'
+
+$(foreach i,$(DIRS),bgtest-$i):
+       $(MAKE) -C $(subst bgtest-,,$@) bgtest OPTS='$(OPTS)' TESTOPTS='$(TESTOPTS)'
+
+$(foreach i,$(DIRS),clean-$i):
+       $(MAKE) -C $(subst clean-,,$@) clean OPTS='$(OPTS)'
+
+SimplePUP: SimplePUP.o
+       $(CHARMC) -language charm++ -o $@ $^
+
+SimplePUP.decl.h: SimplePUP.ci
+       $(CHARMC) $<
+
 SimplePUP.o: SimplePUP.C SimplePUP.h SimpleObject.h SimplePUP.decl.h
-       $(CHARMC) -c SimplePUP.C
+       $(CHARMC) -c $<
 
-test: all
-       $(call run, ./SimplePUP +p4  )
-       $(call run, ./SimplePUP +p4  )
+test-SimplePUP: SimplePUP
+       $(call run, ./SimplePUP +p4)
+       $(call run, ./SimplePUP +p4)
 
-bgtest: all
+bgtest-SimplePUP: SimplePUP
        $(call run, ./SimplePUP +p4 +x2 +y2 +z1)
index e029cd177e3f802348c913fbb43aed47bab7485a..ef7ebe525decb4e281052c3e121c11b39cb317d1 100644 (file)
@@ -1,11 +1,12 @@
 #include <vector>
 #include <pup_stl.h>
-class HeapObject
+template <typename U> class HeapObject
 {
 
  public:
 
   int publicInt;
+  std::vector<U> data;
 
  HeapObject(int param1, bool param2):publicInt(param1), privateBool(param2) {}
 
@@ -17,7 +18,7 @@ class HeapObject
    p|privateBool;
    p|data;
  }
- inline HeapObject &operator=(const HeapObject &indata) {
+ inline HeapObject &operator=(const HeapObject<U> &indata) {
     publicInt=indata.publicInt;
     privateBool=indata.privateBool;
     data=indata.data;
@@ -37,5 +38,4 @@ class HeapObject
 
   // PUP is orthogonal to public vs private member choices
   bool privateBool;
-  std::vector<float> data;
 };
index e7c9923042e4f53b594029edf7d641d13e365241..237265bdf1a48038b86334329105c0ebbc5e7f44 100644 (file)
 /////////////////////////////////////
 
 #include "SimplePUP.h"
+#include "SimplePUP.def.h"
 
-main::main(CkArgMsg *m)
+template <typename U> void execute_example(std::vector<U> &dataToCompare)
 {
- //normal object construction
-  HeapObject exampleObject(20,false);
+  //normal object construction
+  HeapObject<U> exampleObject(20, false);
+  exampleObject.data = dataToCompare;
 
   //normal chare array construction
-  CProxy_SimpleArray simpleProxy= CProxy_SimpleArray::ckNew(30);
+  CProxy_SimpleArray<U> simpleProxy= CProxy_SimpleArray<U>::ckNew(30);
 
   //pass object to remote method invocation on the chare array
-  simpleProxy[29].acceptData(exampleObject);
+  simpleProxy[29].acceptData(exampleObject, dataToCompare);
+}
+
+main::main(CkArgMsg *m)
+{
+    std::vector<float> dataToCompare1{ 10.23, 20.92, 30.71 };
+    execute_example<float>(dataToCompare1);
+
+    std::vector<int> dataToCompare2{ 10, 20, 30 };
+    execute_example<int>(dataToCompare2);
+
+    std::vector<bool> dataToCompare3{ false, false, true};
+    execute_example<bool>(dataToCompare3);
 }
 
-#include "SimplePUP.def.h"
index 8857e20885fb5fe33e0247abad03c4b0b3d845ea..9e5d75e9947bc21fb45e4ea761eb7ebd402d0ded 100644 (file)
 
 mainmodule SimplePUP {
   include "HeapObjectSTL.h";
+  include "vector";
+
   mainchare main {
     entry main(CkArgMsg *m);
   };
 
-  array [1D] SimpleArray{
+  template <class U> array [1D] SimpleArray{
     entry SimpleArray();
-    entry void acceptData(HeapObject &inData);
+    entry void acceptData(const HeapObject<U> &inData, const std::vector<U> &dataToCompare);
   };
 
+  array [1D] SimpleArray<float>;
+  array [1D] SimpleArray<int>;
+  array [1D] SimpleArray<bool>;
 };
index 95735bdbbf2c34efde379499b3498b54412d0c04..d28f9b044b5df07d2c60db7d3c8f24802c139be5 100644 (file)
@@ -10,6 +10,8 @@
 ///////////////////////////////////////
 
 #include "SimplePUP.decl.h"
+#include <vector>
+#include <cassert>
 
 class main : public CBase_main {
 
@@ -21,8 +23,7 @@ public:
 
 };
 
-
-class SimpleArray : public CBase_SimpleArray {
+template <typename U> class SimpleArray : public CBase_SimpleArray<U> {
 
  public:
   
@@ -37,25 +38,36 @@ class SimpleArray : public CBase_SimpleArray {
 
   ~SimpleArray(){}
 
-  void acceptData(HeapObject &inData){
-
+  void acceptData(const HeapObject<U> &inData,
+          const std::vector<U> &dataToCompare){
+    
     //do something to the object
     localCopy=inData;
+
+    assert(inData.data.size() == dataToCompare.size());
+    for (int i = 0; i < dataToCompare.size(); i++)
+    {
+        assert(inData.data[i] == dataToCompare[i]);
+    }
+
     localCopy.doWork();
 
-    if(thisIndex==0) //no one lower to pass to
+    if(this->thisIndex==0) //no one lower to pass to
       {
        done();
       }
     else
       { // pass object down one index
-       thisProxy[thisIndex-1].acceptData(localCopy);
+       this->thisProxy[this->thisIndex-1].acceptData(localCopy, dataToCompare);
       }
   }
 
  private:
 
-  HeapObject localCopy;
+  HeapObject<U> localCopy;
 
 };
 
+#define CK_TEMPLATES_ONLY
+#include "SimplePUP.def.h"
+#undef CK_TEMPLATES_ONLY