Remove boost serialization and fix the seg fault issue.

CMake/CMakeSetCompilerFlags.cmake

@@ -47,7 +47,7 @@ endmacro()
 ################################################################
 ###             ADD_COMPILER_FLAGS_TO_PROJECT                ###
 ################################################################
-function(addAdditionalFlags project_name)
+function(addAdditionalFlags library_name)
 
     status_lib("additional compiler flags CXX: ${CS_COMPILER_FLAGS_CXX}")
     status_lib("additional compiler flags CXX debug: ${CS_COMPILER_FLAGS_CXX_DEBUG}")
@@ -67,18 +67,18 @@ function(addAdditionalFlags project_name)
 
     # compile options
     foreach(flag IN LISTS CS_COMPILER_FLAGS_CXX)
-        target_compile_options(${project_name} PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:${flag}>")
+        target_compile_options(${library_name} PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:${flag}>")
         if(MSVC)
-            target_compile_options(${project_name} PRIVATE "$<$<COMPILE_LANGUAGE:CUDA>:-Xcompiler=${flag}>")
+            target_compile_options(${library_name} PRIVATE "$<$<COMPILE_LANGUAGE:CUDA>:-Xcompiler=${flag}>")
         endif()
     endforeach()
 
     foreach(flag IN LISTS CS_COMPILER_FLAGS_CXX_DEBUG)
-        target_compile_options(${project_name} PRIVATE "$<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CONFIG:DEBUG>>:${flag}>")
+        target_compile_options(${library_name} PRIVATE "$<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CONFIG:DEBUG>>:${flag}>")
     endforeach()
 
     foreach(flag IN LISTS CS_COMPILER_FLAGS_CXX_RELEASE)
-        target_compile_options(${project_name} PRIVATE "$<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CONFIG:RELEASE>>:${flag}>")
+        target_compile_options(${library_name} PRIVATE "$<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CONFIG:RELEASE>>:${flag}>")
     endforeach()
 
 endfunction()
\ No newline at end of file

CMake/VirtualFluidsMacros.cmake

@@ -80,7 +80,7 @@ endfunction()
 #################################################################################
 function (vf_get_library_test_name library_test_name)
     vf_get_library_name (folder_name)
-    set (${library_test_name} ${library_name}Tests PARENT_SCOPE)
+    set (${library_test_name} ${folder_name}Tests PARENT_SCOPE)
 endfunction()
 
 
@@ -103,11 +103,11 @@ endfunction()
 function(vf_add_library)
 
     set( options )
-    set( oneValueArgs )
-    set( multiValueArgs NAME BUILDTYPE PUBLIC_LINK PRIVATE_LINK FILES FOLDER EXCLUDE)
+    set( oneValueArgs NAME BUILDTYPE)
+    set( multiValueArgs PUBLIC_LINK PRIVATE_LINK FILES FOLDER EXCLUDE)
     cmake_parse_arguments( ARG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} )
 
-    if(${ARG_NAME})
+    if(DEFINED ARG_NAME)
         set(library_name ${ARG_NAME})
     else()
         vf_get_library_name (library_name)

src/gpu/VirtualFluids_GPU/CMakeLists.txt

@@ -12,3 +12,5 @@ linkBoost(COMPONENTS "serialization")
 #SET(TPN_WIN32 "/EHsc")
 #https://stackoverflow.com/questions/6832666/lnk2019-when-including-asio-headers-solution-generated-with-cmake
 #https://stackoverflow.com/questions/27442885/syntax-error-with-stdnumeric-limitsmax
+
+vf_add_tests()

src/gpu/VirtualFluids_GPU/LBM/Simulation.cpp

@@ -40,18 +40,11 @@
 #include "Calculation/ForceCalculations.h"
 #include "Calculation/PorousMedia.h"
 //////////////////////////////////////////////////////////////////////////
-//CUDA
+#include "Restart/RestartObject.h"
+
 #include <cuda_runtime.h>
 #include <helper_functions.h>
 #include <helper_cuda.h>
-////random numbers
-//#include <curand.h>
-//#include <curand_kernel.h>
-//////////////////////////////////////////////////////////////////////////
-#include <boost/foreach.hpp>
-#include <stdio.h>
-#include <vector>
-#include "Restart/RestartPostprocessor.h"
 //////////////////////////////////////////////////////////////////////////
 #include "DataStructureInitializer/GridProvider.h"
 #include "Output/DataWriter.h"
@@ -59,14 +52,11 @@
 #include "PreProcessor/PreProcessorFactory/PreProcessorFactory.h"
 #include "Kernel/Kernel.h"
 
-Simulation::Simulation()
-{
 
-}
 
-Simulation::~Simulation()
+std::string getFileName(const std::string& fname, int step, int myID)
 {
-
+    return std::string(fname + "_Restart_" + UbSystem::toString(myID) + "_" +  UbSystem::toString(step));
 }
 
 
@@ -114,9 +104,7 @@ void Simulation::init(SPtr<Parameter> para, SPtr<GridProvider> gridProvider, std
    else
        para->setStartTurn((unsigned int)0); //100000
 
-   //Restart object
-   restObj = new RestartObject();
-   rest = new RestartPostprocessor(restObj, RestartPostprocessor::TXT);
+   restart_object = std::make_shared<ASCIIRestartObject>();
    //////////////////////////////////////////////////////////////////////////
    output.setName(para->getFName() + StringUtil::toString<int>(para->getMyID()) + ".log");
    if(para->getMyID() == 0) output.setConsoleOut(true);
@@ -264,7 +252,7 @@ void Simulation::init(SPtr<Parameter> para, SPtr<GridProvider> gridProvider, std
    //////////////////////////////////////////////////////////////////////////
    ////allocVeloForForcing(para);
    //output << "new object forceCalulator  " << "\n";
-   //forceCalculator = new ForceCalculations(para.get());
+   //forceCalculator = std::make_shared<ForceCalculations>(para.get());
 
    //////////////////////////////////////////////////////////////////////////
    //output << "define the Grid..." ;
@@ -330,10 +318,10 @@ void Simulation::init(SPtr<Parameter> para, SPtr<GridProvider> gridProvider, std
    if (para->getDoRestart())
    {
 	   output << "Restart...\n...get the Object...\n";
-	   restObj = rest->restart(para->getFName(), para->getTimeDoRestart(), para->getMyID());
-	   output << "...load...\n";
-	   restObj->load(para.get());
-	   //para = rest->restart(para->getTimeDoRestart());
+
+		const auto name = getFileName(para->getFName(), para->getTimeDoRestart(), para->getMyID());
+		restart_object->deserialize(name, para);
+
 	   output << "...copy Memory for Restart...\n";
 	   for (int lev=para->getCoarse(); lev <= para->getFine(); lev++)
 	   {
@@ -523,8 +511,10 @@ void Simulation::run()
                 }
                 
                 output << "Dateien fuer CheckPoint schreiben t=" << t << "...";
-                restObj->safe(para.get());
-                rest->doCheckPoint(para->getFName(), t, para->getMyID());
+
+				const auto name = getFileName(para->getFName(), t, para->getMyID());
+				restart_object->serialize(name, para);
+
                 output << "\n fertig\n";
             }
             //////////////////////////////////////////////////////////////////////////
@@ -1299,11 +1289,6 @@ void Simulation::free()
 	}
 	//////////////////////////////////////////////////////////////////////////
 
-	para->~Parameter();
-	gridProvider->~GridProvider();
-	dataWriter->~DataWriter();
-	comm->~Communicator();
-	for(std::size_t i = 0; i < kernels.size(); i++)
-		kernels.at(i)->~Kernel();
+    delete comm;
 
 }
\ No newline at end of file

src/gpu/VirtualFluids_GPU/LBM/Simulation.h

@@ -20,7 +20,6 @@ class Parameter;
 class GridProvider;
 class PorousMedia;
 class RestartObject;
-class RestartPostprocessor;
 class ForceCalculations;
 class DataWriter;
 class Kernel;
@@ -33,8 +32,6 @@ class TrafficMovementFactory;
 class VIRTUALFLUIDS_GPU_EXPORT Simulation
 {
 public:
-	Simulation();
-	~Simulation();
 	void run();
 	void init(SPtr<Parameter> para, SPtr<GridProvider> gridProvider, std::shared_ptr<DataWriter> dataWriter, std::shared_ptr<CudaMemoryManager> cudaManager);
 	void free();
@@ -73,12 +70,10 @@ protected:
 	std::vector < SPtr< ADKernel>> adKernels;
 	std::shared_ptr<PreProcessor> preProcessor;
 
-	//Restart object
-	RestartObject* restObj;
-	RestartPostprocessor* rest;
+    SPtr<RestartObject> restart_object;
 
 	//Forcing Calculation
-	ForceCalculations* forceCalculator;
+	std::shared_ptr<ForceCalculations> forceCalculator;
 
 	//Porous Media
 	std::vector<std::shared_ptr<PorousMedia>> pm;

src/gpu/VirtualFluids_GPU/Restart/RestartObject.cpp

 #include "RestartObject.h"
+
+#include <fstream>
+
 #include "Parameter/Parameter.h"
 #include "basics/utilities/UbMath.h"
 
-RestartObject::RestartObject()
+void RestartObject::deserialize(const std::string &filename, std::shared_ptr<Parameter> para)
 {
+    for (int j = para->getCoarse(); j <= para->getFine(); j++) {
+        std::vector<real> vec;
+        fs.push_back(vec);
+
+        for (unsigned int i = 0; i < (para->getD3Qxx() * para->getParH(j)->size_Mat_SP); i++) {
+            para->getParH(j)->d0SP.f[0][i] = fs[j][i];
+        }
+    }
+
+    deserialize_internal(filename);
 }
-//////////////////////////////////////////////////////////////////////////
-RestartObject::~RestartObject()
+
+void RestartObject::serialize(const std::string &filename, std::shared_ptr<Parameter> para)
 {
+    if (fs.size() > 0) {
+        clear(para);
+    }
+    for (int j = para->getCoarse(); j <= para->getFine(); j++) {
+        std::vector<real> vec;
+        fs.push_back(vec);
+
+        for (unsigned int i = 0; i < (para->getD3Qxx() * para->getParH(j)->size_Mat_SP); i++) {
+            if (UbMath::isNaN(para->getParH(j)->d0SP.f[0][i])) {
+                fs[j].push_back((real)0.0);
+            } else {
+                fs[j].push_back(para->getParH(j)->d0SP.f[0][i]);
+            }
+        }
+    }
+
+    serialize_internal(filename);
 }
-//////////////////////////////////////////////////////////////////////////
-void RestartObject::load(Parameter* para)
+
+void RestartObject::clear(std::shared_ptr<Parameter> para)
 {
-	for (int j = para->getCoarse(); j <= para->getFine(); j++)
-	{
-		std::vector<real> vec;
-		fs.push_back(vec);
-
-		for (unsigned int i = 0; i < (para->getD3Qxx()*para->getParH(j)->size_Mat_SP); i++)
-		{
-			para->getParH(j)->d0SP.f[0][i] = fs[j][i];
-		}
-	}
+    for (int j = para->getCoarse(); j <= para->getFine(); j++) {
+        fs[j].resize(0);
+    }
+    fs.resize(0);
 }
 //////////////////////////////////////////////////////////////////////////
-void RestartObject::safe(Parameter* para)
+
+void ASCIIRestartObject::serialize_internal(const std::string &filename)
 {
-	if (fs.size() > 0)
-	{
-		clear(para);
-	}
-	for (int j = para->getCoarse(); j <= para->getFine(); j++)
-	{
-		std::vector<real> vec;
-		fs.push_back(vec);
-
-		for (unsigned int i = 0; i < (para->getD3Qxx()*para->getParH(j)->size_Mat_SP); i++)
-		{
-			if (UbMath::isNaN(para->getParH(j)->d0SP.f[0][i]))
-			{
-				fs[j].push_back((real)0.0);
-			}
-			else
-			{
-				fs[j].push_back(para->getParH(j)->d0SP.f[0][i]);
-			}
-		}
-	}
+    std::ofstream stream(filename + ".txt");
+
+    if (!stream) {
+        stream.clear();
+        std::string path = UbSystem::getPathFromString(filename);
+        if (path.size() > 0) {
+            UbSystem::makeDirectory(path);
+            stream.open(filename.c_str());
+        }
+
+        if (!stream)
+            throw UbException(UB_EXARGS, "couldn't open file " + filename);
+    }
+
+    for (std::vector<std::vector<real>>::size_type i = 0; i < fs.size(); i++) {
+        for (std::vector<real>::size_type j = 0; j < fs[i].size(); j++) {
+            stream << fs[i][j] << " ";
+        }
+        stream << "\n";
+    }
+
+    stream.close();
 }
-//////////////////////////////////////////////////////////////////////////
-void RestartObject::clear(Parameter* para)
+
+void ASCIIRestartObject::deserialize_internal(const std::string &filename)
+{
+    std::ifstream stream(filename + ".txt", std::ios_base::in);
+
+    if (!stream.is_open())
+        throw UbException(UB_EXARGS, "couldn't open check point file " + filename);
+
+    std::string line;
+    while (std::getline(stream, line)) {
+        std::vector<real> lineData;
+        std::stringstream lineStream(line);
+
+        real value;
+        while (lineStream >> value) {
+            lineData.push_back(value);
+        }
+        fs.push_back(lineData);
+    }
+
+    stream.close();
+}
+
+void BinaryRestartObject::serialize_internal(const std::string &filename)
 {
-	for (int j = para->getCoarse(); j <= para->getFine(); j++)
-	{
-		fs[j].resize(0);
-	}
-	fs.resize(0);
+    std::ofstream stream(filename + ".bin", std::ios_base::binary);
+
+    if (!stream) {
+        stream.clear();
+        std::string path = UbSystem::getPathFromString(filename);
+        if (path.size() > 0) {
+            UbSystem::makeDirectory(path);
+            stream.open(filename.c_str());
+        }
+
+        if (!stream)
+            throw UbException(UB_EXARGS, "couldn't open file " + filename);
+    }
+
+    // Store size of the outer vector
+    int s1 = fs.size();
+    stream.write(reinterpret_cast<const char *>(&s1), sizeof(s1));
+
+    // Now write each vector one by one
+    for (auto &v : fs) {
+        // Store its size
+        int size = v.size();
+        stream.write(reinterpret_cast<const char *>(&size), sizeof(size));
+
+        // Store its contents
+        stream.write(reinterpret_cast<const char *>(&v[0]), v.size() * sizeof(float));
+    }
+
+    stream.close();
 }
-//////////////////////////////////////////////////////////////////////////
 
+void BinaryRestartObject::deserialize_internal(const std::string &filename)
+{
+    std::ifstream stream(filename + ".bin", std::ios_base::in | std::ifstream::binary);
+
+    if (!stream.is_open())
+        throw UbException(UB_EXARGS, "couldn't open check point file " + filename);
+
+    int size = 0;
+    stream.read(reinterpret_cast<char *>(&size), sizeof(size));
+    fs.resize(size);
+    for (int n = 0; n < size; ++n) {
+        int size2 = 0;
+        stream.read(reinterpret_cast<char *>(&size2), sizeof(size2));
+        real f;
+        for (int k = 0; k < size2; ++k) {
+            stream.read(reinterpret_cast<char *>(&f), sizeof(f));
+            fs[n].push_back(f);
+        }
+    }
+
+    stream.close();
+}

src/gpu/VirtualFluids_GPU/Restart/RestartObject.h

 #ifndef RestartObject_H
 #define RestartObject_H
 
-#include "LBM/LB.h"
-#include "LBM/D3Q27.h"
-#include "Parameter/Parameter.h"
-#include "basics/utilities/UbSystem.h"
-#include "boost/serialization/serialization.hpp"
-#include "boost/serialization/vector.hpp"
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <basics/Core/DataTypes.h>
+
+class Parameter;
 
 class RestartObject
 {
 public:
-   RestartObject();
-   ~RestartObject();
-   void load(Parameter* para);
-   void safe(Parameter* para);
-   void clear(Parameter* para);
-protected:
+    virtual ~RestartObject() = default;
+
+    void deserialize(const std::string &filename, std::shared_ptr<Parameter> para);
+    void serialize(const std::string &filename, std::shared_ptr<Parameter> para);
+
+    std::vector<std::vector<real>> fs;
+
+    virtual void serialize_internal(const std::string &filename)   = 0;
+    virtual void deserialize_internal(const std::string &filename) = 0;
 
 private:
-	//////////////////////////////////////////////////////////////////////////
-	//Restart
-	friend class boost::serialization::access;
-	template<class Archive>
-	void serialize(Archive & ar, const unsigned int version)
-	{
-		ar & fs;
-	}
-	//////////////////////////////////////////////////////////////////////////
-	std::vector< std::vector<real> > fs;
-	//////////////////////////////////////////////////////////////////////////
+    void clear(std::shared_ptr<Parameter> para);
+};
+
 
+class ASCIIRestartObject : public RestartObject
+{
+private:
+    virtual void serialize_internal(const std::string &filename);
+    virtual void deserialize_internal(const std::string &filename);
+};
+
+class BinaryRestartObject : public RestartObject
+{
+private:
+    virtual void serialize_internal(const std::string &filename);
+    virtual void deserialize_internal(const std::string &filename);
 };
 
 #endif

src/gpu/VirtualFluids_GPU/Restart/RestartObjectTests.cpp

+#include <gmock/gmock.h>
+
+#include "RestartObject.h"
+
+
+TEST(RestartObjectTests, saveAndLoad_ascii)
+{
+    std::shared_ptr<RestartObject> sut = std::make_shared<ASCIIRestartObject>();
+
+    sut->fs = std::vector<std::vector<float>> {
+                { 1,2,3 },
+                { 4,5,6 }
+            };
+
+    std::string name {"test_do_check_point"};
+    sut->serialize_internal(name);
+
+
+    std::shared_ptr<RestartObject> obj_read = std::make_shared<ASCIIRestartObject>();
+    obj_read->deserialize_internal(name);
+
+    EXPECT_THAT(sut->fs, ::testing::ContainerEq(obj_read->fs));
+}
+
+
+TEST(RestartObjectTests, saveAndLoad_binary)
+{
+    std::shared_ptr<RestartObject> sut = std::make_shared<BinaryRestartObject>();
+
+    sut->fs = std::vector<std::vector<float>> {
+                { 1,2,3 },
+                { 4,5,6 }
+            };
+
+    std::string name {"test_do_check_point"};
+    sut->serialize_internal(name);
+
+
+    std::shared_ptr<RestartObject> obj_read = std::make_shared<BinaryRestartObject>();
+    obj_read->deserialize_internal(name);
+
+    EXPECT_THAT(sut->fs, ::testing::ContainerEq(obj_read->fs));
+}

src/gpu/VirtualFluids_GPU/Restart/RestartPostprocessor.cpp

-#include "RestartPostprocessor.h"
-#include <boost/archive/binary_oarchive.hpp>
-#include <boost/archive/binary_iarchive.hpp>
-
-#include <boost/archive/text_oarchive.hpp>
-#include <boost/archive/text_iarchive.hpp>
-
-//#include "BoostSerializationClassExportHelper.h"
-
-RestartPostprocessor::RestartPostprocessor(RestartObject *object, ArchiveType type)
-{
-	archiveType = type;
-	obj = object;
-}
-//////////////////////////////////////////////////////////////////////////
-RestartPostprocessor::~RestartPostprocessor()
-{
-}
-//////////////////////////////////////////////////////////////////////////
-void RestartPostprocessor::doCheckPoint( std::string fname, int step, int myID)
-{
-   std::string filename = fname + "_Restart_" + UbSystem::toString(myID) + "_" +  UbSystem::toString(step);
-
-   if (archiveType == TXT)
-   {
-      saveTxtArchive(filename + ".txt");
-   } 
-   else if(archiveType == BINARY)
-   {
-      saveBinArchive(filename + ".bin");
-   }
-}
-//////////////////////////////////////////////////////////////////////////
-RestartObject* RestartPostprocessor::restart( std::string fname, int step, int myID)
-{
-   std::string filename = fname + "_Restart_" + UbSystem::toString(myID) + "_" +  UbSystem::toString(step);
-
-   if (archiveType == TXT)
-   {
-      loadTxtArchive(filename + ".txt");
-   } 
-   else if(archiveType == BINARY)
-   {
-      loadBinArchive(filename + ".bin");
-   }
-
-   return obj;
-}
-//////////////////////////////////////////////////////////////////////////
-void RestartPostprocessor::saveTxtArchive(std::string filename)
-{
-   std::ofstream file(filename.c_str()); 
-   if(!file)
-   { 
-      file.clear(); 
-      std::string path = UbSystem::getPathFromString(filename);
-      if(path.size()>0){ UbSystem::makeDirectory(path); file.open(filename.c_str());}
-      if(!file) throw UbException(UB_EXARGS,"couldn't open file "+filename);
-   }
-   boost::archive::text_oarchive oa(file);
-   oa.register_type<RestartObject>();
-   oa << obj;
-}
-//////////////////////////////////////////////////////////////////////////
-void RestartPostprocessor::loadTxtArchive( std::string filename )
-{
-   std::ifstream file(filename.c_str()); 
-   //if (!file.is_open()) UB_THROW( UbException(UB_EXARGS,"Can not open check point file \"" + filename + "\""));
-   if (!file.is_open()) throw UbException(UB_EXARGS,"couldn't open check point file "+filename);
-   printf("the check point file is open...");
-   boost::archive::text_iarchive ia(file);
-   printf("boost archive is allocated...");
-   ia.register_type<RestartObject>();
-   printf("register type is set...");
-   ia >> obj; 
-   printf("obj is filled...");
-}
-//////////////////////////////////////////////////////////////////////////
-void RestartPostprocessor::saveBinArchive( std::string filename )
-{
-   //impotent for binary archive add std::ios::binary
-   std::ofstream file(filename.c_str(), std::ios::binary); 
-   if(!file)
-   { 
-      file.clear(); 
-      std::string path = UbSystem::getPathFromString(filename);
-      if(path.size()>0){ UbSystem::makeDirectory(path); file.open(filename.c_str());}
-      if(!file) throw UbException(UB_EXARGS,"couldn't open file "+filename);
-   }
-   boost::archive::binary_oarchive oa(file);
-   oa.register_type<RestartObject>();
-   oa << obj;
-}
-//////////////////////////////////////////////////////////////////////////
-void RestartPostprocessor::loadBinArchive( std::string filename )
-{
-   //impotent for binary archive add std::ios::binary
-   std::ifstream file(filename.c_str(), std::ios::binary); 
-   //if (!file.is_open()) UB_THROW( UbException(UB_EXARGS,"Can not open check point file \"" + filename + "\""));
-   boost::archive::binary_iarchive ia(file);
-   ia.register_type<RestartObject>();
-   ia >> obj;
-}
-

src/gpu/VirtualFluids_GPU/Restart/RestartPostprocessor.h

-#ifndef Restarter_H
-#define Restarter_H
-
-#include "LBM/LB.h"
-#include "LBM/D3Q27.h"
-#include "Restart/RestartObject.h"
-#include "basics/utilities/UbSystem.h"
-
-#include <boost/shared_ptr.hpp>
-class RestartPostprocessor;
-typedef boost::shared_ptr<RestartPostprocessor> RestartPostprocessorPtr;
-
-class RestartPostprocessor
-{
-public:
-   enum ArchiveType {TXT, BINARY};
-public:
-   RestartPostprocessor(RestartObject *object, ArchiveType typetype = BINARY);
-   ~RestartPostprocessor();
-   void doCheckPoint( std::string fname, int step, int myID);
-   RestartObject* restart( std::string fname, int step, int myID);
-protected:
-   void saveTxtArchive(std::string filename);
-   void loadTxtArchive(std::string filename);
-   void saveBinArchive(std::string filename);
-   void loadBinArchive(std::string filename);
-private:
-   ArchiveType archiveType;
-   RestartObject *obj;
-};
-
-#endif