1/*
2 * Packer_unit_tests.hpp
3 *
4 * Created on: Jul 15, 2015
5 * Author: Pietro Incardona
6 */
7
8#ifndef SRC_PACKER_UNIT_TESTS_HPP_
9#define SRC_PACKER_UNIT_TESTS_HPP_
10
11#include "Pack_selector.hpp"
12#include "Packer.hpp"
13#include "Unpacker.hpp"
14#include "Grid/grid_util_test.hpp"
15#include <iostream>
16#include "Vector/vector_test_util.hpp"
17#include "data_type/aggregate.hpp"
18
19BOOST_AUTO_TEST_SUITE( packer_unpacker )
20
21BOOST_AUTO_TEST_CASE ( packer_unpacker_test )
22{
23 //! [Pack selector usage]
24
25 int val = Pack_selector<unsigned char>::value;
26 BOOST_REQUIRE_EQUAL(val,PACKER_PRIMITIVE);
27 val = Pack_selector<char>::value;
28 BOOST_REQUIRE_EQUAL(val,PACKER_PRIMITIVE);
29 val = Pack_selector<short>::value;
30 BOOST_REQUIRE_EQUAL(val,PACKER_PRIMITIVE);
31 val = Pack_selector<unsigned short>::value;
32 BOOST_REQUIRE_EQUAL(val,PACKER_PRIMITIVE);
33 val = Pack_selector<int>::value;
34 BOOST_REQUIRE_EQUAL(val,PACKER_PRIMITIVE);
35 val = Pack_selector<unsigned int>::value;
36 BOOST_REQUIRE_EQUAL(val,PACKER_PRIMITIVE);
37 val = Pack_selector<long int>::value;
38 BOOST_REQUIRE_EQUAL(val,PACKER_PRIMITIVE);
39 val = Pack_selector<unsigned long int>::value;
40 BOOST_REQUIRE_EQUAL(val,PACKER_PRIMITIVE);
41 val = Pack_selector<float>::value;
42 BOOST_REQUIRE_EQUAL(val,PACKER_PRIMITIVE);
43 val = Pack_selector<double>::value;
44 BOOST_REQUIRE_EQUAL(val,PACKER_PRIMITIVE);
45
46 val = Pack_selector<Point_test<float>>::value;
47 BOOST_REQUIRE_EQUAL(val,PACKER_OBJECTS_WITH_POINTER_CHECK);
48
49
50 val = Pack_selector< openfpm::vector<Point_test<float>> >::value;
51 BOOST_REQUIRE_EQUAL(val,PACKER_GENERAL);
52 val = Pack_selector< grid_cpu<3,Point_test<float>> >::value;
53 BOOST_REQUIRE_EQUAL(val,PACKER_GRID);
54 val = Pack_selector< encapc<3,Point_test<float>, memory_traits_lin<Point_test<float>>::type > >::value;
55 BOOST_REQUIRE_EQUAL(val,PACKER_ENCAP_OBJECTS);
56
57 struct test_s
58 {
59 float a;
60 float b;
61
62 static bool noPointers() {return true;}
63 };
64
65 val = Pack_selector< test_s >::value;
66 BOOST_REQUIRE_EQUAL(val,PACKER_OBJECTS_WITH_POINTER_CHECK);
67
68 //! [Pack selector usage]
69
70 {
71
72 //! [Pack into a message primitives objects vectors and grids]
73
74 typedef Point_test<float> pt;
75
76 // Create all the objects we want to pack
77 unsigned char uc = 1;
78 char c = 2;
79 short s = 3;
80 unsigned short us = 4;
81 int i = 5;
82 unsigned int ui = 6;
83 long int li = 7;
84 unsigned long int uli = 8;
85 float f = 9;
86 double d = 10;
87
88 openfpm::vector<Point_test<float>> v = allocate_openfpm<openfpm::vector<Point_test<float>>>(1024);
89
90 Point_test<float> p;
91 p.fill();
92
93 size_t sz[] = {16,16,16};
94 grid_cpu<3,Point_test<float>> g(sz);
95 g.setMemory();
96 fill_grid<3>(g);
97
98 grid_key_dx_iterator_sub<3> sub(g.getGrid(),{1,2,3},{5,6,7});
99
100 // Here we start to push all the allocations required to pack all the data
101
102 //std::vector<size_t> pap_prp;
103
104 size_t size_total = 0;
105 size_t size_total_old = 0;
106
107 Packer<unsigned char,HeapMemory>::packRequest(uc,size_total);
108 BOOST_REQUIRE_EQUAL(size_total,sizeof(unsigned char));
109 size_total_old = size_total;
110
111 Packer<char,HeapMemory>::packRequest(c,size_total);
112 BOOST_REQUIRE_EQUAL(size_total - size_total_old,sizeof(char));
113 size_total_old = size_total;
114
115 Packer<short,HeapMemory>::packRequest(s,size_total);
116 BOOST_REQUIRE_EQUAL(size_total - size_total_old,sizeof(short));
117 size_total_old = size_total;
118
119 Packer<unsigned short,HeapMemory>::packRequest(us,size_total);
120 BOOST_REQUIRE_EQUAL(size_total - size_total_old,sizeof(unsigned short));
121 size_total_old = size_total;
122
123 Packer<int,HeapMemory>::packRequest(i,size_total);
124 BOOST_REQUIRE_EQUAL(size_total - size_total_old,sizeof(int));
125 size_total_old = size_total;
126
127 Packer<unsigned int,HeapMemory>::packRequest(ui,size_total);
128 BOOST_REQUIRE_EQUAL(size_total - size_total_old,sizeof(unsigned int));
129 size_total_old = size_total;
130
131 Packer<long int,HeapMemory>::packRequest(li,size_total);
132 BOOST_REQUIRE_EQUAL(size_total - size_total_old,sizeof(long int));
133 size_total_old = size_total;
134
135 Packer<long unsigned int,HeapMemory>::packRequest(uli,size_total);
136 BOOST_REQUIRE_EQUAL(size_total - size_total_old,sizeof(long unsigned int));
137 size_total_old = size_total;
138
139 Packer<float,HeapMemory>::packRequest(f,size_total);
140 BOOST_REQUIRE_EQUAL(size_total - size_total_old,sizeof(float));
141 size_total_old = size_total;
142
143 Packer<double,HeapMemory>::packRequest(d,size_total);
144 BOOST_REQUIRE_EQUAL(size_total - size_total_old,sizeof(double));
145 size_total_old = size_total;
146
147 Packer<Point_test<float>,HeapMemory>::packRequest(p,size_total);
148
149#ifndef SE_CLASS3
150 BOOST_REQUIRE_EQUAL(size_total - size_total_old,(sizeof(float)*4 + sizeof(float[3]) + sizeof(float[3][3])));
151#endif
152 size_total_old = size_total;
153
154 Packer<openfpm::vector<Point_test<float>>,HeapMemory>::packRequest<pt::x,pt::v>(v,size_total);
155#ifndef SE_CLASS3
156 BOOST_REQUIRE_EQUAL(size_total - size_total_old,(sizeof(float) + sizeof(float[3])) * v.size() + sizeof(v.size()));
157#endif
158 size_total_old = size_total;
159
160 Packer<grid_cpu<3,Point_test<float>>,HeapMemory>::packRequest<decltype(sub),pt::x,pt::v>(g,sub,size_total);
161#ifndef SE_CLASS3
162 BOOST_REQUIRE_EQUAL(size_total - size_total_old,(sizeof(float) + sizeof(float[3])) * sub.getVolume());
163#endif
164 // Calculate how much preallocated memory we need to pack all the objects
165 //size_t req = ExtPreAlloc<HeapMemory>::calculateMem(pap_prp);
166
167 // allocate the memory
168 HeapMemory pmem;
169 pmem.allocate(size_total);
170 ExtPreAlloc<HeapMemory> & mem = *(new ExtPreAlloc<HeapMemory>(size_total,pmem));
171 mem.incRef();
172
173 Pack_stat sts;
174
175 // try to pack
176 Packer<unsigned char,HeapMemory>::pack(mem,1,sts);
177 Packer<char,HeapMemory>::pack(mem,2,sts);
178 Packer<short,HeapMemory>::pack(mem,3,sts);
179 Packer<unsigned short,HeapMemory>::pack(mem,4,sts);
180 Packer<int,HeapMemory>::pack(mem,5,sts);
181 Packer<unsigned int, HeapMemory>::pack(mem,6,sts);
182 Packer<long int,HeapMemory>::pack(mem,7,sts);
183 Packer<long unsigned int,HeapMemory>::pack(mem,8,sts);
184 Packer<float,HeapMemory>::pack(mem,9,sts);
185 Packer<double,HeapMemory>::pack(mem,10,sts);
186 Packer<Point_test<float>,HeapMemory>::pack(mem,p,sts);
187 Packer<openfpm::vector<Point_test<float>>,HeapMemory>::pack<pt::x,pt::v>(mem,v,sts);
188 Packer<grid_cpu<3,Point_test<float>>,HeapMemory>::pack<decltype(sub),pt::x,pt::v>(mem,g,sub,sts);
189
190 //! [Pack into a message primitives objects vectors and grids]
191
192 //! [Unpack a message into primitives objects vectors and grids]
193
194 Unpack_stat ps;
195
196 unsigned char uc2;
197 Unpacker<unsigned char,HeapMemory>::unpack(mem,uc2,ps);
198 char c2;
199 Unpacker<char,HeapMemory>::unpack(mem,c2,ps);
200 short s2;
201 Unpacker<short,HeapMemory>::unpack(mem,s2,ps);
202 unsigned short us2;
203 Unpacker<unsigned short,HeapMemory>::unpack(mem,us2,ps);
204 int i2;
205 Unpacker<int,HeapMemory>::unpack(mem,i2,ps);
206 unsigned int ui2;
207 Unpacker<unsigned int,HeapMemory>::unpack(mem,ui2,ps);
208 long int li2;
209 Unpacker<long int,HeapMemory>::unpack(mem,li2,ps);
210 unsigned long int uli2;
211 Unpacker<unsigned long int,HeapMemory>::unpack(mem,uli2,ps);
212 float f2;
213 Unpacker<float,HeapMemory>::unpack(mem,f2,ps);
214 double d2;
215 Unpacker<double,HeapMemory>::unpack(mem,d2,ps);
216
217 // Unpack the point and check
218 Point_test<float> p_test;
219 Unpacker<Point_test<float>,HeapMemory>::unpack(mem,p_test,ps);
220
221 // Unpack the vector and check
222 openfpm::vector<Point_test<float>> v_test;
223 v_test.resize(v.size());
224 Unpacker<openfpm::vector<Point_test<float>>,HeapMemory>::unpack<pt::x,pt::v>(mem,v_test,ps);
225
226 //! [Unpack a message into primitives objects vectors and grids]
227
228 BOOST_REQUIRE_EQUAL(uc2,uc);
229 BOOST_REQUIRE_EQUAL(c2,c);
230 BOOST_REQUIRE_EQUAL(s2,s);
231 BOOST_REQUIRE_EQUAL(us2,us);
232 BOOST_REQUIRE_EQUAL(i2,i);
233 BOOST_REQUIRE_EQUAL(ui2,ui);
234 BOOST_REQUIRE_EQUAL(li2,li);
235 BOOST_REQUIRE_EQUAL(uli2,uli);
236 BOOST_REQUIRE_EQUAL(f2,f);
237 BOOST_REQUIRE_EQUAL(d2,d);
238
239 bool val = (p_test == p);
240 BOOST_REQUIRE_EQUAL(true,val);
241
242 auto it = v_test.getIterator();
243
244 while (it.isNext())
245 {
246 float f1 = v_test.template get<pt::x>(it.get());
247 float f2 = v.template get<pt::x>(it.get());
248
249 BOOST_REQUIRE_EQUAL(f1,f2);
250
251 for (size_t i = 0 ; i < 3 ; i++)
252 {
253 f1 = v_test.template get<pt::v>(it.get())[i];
254 f2 = v.template get<pt::v>(it.get())[i];
255
256 BOOST_REQUIRE_EQUAL(f1,f2);
257 }
258
259 ++it;
260 }
261
262 // Unpack the grid and check
263
264 size_t sz2[] = {16,16,16};
265 grid_cpu<3,Point_test<float>> g_test(sz2);
266 g_test.setMemory();
267
268 grid_key_dx_iterator_sub<3> sub2(g_test.getGrid(),{1,2,3},{5,6,7});
269
270 int ctx = 0;
271 Unpacker<grid_cpu<3,Point_test<float>>,HeapMemory>::unpack<decltype(sub2),int,pt::x,pt::v>(mem,sub2,g_test,ps,ctx,rem_copy_opt::NONE_OPT);
272
273 // Check the unpacked grid
274 sub2.reset();
275
276 while (sub2.isNext())
277 {
278 float f1 = g_test.template get<pt::x>(sub2.get());
279 float f2 = g.template get<pt::x>(sub2.get());
280
281 BOOST_REQUIRE_EQUAL(f1,f2);
282
283 for (size_t i = 0 ; i < 3 ; i++)
284 {
285 f1 = g_test.template get<pt::v>(sub2.get())[i];
286 f2 = g.template get<pt::v>(sub2.get())[i];
287
288 BOOST_REQUIRE_EQUAL(f1,f2);
289 }
290
291 ++sub2;
292 }
293
294 // destroy the packed memory
295 mem.decRef();
296 delete &mem;
297
298 //! [Unpack the object]
299
300 }
301}
302
303BOOST_AUTO_TEST_CASE ( packer_selector_test )
304{
305 BOOST_REQUIRE_EQUAL(Pack_selector<int>::value,PACKER_PRIMITIVE);
306 BOOST_REQUIRE_EQUAL(Pack_selector<float>::value,PACKER_PRIMITIVE);
307 BOOST_REQUIRE_EQUAL(Pack_selector<double>::value,PACKER_PRIMITIVE);
308 BOOST_REQUIRE_EQUAL(Pack_selector<long int>::value,PACKER_PRIMITIVE);
309
310 BOOST_REQUIRE_EQUAL(Pack_selector<int[3]>::value,PACKER_ARRAY_CP_PRIMITIVE);
311 BOOST_REQUIRE_EQUAL(Pack_selector<float[3][3]>::value,PACKER_ARRAY_CP_PRIMITIVE);
312 BOOST_REQUIRE_EQUAL(Pack_selector<double[5][6]>::value,PACKER_ARRAY_CP_PRIMITIVE);
313 BOOST_REQUIRE_EQUAL(Pack_selector<long int[5][8][9]>::value,PACKER_ARRAY_CP_PRIMITIVE);
314
315 BOOST_REQUIRE_EQUAL(Pack_selector<openfpm::vector<float>>::value,PACKER_GENERAL);
316 int aa = Pack_selector<openfpm::vector<aggregate<float,float[3]>>>::value;
317 BOOST_REQUIRE_EQUAL(aa,PACKER_GENERAL);
318 aa = Pack_selector<openfpm::vector_gpu<aggregate<float,float[3]>>>::value;
319 BOOST_REQUIRE_EQUAL(aa,PACKER_GENERAL);
320
321 aa = Pack_selector<grid_cpu<3,aggregate<float,float[3]>>>::value;
322 BOOST_REQUIRE_EQUAL(aa,PACKER_GRID);
323
324
325 openfpm::vector<aggregate<float,float[3]>> vd;
326 aa = Pack_selector<decltype(vd.get(0))>::value;
327 BOOST_REQUIRE_EQUAL(aa,PACKER_ENCAP_OBJECTS);
328
329 size_t sz[3] = {6,6,6};
330 grid_cpu<3,aggregate<float,float[3]>> gd(sz);
331 aa = Pack_selector<decltype(gd.get_o(grid_key_dx<3>({0,0,0})))>::value;
332 BOOST_REQUIRE_EQUAL(aa,PACKER_ENCAP_OBJECTS);
333
334 struct a_test
335 {
336 int a;
337 int b;
338 int c;
339 };
340
341 BOOST_REQUIRE_EQUAL(Pack_selector<a_test>::value,PACKER_OBJECTS_WITH_WARNING_POINTERS);
342
343 struct b_test
344 {
345 int a;
346 int b;
347 int c;
348
349 static bool noPointers() {return true;}
350 };
351
352 BOOST_REQUIRE_EQUAL(Pack_selector<b_test>::value,PACKER_OBJECTS_WITH_POINTER_CHECK);
353}
354
355BOOST_AUTO_TEST_CASE ( packer_memory_traits_inte )
356{
357
358}
359
360BOOST_AUTO_TEST_SUITE_END()
361
362
363
364#endif /* SRC_PACKER_UNIT_TESTS_HPP_ */
365