main_ser.cpp

 
#include "Vector/vector_dist.hpp"
 
 
struct my_struct
{
    size_t size;
 
    char * ptr;
 
    std::string str;
 
    openfpm::vector<int> v;
 
 
public:
 
    static bool pack()  {return true;}
 
 
 
    my_struct()
    {
        size = 0;
        ptr = NULL;
    }
 
    my_struct(const my_struct & my)
    {
        this->operator=(my);
    }
 
    my_struct(my_struct && my)
    {
        this->operator=(my);
    }
 
    ~my_struct()
    {
        if (ptr != NULL)
            delete [] ptr;
    }
 
    // we copy pointer and we do double delete
    my_struct & operator=(const my_struct & my)
    {
        size = my.size;
        str = my.str;
        v = my.v;
 
        ptr = new char[size];
        memcpy(ptr,my.ptr,32);
 
        return *this;
    }
 
    // we copy pointer and we do double delete
    my_struct & operator=(my_struct && my)
    {
        size = my.size;
        my.size = 0;
        str.swap(my.str);
        v.swap(my.v);
        ptr = my.ptr;
        my.ptr = 0;
 
        return *this;
    }
 
 
 
    template<int ... prp> inline void packRequest(size_t & req) const
    {
        req += 2*sizeof(size_t) + size + str.size()+1;
        v.packRequest(req);
    }
 
 
 
    static bool noPointers()
    {
        return false;
    }
 
 
 
    template<typename Memory, int ... prp> inline void pack(ExtPreAlloc<Memory> & mem, Pack_stat & sts) const
    {
 
        //Serialize the number that determine the C-string size
        Packer<size_t, Memory>::pack(mem,size,sts);
 
 
 
        // Allocate and copy the string
        mem.allocate(size);
        void * t_ptr = mem.getPointer();
        memcpy(t_ptr,ptr,size);
 
 
 
        //Serialize the number that determine the C++-string str.size()+1 given by the null terminator
        Packer<size_t, Memory>::pack(mem,str.size()+1,sts);
 
        // Allocate and copy the string
        mem.allocate(str.size()+1);
        char * t_ptr2 = (char *)mem.getPointer();
        memcpy(t_ptr2,str.c_str(),str.size());
 
        // Add null terminator
        t_ptr2[str.size()] = 0;
 
        Packer<decltype(v), Memory>::pack(mem,v,sts);
 
    }
 
 
 
