Packing class. More...

Detailed Description

template<typename T, typename Mem, int pack_type>
class Packer< T, Mem, pack_type >

Packing class.

This class pack objects primitives vectors and grids, the general usage is to create a vector of packing request (std::vector<size_t>) that contain the size of the required space needed to pack the information. Calculate the total size, allocating it on HeapMemory (for example), Create an ExtPreAlloc memory object giving the preallocated memory to it and finally Pack all the objects subsequently

In order to unpack the information the Unpacker class can be used

See also: Unpacker

 
    typedef Point_test<float> pt;
 
    // Create all the objects we want to pack
    unsigned char uc = 1;
    char c = 2;
    short s = 3;
    unsigned short us = 4;
    int i = 5;
    unsigned int ui = 6;
    long int li = 7;
    unsigned long int uli = 8;
    float f = 9;
    double d = 10;
 
    openfpm::vector<Point_test<float>> v = allocate_openfpm<openfpm::vector<Point_test<float>>>(1024);
 
    Point_test<float> p;
    p.fill();
 
    size_t sz[] = {16,16,16};
    grid_cpu<3,Point_test<float>> g(sz);
    g.setMemory();
    fill_grid<3>(g);
 
    grid_key_dx_iterator_sub<3> sub(g.getGrid(),{1,2,3},{5,6,7});
 
    // Here we start to push all the allocations required to pack all the data
 
    //std::vector<size_t> pap_prp;
 
    size_t size_total = 0;
    size_t size_total_old = 0;
 
    Packer<unsigned char,HeapMemory>::packRequest(uc,size_total);
    BOOST_REQUIRE_EQUAL(size_total,sizeof(unsigned char));
    size_total_old = size_total;
 
    Packer<char,HeapMemory>::packRequest(c,size_total);
    BOOST_REQUIRE_EQUAL(size_total - size_total_old,sizeof(char));
    size_total_old = size_total;
 
    Packer<short,HeapMemory>::packRequest(s,size_total);
    BOOST_REQUIRE_EQUAL(size_total - size_total_old,sizeof(short));
    size_total_old = size_total;
 
    Packer<unsigned short,HeapMemory>::packRequest(us,size_total);
    BOOST_REQUIRE_EQUAL(size_total - size_total_old,sizeof(unsigned short));
    size_total_old = size_total;
 
    Packer<int,HeapMemory>::packRequest(i,size_total);
    BOOST_REQUIRE_EQUAL(size_total - size_total_old,sizeof(int));
    size_total_old = size_total;
 
    Packer<unsigned int,HeapMemory>::packRequest(ui,size_total);
    BOOST_REQUIRE_EQUAL(size_total - size_total_old,sizeof(unsigned int));
    size_total_old = size_total;
 
    Packer<long int,HeapMemory>::packRequest(li,size_total);
    BOOST_REQUIRE_EQUAL(size_total - size_total_old,sizeof(long int));
    size_total_old = size_total;
 
    Packer<long unsigned int,HeapMemory>::packRequest(uli,size_total);
    BOOST_REQUIRE_EQUAL(size_total - size_total_old,sizeof(long unsigned int));
    size_total_old = size_total;
 
    Packer<float,HeapMemory>::packRequest(f,size_total);
    BOOST_REQUIRE_EQUAL(size_total - size_total_old,sizeof(float));
    size_total_old = size_total;
 
    Packer<double,HeapMemory>::packRequest(d,size_total);
    BOOST_REQUIRE_EQUAL(size_total - size_total_old,sizeof(double));
    size_total_old = size_total;
 
    Packer<Point_test<float>,HeapMemory>::packRequest(p,size_total);
 
#ifndef SE_CLASS3
    BOOST_REQUIRE_EQUAL(size_total - size_total_old,(sizeof(float)*4 + sizeof(float[3]) + sizeof(float[3][3])));
#endif
    size_total_old = size_total;
 
    Packer<openfpm::vector<Point_test<float>>,HeapMemory>::packRequest<pt::x,pt::v>(v,size_total);
#ifndef SE_CLASS3
    BOOST_REQUIRE_EQUAL(size_total - size_total_old,(sizeof(float) + sizeof(float[3])) * v.size() + sizeof(v.size()));
#endif
    size_total_old = size_total;
 
    Packer<grid_cpu<3,Point_test<float>>,HeapMemory>::packRequest<decltype(sub),pt::x,pt::v>(g,sub,size_total);
#ifndef SE_CLASS3
    BOOST_REQUIRE_EQUAL(size_total - size_total_old,(sizeof(float) + sizeof(float[3])) * sub.getVolume());
#endif
    // Calculate how much preallocated memory we need to pack all the objects
    //size_t req = ExtPreAlloc<HeapMemory>::calculateMem(pap_prp);
 
    // allocate the memory
    HeapMemory pmem;
    pmem.allocate(size_total);
    ExtPreAlloc<HeapMemory> & mem = *(new ExtPreAlloc<HeapMemory>(size_total,pmem));
    mem.incRef();
 
    Pack_stat sts;
 
    // try to pack
    Packer<unsigned char,HeapMemory>::pack(mem,1,sts);
    Packer<char,HeapMemory>::pack(mem,2,sts);
    Packer<short,HeapMemory>::pack(mem,3,sts);
    Packer<unsigned short,HeapMemory>::pack(mem,4,sts);
    Packer<int,HeapMemory>::pack(mem,5,sts);
    Packer<unsigned int, HeapMemory>::pack(mem,6,sts);
    Packer<long int,HeapMemory>::pack(mem,7,sts);
    Packer<long unsigned int,HeapMemory>::pack(mem,8,sts);
    Packer<float,HeapMemory>::pack(mem,9,sts);
    Packer<double,HeapMemory>::pack(mem,10,sts);
    Packer<Point_test<float>,HeapMemory>::pack(mem,p,sts);
    Packer<openfpm::vector<Point_test<float>>,HeapMemory>::pack<pt::x,pt::v>(mem,v,sts);
    Packer<grid_cpu<3,Point_test<float>>,HeapMemory>::pack<decltype(sub),pt::x,pt::v>(mem,g,sub,sts);
 

Template Parameters

T	object type to pack
Mem	Memory origin HeapMemory CudaMemory ...
Implementation	of the packer (the Pack_selector choose the correct one)

Definition at line 49 of file Packer.hpp.

#include <Packer.hpp>

Static Public Member Functions
static void	pack (ExtPreAlloc< Mem >, const T &obj)
	Error, no implementation.

static size_t	packRequest (const T &obj, size_t &req)
	Error, no implementation.

Member Function Documentation

◆ pack()

template<typename T , typename Mem , int pack_type>

static void Packer< T, Mem, pack_type >::pack	(	ExtPreAlloc< Mem >	,
		const T &	obj
	)

inlinestatic

Error, no implementation.

Definition at line 56 of file Packer.hpp.

◆ packRequest()