Could someone please help me to better understand how to write 
serialization functions for a class using type erasure?  Looking at my 
code, and at the hpx/runtime/serialization/ code, I just can't figure 
out how to handle this.  Even assuming that the boilerplate code is able 
to correctly deal with pointers to a derived class, it appears to me 
that only the serialize function for the base class will be executed by 
the runtime system.

Perhaps I don't understand how the underlying serialization subsystem 
works in HPX, but it would seem to me that there should be *something* 
particular that needs to be done in my code to be able to properly 
handle this situation.  I suspect that this is the latest cause of 
segmentation faults that I'm having on my project...

The classes in question look something like the following.  I think that 
the code is fairly straightforward - the Model class is essentially a 
wrapper for a variety of concrete model types: first an object of 
concrete model type is created and then passed to 
Model::Construct(Model_Type) which returns a Model wrapper object.  This 
Model type is required as a parameter for some of my Components -- as 
such, these classes all need to support serialization.

class Model{


     std::unique_ptr<detail::Model_Base> impl_;


    Model(std::unique_ptr<detail::Model_Base>&& model_ptr ) : 
    Model() = default;
    Model(Model&& other) = default;
    Model(Model const& other) : impl(other.impl_->Clone()){}

    template <typename Model_Type>
    static Model Construct(Model_Type const& model){

         std::unique_ptr<detail::Model_Base> model_impl_ =
         Model model_{std::move(model_impl_)};
         return model_;

/* ... */


     friend class hpx::serialization::access;

     template <typename Archive>
     void serialize(Archive& ar, const unsigned int version){ ar & impl_; }


namespace detail{

struct Model_Base {

  virtual Matrix Model(Matrix const &inputdata, vector<Matrix> parameters);

/* ... */

virtual fx::modeling::detail::Model_Base *Clone();

   friend class hpx::serialization::access;

   template <typename Archive>
   void serialize(Archive& ar, const unsigned int version){}


template <typename Model_Type> struct Model_Impl : public Model_Base {
   using model_type = Model_Type;
   Model_Impl(Model_Type model) : model_(model) {}
   Model_Impl(Model_Impl const &other) : model_(other.model_) {}
   Model_Impl(Model_Impl &&other) = default;

   Matrix Evaluate_Model(Matrix const &inputdata, vector<Matrix> 
parameters) override;

   /* ... */
   virtual fx::modeling::detail::Model_Base *Clone() override;

   Model_Type model_;

   friend class hpx::serialization::access;

   template <typename Archive>
   void serialize(Archive& ar, const unsigned int version){ ar & model_; }


As usual, I greatly appreciate any help that you can offer.

Just a final note -- as this is for a personal project, I have 
flexibility in changing things fairly broadly.  If the above approach is 
wrong or problematic, I would also appreciate any suggestions on how to 
better handle this.

Thanks and regards,


hpx-users mailing list

Reply via email to