    template<typename Memory, int ... prp> inline void unpack(ExtPreAlloc<Memory> & mem, Unpack_stat & ps)
    {
 
        // unpack the size of the C string
        Unpacker<size_t, Memory>::unpack(mem,size,ps);
 
 
 
        // Allocate the C string
        ptr = new char[size];
 
        // source pointer
        char * ptr_src = (char *)mem.getPointerOffset(ps.getOffset());
 
        // copy from the buffer to the destination
        memcpy(ptr,ptr_src,size);
 
        // update the pointer
        ps.addOffset(size);
 
 
 
        // get the the C++ string size
        size_t cpp_size;
        Unpacker<size_t, Memory>::unpack(mem,cpp_size,ps);
 
        // Create the string from the serialized data (de-serialize)
        char * ptr_src2 = (char *)mem.getPointerOffset(ps.getOffset());
        str = std::string(ptr_src2);
        ps.addOffset(cpp_size);
 
        // Unpack the vector
        Unpacker<decltype(v), Memory>::unpack(mem,v,ps);
 
    }
 
 
 
};
 
 
int main(int argc, char* argv[])
{
    // initialize the library
    openfpm_init(&argc,&argv);
 
    // Here we define our domain a 2D box with internals from 0 to 1.0 for x and y
    Box<2,float> domain({0.0,0.0},{1.0,1.0});
 
    // Here we define the boundary conditions of our problem
    size_t bc[2]={PERIODIC,PERIODIC};
 
    // extended boundary around the domain, and the processor domain
    Ghost<2,float> g(0.01);
 
    // my_struct at position 0 in the aggregate
    constexpr int my_s1 = 0;
 
    // my_struct at position 1 in the aggregate
    constexpr int my_s2 = 1;
 
 
    vector_dist<2,float, aggregate<my_struct,my_struct>>
    vd(4096,domain,bc,g);
 
    std::cout << "HAS PACK: " << has_pack_agg<aggregate<my_struct,my_struct>>::result::value << std::endl;
 
 
 
    auto it = vd.getDomainIterator();
 
    while (it.isNext())
    {
        auto p = it.get();
 
        // we define x, assign a random position between 0.0 and 1.0
        vd.getPos(p)[0] = (float)rand() / RAND_MAX;
 
        // we define y, assign a random position between 0.0 and 1.0
        vd.getPos(p)[1] = (float)rand() / RAND_MAX;
 
        // Get the particle position as point
        Point<2,float> pt = vd.getPos(p);
 
        // create a C string from the particle coordinates
        // and copy into my struct
        vd.getProp<my_s1>(p).size = 32;
        vd.getProp<my_s1>(p).ptr = new char[32];
        strcpy(vd.getProp<my_s1>(p).ptr,pt.toString().c_str());
 
        // create a C++ string from the particle coordinates
        vd.getProp<my_s1>(p).str = std::string(pt.toString());
 
        vd.getProp<my_s1>(p).v.add(1);
        vd.getProp<my_s1>(p).v.add(2);
        vd.getProp<my_s1>(p).v.add(3);
 
        pt = pt * 2.0;
 
        // create a C string from the particle coordinates multiplied by 2.0
        // and copy into my struct
        vd.getProp<my_s2>(p).size = 32;
        vd.getProp<my_s2>(p).ptr = new char[32];
        strcpy(vd.getProp<my_s2>(p).ptr,pt.toString().c_str());
 
        // create a C++ string from the particle coordinates
        vd.getProp<my_s2>(p).str = std::string(pt.toString());
 
        vd.getProp<my_s2>(p).v.add(1);
        vd.getProp<my_s2>(p).v.add(2);
        vd.getProp<my_s2>(p).v.add(3);
        vd.getProp<my_s2>(p).v.add(4);
 
        // next particle
        ++it;
    }
 
 
 
    // Particles are redistribued across the processors
    vd.map();
 
    // Synchronize the ghost
    vd.ghost_get<my_s1,my_s2>();
 
 
 
    vd.write("particles");
 
 
 
    size_t fg = vd.size_local();
 
    Vcluster<> & v_cl = create_vcluster();
 
    // Only the master processor print
    if (v_cl.getProcessUnitID() == 0)
    {
        // Print 4 particles
        for ( ; fg < vd.size_local()+4 ; fg++)
        {
            // Print my struct1 information
            std::cout << "my_struct1:" << std::endl;
            std::cout << "C-string: " << vd.getProp<my_s1>(fg).ptr << std::endl;
            std::cout << "Cpp-string: " << vd.getProp<my_s1>(fg).str << std::endl;
 
            for (size_t i = 0 ; i < vd.getProp<my_s1>(fg).v.size() ; i++)
                std::cout << "Element: " << i << "   " << vd.getProp<my_s1>(fg).v.get(i) << std::endl;
 
            // Print my struct 2 information
            std::cout << "my_struct2" << std::endl;
            std::cout << "C-string: " << vd.getProp<my_s2>(fg).ptr << std::endl;
            std::cout << "Cpp-string: " << vd.getProp<my_s2>(fg).str << std::endl;
 
            for (size_t i = 0 ; i < vd.getProp<my_s2>(fg).v.size() ; i++)
                std::cout << "Element: " << i << "   " << vd.getProp<my_s2>(fg).v.get(i) << std::endl;
        }
    }
 
 
 
    openfpm_finalize();
 
 
}