add array serialization tests, fix bugs (#1319)

fix error in non-instantiated template

Author: leekillough

src/sst/core/serialization/impl/serialize_array.h

@@ -97,10 +97,7 @@ struct serialize_impl_fixed_array
         case serializer::UNPACK:
             if constexpr ( std::is_pointer_v<OBJ_TYPE> ) {
                 // for pointers to fixed arrays, we allocate the storage
-                if constexpr ( std::is_same_v<OBJ_TYPE, ELEM_T(*)[SIZE]> )
-                    ary = new ELEM_T[SIZE];
-                else
-                    ary = new std::remove_pointer_t<OBJ_TYPE>;
+                ary = reinterpret_cast<OBJ_TYPE>(new std::remove_pointer_t<OBJ_TYPE>);
             }
             [[fallthrough]];
 

src/sst/core/serialization/serializer.h

@@ -131,7 +131,7 @@ class serializer
         switch ( mode_ ) {
         case SIZER:
             sizer_.add(sizeof(SIZE_T));
-            sizer_.add(size);
+            sizer_.add(size * sizeof(ELEM_T));
             break;
         case PACK:
             if ( buffer ) {

src/sst/core/testElements/coreTest_Serialization.cc

@@ -40,8 +40,8 @@ namespace SST::CoreTestSerialization {
 using SST::Core::Serialization::get_size;
 
 template <typename T>
-static void
-serializeDeserialize(T& input, T& output, bool with_tracking = false)
+void
+serializeDeserialize(T&& input, T&& output, bool with_tracking = false)
 {
     // Set up serializer and buffers
     char*                                buffer;
@@ -220,6 +220,57 @@ checkContainerSerializeDeserialize(T*& data)
     return true;
 };
 
+// Arrays
+
+template <typename>
+constexpr size_t array_size = 0;
+
+template <typename T, size_t S>
+constexpr size_t array_size<T[S]> = S;
+
+template <typename T, size_t S>
+constexpr size_t array_size<std::array<T, S>> = S;
+
+template <typename T>
+bool
+checkFixedArraySerializeDeserialize(T& data)
+{
+    T result;
+    serializeDeserialize(data, result);
+
+    for ( size_t i = 0; i < array_size<std::remove_pointer_t<T>>; ++i ) {
+        if constexpr ( std::is_pointer_v<T> ) {
+            if ( (*data)[i] != (*result)[i] ) return false;
+        }
+        else {
+            if ( data[i] != result[i] ) return false;
+        }
+    }
+    if constexpr ( std::is_pointer_v<T> ) delete[] result;
+    return true;
+};
+
+template <typename T>
+bool
+checkArraySerializeDeserialize(T* data, size_t dataSize)
+{
+    using SST::Core::Serialization::array;
+
+    T*     result     = nullptr;
+    size_t resultSize = ~size_t {};
+
+    serializeDeserialize(array(data, dataSize), array(result, resultSize));
+
+    if ( resultSize != dataSize ) return false;
+
+    for ( size_t i = 0; i < dataSize; ++i ) {
+        if ( data[i] != result[i] ) return false;
+    }
+
+    delete[] result;
+
+    return true;
+};
 
 // For ordered but non-iterable contaienrs
 template <typename T>
@@ -558,6 +609,47 @@ coreTestSerialization::coreTestSerialization(ComponentId_t id, Params& params) :
         checkSimpleSerializeDeserialize<double*>::check_all(rng->nextUniform() * 1000000, out, "double*");
         checkSimpleSerializeDeserialize<std::string*>::check_all("test_string", out, "std::string*");
     }
+    else if ( test == "array" ) {
+        {
+            int32_t array_in[10];
+            for ( size_t i = 0; i < 10; ++i )
+                array_in[i] = rng->generateNextInt32();
+            passed = checkFixedArraySerializeDeserialize(array_in);
+            if ( !passed ) out.output("ERROR: int32_t[10] did not serialize/deserialize properly\n");
+        }
+        {
+            std::array<int32_t, 10> array_in;
+            for ( size_t i = 0; i < 10; ++i )
+                array_in[i] = rng->generateNextInt32();
+            passed = checkFixedArraySerializeDeserialize(array_in);
+            if ( !passed ) out.output("ERROR: std::array<int32_t, 10> did not serialize/deserialize properly\n");
+        }
+        {
+            int32_t(*array_in)[10] = reinterpret_cast<int32_t(*)[10]>(new int32_t[10]);
+            for ( size_t i = 0; i < 10; ++i )
+                (*array_in)[i] = rng->generateNextInt32();
+            passed = checkFixedArraySerializeDeserialize(array_in);
+            if ( !passed ) out.output("ERROR: int32_t[10] did not serialize/deserialize properly\n");
+            delete[] array_in;
+        }
+        {
+            std::array<int32_t, 10>* array_in = new std::array<int32_t, 10>;
+            for ( size_t i = 0; i < 10; ++i )
+                (*array_in)[i] = rng->generateNextInt32();
+            passed = checkFixedArraySerializeDeserialize(array_in);
+            if ( !passed ) out.output("ERROR: std::array<int32_t, 10> did not serialize/deserialize properly\n");
+            delete array_in;
+        }
+        {
+            size_t   size     = 100;
+            int32_t* array_in = new int32_t[size];
+            for ( size_t i = 0; i < size; ++i )
+                array_in[i] = rng->generateNextInt32();
+            passed = checkArraySerializeDeserialize(array_in, size);
+            if ( !passed ) out.output("ERROR: std::array<int32_t, %zu> did not serialize/deserialize properly\n", size);
+            delete[] array_in;
+        }
+    }
     else if ( test == "ordered_containers" ) {
         // Ordered Containers
         // map, set, vector, vector<bool>, list, deque

tests/testsuite_default_Serialization.py

@@ -36,6 +36,9 @@ def test_Serialization_pod(self):
     def test_Serialization_pod_ptr(self):
         self.serialization_test_template("pod_ptr")
 
+    def test_Serialization_array(self):
+        self.serialization_test_template("array")
+
     def test_Serialization_ordered_containers(self):
         self.serialization_test_template("ordered_containers")
 
@@ -82,4 +85,3 @@ def serialization_test_template(self, testtype, default_reffile = True):
         filter1 = StartsWithFilter("WARNING: No components are")
         cmp_result = testing_compare_filtered_diff("serialization", outfile, reffile, True, [filter1])
         self.assertTrue(cmp_result, "Output/Compare file {0} does not match Reference File {1}".format(outfile, reffile))
-