]> git.proxmox.com Git - ceph.git/blob - ceph/src/test/erasure-code/TestErasureCodeShec.cc
projects / ceph.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
update sources to v12.1.1
[ceph.git] / ceph / src / test / erasure-code / TestErasureCodeShec.cc
1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
2 // vim: ts=8 sw=2 smarttab
3 /*
4 * Ceph - scalable distributed file system
5 *
6 * Copyright (C) 2014,2015 FUJITSU LIMITED
7 *
8 * Author: Shotaro Kawaguchi <kawaguchi.s@jp.fujitsu.com>
9 * Author: Takanori Nakao <nakao.takanori@jp.fujitsu.com>
10 * Author: Takeshi Miyamae <miyamae.takeshi@jp.fujitsu.com>
11 *
12 * This library is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU Lesser General Public
14 * License as published by the Free Software Foundation; either
15 * version 2.1 of the License, or (at your option) any later version.
16 *
17 */
18
19 //SUMMARY: TestErasureCodeShec
20
21 #include <errno.h>
22 #include <pthread.h>
23 #include <stdlib.h>
24
25 #include "crush/CrushWrapper.h"
26 #include "osd/osd_types.h"
27 #include "include/stringify.h"
28 #include "erasure-code/shec/ErasureCodeShec.h"
29 #include "erasure-code/ErasureCodePlugin.h"
30 #include "global/global_context.h"
31 #include "gtest/gtest.h"
32
33 void* thread1(void* pParam);
34 void* thread2(void* pParam);
35 void* thread3(void* pParam);
36 void* thread4(void* pParam);
37 void* thread5(void* pParam);
38
39 static int g_flag = 0;
40
41 TEST(ErasureCodeShec, init_1)
42 {
43 //all parameters are normal values
44 ErasureCodeShecTableCache tcache;
45 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
46 tcache,
47 ErasureCodeShec::MULTIPLE);
48 ErasureCodeProfile *profile = new ErasureCodeProfile();
49 (*profile)["plugin"] = "shec";
50 (*profile)["technique"] = "";
51 (*profile)["crush-failure-domain"] = "osd";
52 (*profile)["k"] = "4";
53 (*profile)["m"] = "3";
54 (*profile)["c"] = "2";
55
56 int r = shec->init(*profile, &cerr);
57
58 //check profile
59 EXPECT_EQ(4, shec->k);
60 EXPECT_EQ(3, shec->m);
61 EXPECT_EQ(2, shec->c);
62 EXPECT_EQ(8, shec->w);
63 EXPECT_EQ(ErasureCodeShec::MULTIPLE, shec->technique);
64 EXPECT_STREQ("default", shec->rule_root.c_str());
65 EXPECT_STREQ("osd", shec->rule_failure_domain.c_str());
66 EXPECT_TRUE(shec->matrix != NULL);
67 EXPECT_EQ(0, r);
68
69 delete shec;
70 delete profile;
71 }
72
73 TEST(ErasureCodeShec, init_2)
74 {
75 //all parameters are normal values
76 ErasureCodeShecTableCache tcache;
77 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
78 tcache,
79 ErasureCodeShec::MULTIPLE);
80 ErasureCodeProfile *profile = new ErasureCodeProfile();
81 (*profile)["plugin"] = "shec";
82 (*profile)["technique"] = "";
83 (*profile)["crush-root"] = "test";
84 (*profile)["crush-failure-domain"] = "host";
85 (*profile)["k"] = "4";
86 (*profile)["m"] = "3";
87 (*profile)["c"] = "2";
88 (*profile)["w"] = "8";
89
90 int r = shec->init(*profile, &cerr);
91
92 //check profile
93 EXPECT_EQ(4, shec->k);
94 EXPECT_EQ(3, shec->m);
95 EXPECT_EQ(2, shec->c);
96 EXPECT_EQ(8, shec->w);
97 EXPECT_EQ(ErasureCodeShec::MULTIPLE, shec->technique);
98 EXPECT_STREQ("test", shec->rule_root.c_str());
99 EXPECT_STREQ("host", shec->rule_failure_domain.c_str());
100 EXPECT_TRUE(shec->matrix != NULL);
101 EXPECT_EQ(0, r);
102
103 delete shec;
104 delete profile;
105 }
106
107 TEST(ErasureCodeShec, init_3)
108 {
109 //all parameters are normal values
110 ErasureCodeShecTableCache tcache;
111 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
112 tcache,
113 ErasureCodeShec::MULTIPLE);
114 ErasureCodeProfile *profile = new ErasureCodeProfile();
115 (*profile)["plugin"] = "shec";
116 (*profile)["technique"] = "";
117 (*profile)["crush-failure-domain"] = "osd";
118 (*profile)["k"] = "4";
119 (*profile)["m"] = "3";
120 (*profile)["c"] = "2";
121 (*profile)["w"] = "16";
122
123 int r = shec->init(*profile, &cerr);
124
125 //check profile
126 EXPECT_EQ(4, shec->k);
127 EXPECT_EQ(3, shec->m);
128 EXPECT_EQ(2, shec->c);
129 EXPECT_EQ(16, shec->w);
130 EXPECT_EQ(ErasureCodeShec::MULTIPLE, shec->technique);
131 EXPECT_STREQ("default", shec->rule_root.c_str());
132 EXPECT_STREQ("osd", shec->rule_failure_domain.c_str());
133 EXPECT_TRUE(shec->matrix != NULL);
134 EXPECT_EQ(0, r);
135
136 delete shec;
137 delete profile;
138 }
139
140 TEST(ErasureCodeShec, init_4)
141 {
142 //all parameters are normal values
143 ErasureCodeShecTableCache tcache;
144 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
145 tcache,
146 ErasureCodeShec::MULTIPLE);
147 ErasureCodeProfile *profile = new ErasureCodeProfile();
148 (*profile)["plugin"] = "shec";
149 (*profile)["technique"] = "";
150 (*profile)["crush-failure-domain"] = "osd";
151 (*profile)["k"] = "4";
152 (*profile)["m"] = "3";
153 (*profile)["c"] = "2";
154 (*profile)["w"] = "32";
155
156 int r = shec->init(*profile, &cerr);
157
158 //check profile
159 EXPECT_EQ(4, shec->k);
160 EXPECT_EQ(3, shec->m);
161 EXPECT_EQ(2, shec->c);
162 EXPECT_EQ(32, shec->w);
163 EXPECT_EQ(ErasureCodeShec::MULTIPLE, shec->technique);
164 EXPECT_STREQ("default", shec->rule_root.c_str());
165 EXPECT_STREQ("osd", shec->rule_failure_domain.c_str());
166 EXPECT_TRUE(shec->matrix != NULL);
167 EXPECT_EQ(0, r);
168
169 delete shec;
170 delete profile;
171 }
172
173 TEST(ErasureCodeShec, init_5)
174 {
175 ErasureCodeShecTableCache tcache;
176 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
177 tcache,
178 ErasureCodeShec::MULTIPLE);
179 ErasureCodeProfile *profile = new ErasureCodeProfile();
180 //plugin is not specified
181 (*profile)["technique"] = "";
182 (*profile)["crush-failure-domain"] = "osd";
183 (*profile)["k"] = "4";
184 (*profile)["m"] = "3";
185 (*profile)["c"] = "2";
186
187 int r = shec->init(*profile, &cerr);
188
189 EXPECT_TRUE(shec->matrix != NULL);
190 EXPECT_EQ(0, r);
191
192 delete shec;
193 delete profile;
194 }
195
196 TEST(ErasureCodeShec, init_6)
197 {
198 ErasureCodeShecTableCache tcache;
199 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
200 tcache,
201 ErasureCodeShec::MULTIPLE);
202 ErasureCodeProfile *profile = new ErasureCodeProfile();
203 (*profile)["plugin"] = "jerasure"; //unexpected value
204 (*profile)["technique"] = "";
205 (*profile)["crush-failure-domain"] = "osd";
206 (*profile)["k"] = "4";
207 (*profile)["m"] = "3";
208 (*profile)["c"] = "2";
209
210 int r = shec->init(*profile, &cerr);
211
212 EXPECT_TRUE(shec->matrix != NULL);
213 EXPECT_EQ(0, r);
214
215 delete shec;
216 delete profile;
217 }
218
219 TEST(ErasureCodeShec, init_7)
220 {
221 ErasureCodeShecTableCache tcache;
222 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
223 tcache,
224 ErasureCodeShec::MULTIPLE);
225 ErasureCodeProfile *profile = new ErasureCodeProfile();
226 (*profile)["plugin"] = "abc"; //unexpected value
227 (*profile)["technique"] = "";
228 (*profile)["crush-failure-domain"] = "osd";
229 (*profile)["k"] = "4";
230 (*profile)["m"] = "3";
231 (*profile)["c"] = "2";
232
233 int r = shec->init(*profile, &cerr);
234
235 EXPECT_TRUE(shec->matrix != NULL);
236 EXPECT_EQ(0, r);
237
238 delete shec;
239 delete profile;
240 }
241
242 TEST(ErasureCodeShec, init_8)
243 {
244 ErasureCodeShecTableCache tcache;
245 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
246 tcache,
247 ErasureCodeShec::MULTIPLE);
248 ErasureCodeProfile *profile = new ErasureCodeProfile();
249 (*profile)["plugin"] = "shec";
250 (*profile)["technique"] = "";
251 (*profile)["crush-failure-domain"] = "osd";
252 (*profile)["k"] = "4";
253 (*profile)["m"] = "3";
254 (*profile)["c"] = "2";
255
256 int r = shec->init(*profile, &cerr);
257
258 EXPECT_TRUE(shec->matrix != NULL);
259 EXPECT_EQ(0, r);
260
261 delete shec;
262 delete profile;
263 }
264
265 TEST(ErasureCodeShec, init_9)
266 {
267 ErasureCodeShecTableCache tcache;
268 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
269 tcache,
270 ErasureCodeShec::MULTIPLE);
271 ErasureCodeProfile *profile = new ErasureCodeProfile();
272 (*profile)["plugin"] = "shec";
273 (*profile)["technique"] = "";
274 (*profile)["crush-root"] = "abc"; //unexpected value
275 (*profile)["crush-failure-domain"] = "osd";
276 (*profile)["k"] = "4";
277 (*profile)["m"] = "3";
278 (*profile)["c"] = "2";
279
280 int r = shec->init(*profile, &cerr);
281
282 EXPECT_TRUE(shec->matrix != NULL);
283 EXPECT_EQ(0, r);
284
285 delete shec;
286 delete profile;
287 }
288
289 TEST(ErasureCodeShec, init_10)
290 {
291 ErasureCodeShecTableCache tcache;
292 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
293 tcache,
294 ErasureCodeShec::MULTIPLE);
295 ErasureCodeProfile *profile = new ErasureCodeProfile();
296 (*profile)["plugin"] = "shec";
297 (*profile)["technique"] = "";
298 (*profile)["crush-failure-domain"] = "abc"; //unexpected value
299 (*profile)["k"] = "4";
300 (*profile)["m"] = "3";
301 (*profile)["c"] = "2";
302
303 int r = shec->init(*profile, &cerr);
304
305 EXPECT_TRUE(shec->matrix != NULL);
306 EXPECT_EQ(0, r);
307
308 delete shec;
309 delete profile;
310 }
311
312 TEST(ErasureCodeShec, init_11)
313 {
314 ErasureCodeShecTableCache tcache;
315 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
316 tcache,
317 ErasureCodeShec::MULTIPLE);
318 ErasureCodeProfile *profile = new ErasureCodeProfile();
319 (*profile)["plugin"] = "shec";
320 (*profile)["technique"] = "abc"; //unexpected value
321 (*profile)["crush-failure-domain"] = "osd";
322 (*profile)["k"] = "4";
323 (*profile)["m"] = "3";
324 (*profile)["c"] = "2";
325
326 int r = shec->init(*profile, &cerr);
327
328 EXPECT_TRUE(shec->matrix != NULL);
329 EXPECT_EQ(0, r);
330
331 delete shec;
332 delete profile;
333 }
334
335 TEST(ErasureCodeShec, init_12)
336 {
337 ErasureCodeShecTableCache tcache;
338 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
339 tcache,
340 ErasureCodeShec::MULTIPLE);
341 ErasureCodeProfile *profile = new ErasureCodeProfile();
342 (*profile)["plugin"] = "shec";
343 (*profile)["technique"] = "";
344 (*profile)["crush-failure-domain"] = "osd";
345 (*profile)["k"] = "-1"; //unexpected value
346 (*profile)["m"] = "3";
347 (*profile)["c"] = "2";
348
349 int r = shec->init(*profile, &cerr);
350
351 EXPECT_EQ(-EINVAL, r);
352
353 delete shec;
354 delete profile;
355 }
356
357 TEST(ErasureCodeShec, init_13)
358 {
359 ErasureCodeShecTableCache tcache;
360 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
361 tcache,
362 ErasureCodeShec::MULTIPLE);
363 ErasureCodeProfile *profile = new ErasureCodeProfile();
364 (*profile)["plugin"] = "shec";
365 (*profile)["technique"] = "";
366 (*profile)["crush-failure-domain"] = "abc";
367 (*profile)["k"] = "0.1"; //unexpected value
368 (*profile)["m"] = "3";
369 (*profile)["c"] = "2";
370
371 int r = shec->init(*profile, &cerr);
372
373 EXPECT_EQ(-EINVAL, r);
374
375 delete shec;
376 delete profile;
377 }
378
379 TEST(ErasureCodeShec, init_14)
380 {
381 ErasureCodeShecTableCache tcache;
382 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
383 tcache,
384 ErasureCodeShec::MULTIPLE);
385 ErasureCodeProfile *profile = new ErasureCodeProfile();
386 (*profile)["plugin"] = "shec";
387 (*profile)["technique"] = "";
388 (*profile)["crush-failure-domain"] = "osd";
389 (*profile)["k"] = "a"; //unexpected value
390 (*profile)["m"] = "3";
391 (*profile)["c"] = "2";
392
393 int r = shec->init(*profile, &cerr);
394
395 EXPECT_EQ(-EINVAL, r);
396
397 delete shec;
398 delete profile;
399 }
400
401 TEST(ErasureCodeShec, init_15)
402 {
403 ErasureCodeShecTableCache tcache;
404 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
405 tcache,
406 ErasureCodeShec::MULTIPLE);
407 ErasureCodeProfile *profile = new ErasureCodeProfile();
408 (*profile)["plugin"] = "shec";
409 (*profile)["technique"] = "";
410 (*profile)["crush-failure-domain"] = "osd";
411 //k is not specified
412 (*profile)["m"] = "3";
413 (*profile)["c"] = "2";
414
415 int r = shec->init(*profile, &cerr);
416
417 EXPECT_EQ(-EINVAL, r);
418
419 delete shec;
420 delete profile;
421 }
422
423 TEST(ErasureCodeShec, init_16)
424 {
425 ErasureCodeShecTableCache tcache;
426 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
427 tcache,
428 ErasureCodeShec::MULTIPLE);
429 ErasureCodeProfile *profile = new ErasureCodeProfile();
430 (*profile)["plugin"] = "shec";
431 (*profile)["technique"] = "";
432 (*profile)["crush-failure-domain"] = "osd";
433 (*profile)["k"] = "4";
434 (*profile)["m"] = "-1"; //unexpected value
435 (*profile)["c"] = "2";
436
437 int r = shec->init(*profile, &cerr);
438
439 EXPECT_EQ(-EINVAL, r);
440
441 delete shec;
442 delete profile;
443 }
444
445 TEST(ErasureCodeShec, init_17)
446 {
447 ErasureCodeShecTableCache tcache;
448 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
449 tcache,
450 ErasureCodeShec::MULTIPLE);
451 ErasureCodeProfile *profile = new ErasureCodeProfile();
452 (*profile)["plugin"] = "shec";
453 (*profile)["technique"] = "";
454 (*profile)["crush-failure-domain"] = "osd";
455 (*profile)["k"] = "4";
456 (*profile)["m"] = "0.1"; //unexpected value
457 (*profile)["c"] = "2";
458
459 int r = shec->init(*profile, &cerr);
460
461 EXPECT_EQ(-EINVAL, r);
462
463 delete shec;
464 delete profile;
465 }
466
467 TEST(ErasureCodeShec, init_18)
468 {
469 ErasureCodeShecTableCache tcache;
470 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
471 tcache,
472 ErasureCodeShec::MULTIPLE);
473 ErasureCodeProfile *profile = new ErasureCodeProfile();
474 (*profile)["plugin"] = "shec";
475 (*profile)["technique"] = "";
476 (*profile)["crush-failure-domain"] = "osd";
477 (*profile)["k"] = "4";
478 (*profile)["m"] = "a"; //unexpected value
479 (*profile)["c"] = "2";
480
481 int r = shec->init(*profile, &cerr);
482
483 EXPECT_EQ(-EINVAL, r);
484
485 delete shec;
486 delete profile;
487 }
488
489 TEST(ErasureCodeShec, init_19)
490 {
491 ErasureCodeShecTableCache tcache;
492 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
493 tcache,
494 ErasureCodeShec::MULTIPLE);
495 ErasureCodeProfile *profile = new ErasureCodeProfile();
496 (*profile)["plugin"] = "shec";
497 (*profile)["technique"] = "";
498 (*profile)["crush-failure-domain"] = "osd";
499 (*profile)["k"] = "4";
500 //m is not specified
501 (*profile)["c"] = "2";
502
503 int r = shec->init(*profile, &cerr);
504
505 EXPECT_EQ(-EINVAL, r);
506
507 delete shec;
508 delete profile;
509 }
510
511 TEST(ErasureCodeShec, init_20)
512 {
513 ErasureCodeShecTableCache tcache;
514 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
515 tcache,
516 ErasureCodeShec::MULTIPLE);
517 ErasureCodeProfile *profile = new ErasureCodeProfile();
518 (*profile)["plugin"] = "shec";
519 (*profile)["technique"] = "";
520 (*profile)["crush-failure-domain"] = "osd";
521 (*profile)["k"] = "4";
522 (*profile)["m"] = "3";
523 (*profile)["c"] = "-1"; //unexpected value
524
525 int r = shec->init(*profile, &cerr);
526
527 EXPECT_EQ(-EINVAL, r);
528
529 delete shec;
530 delete profile;
531 }
532
533 TEST(ErasureCodeShec, init_21)
534 {
535 ErasureCodeShecTableCache tcache;
536 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
537 tcache,
538 ErasureCodeShec::MULTIPLE);
539 ErasureCodeProfile *profile = new ErasureCodeProfile();
540 (*profile)["plugin"] = "shec";
541 (*profile)["technique"] = "";
542 (*profile)["crush-failure-domain"] = "osd";
543 (*profile)["k"] = "4";
544 (*profile)["m"] = "3";
545 (*profile)["c"] = "0.1"; //unexpected value
546
547 int r = shec->init(*profile, &cerr);
548
549 EXPECT_EQ(-EINVAL, r);
550
551 delete shec;
552 delete profile;
553 }
554
555 TEST(ErasureCodeShec, init_22)
556 {
557 ErasureCodeShecTableCache tcache;
558 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
559 tcache,
560 ErasureCodeShec::MULTIPLE);
561 ErasureCodeProfile *profile = new ErasureCodeProfile();
562 (*profile)["plugin"] = "shec";
563 (*profile)["technique"] = "";
564 (*profile)["crush-failure-domain"] = "osd";
565 (*profile)["k"] = "4";
566 (*profile)["m"] = "3";
567 (*profile)["c"] = "a"; //unexpected value
568
569 int r = shec->init(*profile, &cerr);
570
571 EXPECT_EQ(-EINVAL, r);
572
573 delete shec;
574 delete profile;
575 }
576
577 TEST(ErasureCodeShec, init_23)
578 {
579 ErasureCodeShecTableCache tcache;
580 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
581 tcache,
582 ErasureCodeShec::MULTIPLE);
583 ErasureCodeProfile *profile = new ErasureCodeProfile();
584 (*profile)["plugin"] = "shec";
585 (*profile)["technique"] = "";
586 (*profile)["crush-failure-domain"] = "osd";
587 (*profile)["k"] = "4";
588 (*profile)["m"] = "3";
589 //c is not specified
590
591 int r = shec->init(*profile, &cerr);
592
593 EXPECT_EQ(-EINVAL, r);
594
595 delete shec;
596 delete profile;
597 }
598
599 TEST(ErasureCodeShec, init_24)
600 {
601 ErasureCodeShecTableCache tcache;
602 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
603 tcache,
604 ErasureCodeShec::MULTIPLE);
605 ErasureCodeProfile *profile = new ErasureCodeProfile();
606 (*profile)["plugin"] = "shec";
607 (*profile)["technique"] = "";
608 (*profile)["crush-failure-domain"] = "osd";
609 (*profile)["k"] = "4";
610 (*profile)["m"] = "3";
611 (*profile)["c"] = "2";
612 (*profile)["w"] = "1"; //unexpected value
613
614 int r = shec->init(*profile, &cerr);
615
616 EXPECT_TRUE(shec->matrix != NULL);
617 EXPECT_EQ(0, r);
618 EXPECT_EQ(4, shec->k);
619 EXPECT_EQ(3, shec->m);
620 EXPECT_EQ(2, shec->c);
621 EXPECT_EQ(8, shec->w);
622 //w is default value
623
624 delete shec;
625 delete profile;
626 }
627
628 TEST(ErasureCodeShec, init_25)
629 {
630 ErasureCodeShecTableCache tcache;
631 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
632 tcache,
633 ErasureCodeShec::MULTIPLE);
634 ErasureCodeProfile *profile = new ErasureCodeProfile();
635 (*profile)["plugin"] = "shec";
636 (*profile)["technique"] = "";
637 (*profile)["crush-failure-domain"] = "osd";
638 (*profile)["k"] = "4";
639 (*profile)["m"] = "3";
640 (*profile)["c"] = "2";
641 (*profile)["w"] = "-1"; //unexpected value
642
643 int r = shec->init(*profile, &cerr);
644
645 EXPECT_TRUE(shec->matrix != NULL);
646 EXPECT_EQ(0, r);
647 EXPECT_EQ(4, shec->k);
648 EXPECT_EQ(3, shec->m);
649 EXPECT_EQ(2, shec->c);
650 EXPECT_EQ(8, shec->w);
651 //w is default value
652
653 delete shec;
654 delete profile;
655 }
656
657 TEST(ErasureCodeShec, init_26)
658 {
659 ErasureCodeShecTableCache tcache;
660 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
661 tcache,
662 ErasureCodeShec::MULTIPLE);
663 ErasureCodeProfile *profile = new ErasureCodeProfile();
664 (*profile)["plugin"] = "shec";
665 (*profile)["technique"] = "";
666 (*profile)["crush-failure-domain"] = "osd";
667 (*profile)["k"] = "4";
668 (*profile)["m"] = "3";
669 (*profile)["c"] = "2";
670 (*profile)["w"] = "0.1"; //unexpected value
671
672 int r = shec->init(*profile, &cerr);
673
674 EXPECT_TRUE(shec->matrix != NULL);
675 EXPECT_EQ(0, r);
676 EXPECT_EQ(4, shec->k);
677 EXPECT_EQ(3, shec->m);
678 EXPECT_EQ(2, shec->c);
679 EXPECT_EQ(8, shec->w);
680 //w is default value
681
682 delete shec;
683 delete profile;
684 }
685
686 TEST(ErasureCodeShec, init_27)
687 {
688 ErasureCodeShecTableCache tcache;
689 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
690 tcache,
691 ErasureCodeShec::MULTIPLE);
692 ErasureCodeProfile *profile = new ErasureCodeProfile();
693 (*profile)["plugin"] = "shec";
694 (*profile)["technique"] = "";
695 (*profile)["crush-failure-domain"] = "osd";
696 (*profile)["k"] = "4";
697 (*profile)["m"] = "3";
698 (*profile)["c"] = "2";
699 (*profile)["w"] = "a"; //unexpected value
700
701 int r = shec->init(*profile, &cerr);
702
703 EXPECT_TRUE(shec->matrix != NULL);
704 EXPECT_EQ(0, r);
705 EXPECT_EQ(4, shec->k);
706 EXPECT_EQ(3, shec->m);
707 EXPECT_EQ(2, shec->c);
708 EXPECT_EQ(8, shec->w);
709 //w is default value
710
711 delete shec;
712 delete profile;
713 }
714
715 TEST(ErasureCodeShec, init_28)
716 {
717 ErasureCodeShecTableCache tcache;
718 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
719 tcache,
720 ErasureCodeShec::MULTIPLE);
721 ErasureCodeProfile *profile = new ErasureCodeProfile();
722 (*profile)["plugin"] = "shec";
723 (*profile)["technique"] = "";
724 (*profile)["crush-failure-domain"] = "osd";
725 (*profile)["k"] = "4";
726 (*profile)["m"] = "3";
727 (*profile)["c"] = "10"; //c > m
728
729 int r = shec->init(*profile, &cerr);
730
731 EXPECT_EQ(-EINVAL, r);
732
733 delete shec;
734 delete profile;
735 }
736
737 TEST(ErasureCodeShec, init_29)
738 {
739 ErasureCodeShecTableCache tcache;
740 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
741 tcache,
742 ErasureCodeShec::MULTIPLE);
743 ErasureCodeProfile *profile = new ErasureCodeProfile();
744 (*profile)["plugin"] = "shec";
745 (*profile)["technique"] = "";
746 (*profile)["crush-failure-domain"] = "osd";
747 //k is not specified
748 //m is not specified
749 //c is not specified
750
751 int r = shec->init(*profile, &cerr);
752
753 EXPECT_TRUE(shec->matrix != NULL);
754 EXPECT_EQ(0, r);
755 //k,m,c are default values
756 EXPECT_EQ(4, shec->k);
757 EXPECT_EQ(3, shec->m);
758 EXPECT_EQ(2, shec->c);
759
760 delete shec;
761 delete profile;
762 }
763
764 TEST(ErasureCodeShec, init_30)
765 {
766 ErasureCodeShecTableCache tcache;
767 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
768 tcache,
769 ErasureCodeShec::MULTIPLE);
770 ErasureCodeProfile *profile = new ErasureCodeProfile();
771 (*profile)["plugin"] = "shec";
772 (*profile)["technique"] = "";
773 (*profile)["crush-failure-domain"] = "osd";
774 (*profile)["k"] = "12";
775 (*profile)["m"] = "8";
776 (*profile)["c"] = "8";
777
778 int r = shec->init(*profile, &cerr);
779
780 EXPECT_TRUE(shec->matrix != NULL);
781 EXPECT_EQ(0, r);
782 EXPECT_EQ(12, shec->k);
783 EXPECT_EQ(8, shec->m);
784 EXPECT_EQ(8, shec->c);
785
786 delete shec;
787 delete profile;
788 }
789
790 TEST(ErasureCodeShec, init_31)
791 {
792 ErasureCodeShecTableCache tcache;
793 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
794 tcache,
795 ErasureCodeShec::MULTIPLE);
796 ErasureCodeProfile *profile = new ErasureCodeProfile();
797 (*profile)["plugin"] = "shec";
798 (*profile)["technique"] = "";
799 (*profile)["crush-failure-domain"] = "osd";
800 (*profile)["k"] = "13";
801 (*profile)["m"] = "7";
802 (*profile)["c"] = "7";
803
804 int r = shec->init(*profile, &cerr);
805
806 EXPECT_EQ(-EINVAL, r);
807
808 delete shec;
809 delete profile;
810 }
811
812 TEST(ErasureCodeShec, init_32)
813 {
814 ErasureCodeShecTableCache tcache;
815 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
816 tcache,
817 ErasureCodeShec::MULTIPLE);
818 ErasureCodeProfile *profile = new ErasureCodeProfile();
819 (*profile)["plugin"] = "shec";
820 (*profile)["technique"] = "";
821 (*profile)["crush-failure-domain"] = "osd";
822 (*profile)["k"] = "7";
823 (*profile)["m"] = "13";
824 (*profile)["c"] = "13";
825
826 int r = shec->init(*profile, &cerr);
827
828 EXPECT_EQ(-EINVAL, r);
829
830 delete shec;
831 delete profile;
832 }
833
834 TEST(ErasureCodeShec, init_33)
835 {
836 ErasureCodeShecTableCache tcache;
837 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
838 tcache,
839 ErasureCodeShec::MULTIPLE);
840 ErasureCodeProfile *profile = new ErasureCodeProfile();
841 (*profile)["plugin"] = "shec";
842 (*profile)["technique"] = "";
843 (*profile)["crush-failure-domain"] = "osd";
844 (*profile)["k"] = "12";
845 (*profile)["m"] = "9";
846 (*profile)["c"] = "8";
847
848 int r = shec->init(*profile, &cerr);
849
850 EXPECT_EQ(-EINVAL, r);
851
852 delete shec;
853 delete profile;
854 }
855
856 TEST(ErasureCodeShec, init_34)
857 {
858 ErasureCodeShecTableCache tcache;
859 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
860 tcache,
861 ErasureCodeShec::MULTIPLE);
862 ErasureCodeProfile *profile = new ErasureCodeProfile();
863 (*profile)["plugin"] = "shec";
864 (*profile)["technique"] = "";
865 (*profile)["crush-failure-domain"] = "osd";
866 (*profile)["k"] = "8";
867 (*profile)["m"] = "12";
868 (*profile)["c"] = "12";
869
870 int r = shec->init(*profile, &cerr);
871
872 EXPECT_EQ(-EINVAL, r);
873
874 delete shec;
875 delete profile;
876 }
877
878 TEST(ErasureCodeShec, init2_4)
879 {
880 //all parameters are normal values
881 ErasureCodeShecTableCache tcache;
882 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
883 tcache,
884 ErasureCodeShec::MULTIPLE);
885 ErasureCodeProfile *profile = new ErasureCodeProfile();
886 (*profile)["plugin"] = "shec";
887 (*profile)["technique"] = "";
888 (*profile)["crush-failure-domain"] = "osd";
889 (*profile)["k"] = "4";
890 (*profile)["m"] = "3";
891 (*profile)["c"] = "2";
892 shec->init(*profile, &cerr);
893 int r = shec->init(*profile, &cerr); //init executed twice
894
895 //check profile
896 EXPECT_EQ(4, shec->k);
897 EXPECT_EQ(3, shec->m);
898 EXPECT_EQ(2, shec->c);
899 EXPECT_EQ(8, shec->w);
900 EXPECT_EQ(ErasureCodeShec::MULTIPLE, shec->technique);
901 EXPECT_STREQ("default", shec->rule_root.c_str());
902 EXPECT_STREQ("osd", shec->rule_failure_domain.c_str());
903 EXPECT_TRUE(shec->matrix != NULL);
904 EXPECT_EQ(0, r);
905
906 delete shec;
907 delete profile;
908 }
909
910 TEST(ErasureCodeShec, init2_5)
911 {
912 //all parameters are normal values
913 ErasureCodeShecTableCache tcache;
914 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
915 tcache,
916 ErasureCodeShec::MULTIPLE);
917 ErasureCodeProfile *profile = new ErasureCodeProfile();
918 ErasureCodeProfile *profile2 = new ErasureCodeProfile();
919 (*profile)["plugin"] = "shec";
920 (*profile)["technique"] = "";
921 (*profile)["crush-failure-domain"] = "host";
922 (*profile)["k"] = "10";
923 (*profile)["m"] = "6";
924 (*profile)["c"] = "5";
925 (*profile)["w"] = "16";
926
927 int r = shec->init(*profile, &cerr);
928
929 //reexecute init
930 (*profile2)["plugin"] = "shec";
931 (*profile2)["technique"] = "";
932 (*profile2)["crush-failure-domain"] = "osd";
933 (*profile2)["k"] = "4";
934 (*profile2)["m"] = "3";
935 (*profile2)["c"] = "2";
936 shec->init(*profile2, &cerr);
937
938 EXPECT_EQ(4, shec->k);
939 EXPECT_EQ(3, shec->m);
940 EXPECT_EQ(2, shec->c);
941 EXPECT_EQ(8, shec->w);
942 EXPECT_EQ(ErasureCodeShec::MULTIPLE, shec->technique);
943 EXPECT_STREQ("default", shec->rule_root.c_str());
944 EXPECT_STREQ("osd", shec->rule_failure_domain.c_str());
945 EXPECT_TRUE(shec->matrix != NULL);
946 EXPECT_EQ(0, r);
947
948 delete shec;
949 delete profile;
950 }
951
952 TEST(ErasureCodeShec, minimum_to_decode_8)
953 {
954 //init
955 ErasureCodeShecTableCache tcache;
956 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
957 tcache,
958 ErasureCodeShec::MULTIPLE);
959 ErasureCodeProfile *profile = new ErasureCodeProfile();
960 (*profile)["plugin"] = "shec";
961 (*profile)["technique"] = "";
962 (*profile)["crush-failure-domain"] = "osd";
963 (*profile)["k"] = "4";
964 (*profile)["m"] = "3";
965 (*profile)["c"] = "2";
966 shec->init(*profile, &cerr);
967
968 //minimum_to_decode
969 set<int> want_to_decode;
970 set<int> available_chunks;
971 set<int> minimum_chunks;
972
973 for (int i = 0; i < 8; ++i) {
974 want_to_decode.insert(i);
975 }
976 for (int i = 0; i < 5; ++i) {
977 available_chunks.insert(i);
978 }
979
980 int r = shec->minimum_to_decode(want_to_decode, available_chunks,
981 &minimum_chunks);
982 EXPECT_EQ(-EINVAL, r);
983
984 delete shec;
985 delete profile;
986 }
987
988 TEST(ErasureCodeShec, minimum_to_decode_9)
989 {
990 //init
991 ErasureCodeShecTableCache tcache;
992 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
993 tcache,
994 ErasureCodeShec::MULTIPLE);
995 ErasureCodeProfile *profile = new ErasureCodeProfile();
996 (*profile)["plugin"] = "shec";
997 (*profile)["technique"] = "";
998 (*profile)["crush-failure-domain"] = "osd";
999 (*profile)["k"] = "4";
1000 (*profile)["m"] = "3";
1001 (*profile)["c"] = "2";
1002 shec->init(*profile, &cerr);
1003
1004 //minimum_to_decode
1005 set<int> want_to_decode;
1006 set<int> available_chunks;
1007 set<int> minimum_chunks;
1008
1009 for (int i = 0; i < 4; ++i) {
1010 want_to_decode.insert(i);
1011 }
1012 for (int i = 0; i < 8; ++i) {
1013 available_chunks.insert(i);
1014 }
1015
1016 int r = shec->minimum_to_decode(want_to_decode, available_chunks,
1017 &minimum_chunks);
1018 EXPECT_EQ(-EINVAL, r);
1019
1020 delete shec;
1021 delete profile;
1022 }
1023
1024 TEST(ErasureCodeShec, minimum_to_decode_10)
1025 {
1026 //init
1027 ErasureCodeShecTableCache tcache;
1028 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
1029 tcache,
1030 ErasureCodeShec::MULTIPLE);
1031 ErasureCodeProfile *profile = new ErasureCodeProfile();
1032 (*profile)["plugin"] = "shec";
1033 (*profile)["technique"] = "";
1034 (*profile)["crush-failure-domain"] = "osd";
1035 (*profile)["k"] = "4";
1036 (*profile)["m"] = "3";
1037 (*profile)["c"] = "2";
1038 shec->init(*profile, &cerr);
1039
1040 //minimum_to_decode
1041 set<int> want_to_decode;
1042 set<int> available_chunks;
1043 set<int> minimum_chunks;
1044
1045 for (int i = 0; i < 7; ++i) {
1046 want_to_decode.insert(i);
1047 }
1048 for (int i = 4; i < 7; ++i) {
1049 available_chunks.insert(i);
1050 }
1051
1052 int r = shec->minimum_to_decode(want_to_decode, available_chunks,
1053 &minimum_chunks);
1054 EXPECT_EQ(-EIO, r);
1055
1056 delete shec;
1057 delete profile;
1058 }
1059
1060 TEST(ErasureCodeShec, minimum_to_decode_11)
1061 {
1062 //init
1063 ErasureCodeShecTableCache tcache;
1064 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
1065 tcache,
1066 ErasureCodeShec::MULTIPLE);
1067 ErasureCodeProfile *profile = new ErasureCodeProfile();
1068 (*profile)["plugin"] = "shec";
1069 (*profile)["technique"] = "";
1070 (*profile)["crush-failure-domain"] = "osd";
1071 (*profile)["k"] = "4";
1072 (*profile)["m"] = "3";
1073 (*profile)["c"] = "2";
1074 shec->init(*profile, &cerr);
1075
1076 //minimum_to_decode
1077 set<int> want_to_decode;
1078 set<int> available_chunks;
1079 set<int> minimum_chunks;
1080
1081 for (int i = 0; i < 5; ++i) {
1082 want_to_decode.insert(i);
1083 }
1084 for (int i = 4; i < 7; ++i) {
1085 available_chunks.insert(i);
1086 }
1087
1088 int r = shec->minimum_to_decode(want_to_decode, available_chunks,
1089 &minimum_chunks);
1090 EXPECT_EQ(-EIO, r);
1091
1092 delete shec;
1093 delete profile;
1094 }
1095
1096 TEST(ErasureCodeShec, minimum_to_decode_12)
1097 {
1098 //init
1099 ErasureCodeShecTableCache tcache;
1100 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
1101 tcache,
1102 ErasureCodeShec::MULTIPLE);
1103 ErasureCodeProfile *profile = new ErasureCodeProfile();
1104 (*profile)["plugin"] = "shec";
1105 (*profile)["technique"] = "";
1106 (*profile)["crush-failure-domain"] = "osd";
1107 (*profile)["k"] = "4";
1108 (*profile)["m"] = "3";
1109 (*profile)["c"] = "2";
1110 shec->init(*profile, &cerr);
1111
1112 //minimum_to_decode
1113 set<int> want_to_decode;
1114 set<int> available_chunks;
1115 //minimum_chunks is NULL
1116
1117 for (int i = 0; i < 7; ++i) {
1118 want_to_decode.insert(i);
1119 available_chunks.insert(i);
1120 }
1121
1122 int r = shec->minimum_to_decode(want_to_decode, available_chunks, NULL);
1123 EXPECT_EQ(-EINVAL, r);
1124
1125 delete shec;
1126 delete profile;
1127 }
1128
1129 TEST(ErasureCodeShec, minimum_to_decode_13)
1130 {
1131 //init
1132 ErasureCodeShecTableCache tcache;
1133 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
1134 tcache,
1135 ErasureCodeShec::MULTIPLE);
1136 ErasureCodeProfile *profile = new ErasureCodeProfile();
1137 (*profile)["plugin"] = "shec";
1138 (*profile)["technique"] = "";
1139 (*profile)["crush-failure-domain"] = "osd";
1140 (*profile)["k"] = "4";
1141 (*profile)["m"] = "3";
1142 (*profile)["c"] = "2";
1143 shec->init(*profile, &cerr);
1144
1145 //minimum_to_decode
1146 set<int> want_to_decode;
1147 set<int> available_chunks;
1148 set<int> minimum_chunks, minimum;
1149
1150 for (int i = 0; i < 7; ++i) {
1151 want_to_decode.insert(i);
1152 available_chunks.insert(i);
1153 }
1154 shec->minimum_to_decode(want_to_decode, available_chunks, &minimum_chunks);
1155 minimum = minimum_chunks; //normal value
1156 for (int i = 100; i < 120; ++i) {
1157 minimum_chunks.insert(i); //insert extra data
1158 }
1159
1160 int r = shec->minimum_to_decode(want_to_decode, available_chunks,
1161 &minimum_chunks);
1162 EXPECT_TRUE(shec->matrix != NULL);
1163 EXPECT_EQ(0, r);
1164 EXPECT_EQ(minimum, minimum_chunks);
1165
1166 delete shec;
1167 delete profile;
1168 }
1169
1170 TEST(ErasureCodeShec, minimum_to_decode2_1)
1171 {
1172 //init
1173 ErasureCodeShecTableCache tcache;
1174 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
1175 tcache,
1176 ErasureCodeShec::MULTIPLE);
1177 ErasureCodeProfile *profile = new ErasureCodeProfile();
1178 (*profile)["plugin"] = "shec";
1179 (*profile)["technique"] = "";
1180 (*profile)["crush-failure-domain"] = "osd";
1181 (*profile)["k"] = "4";
1182 (*profile)["m"] = "3";
1183 (*profile)["c"] = "2";
1184 shec->init(*profile, &cerr);
1185
1186 //minimum_to_decode
1187 set<int> want_to_decode;
1188 set<int> available_chunks;
1189 set<int> minimum_chunks;
1190
1191 want_to_decode.insert(0);
1192 available_chunks.insert(0);
1193 available_chunks.insert(1);
1194 available_chunks.insert(2);
1195
1196 int r = shec->minimum_to_decode(want_to_decode, available_chunks,
1197 &minimum_chunks);
1198 EXPECT_TRUE(shec->matrix != NULL);
1199 EXPECT_EQ(0, r);
1200 EXPECT_TRUE(minimum_chunks.size());
1201
1202 delete shec;
1203 delete profile;
1204 }
1205
1206 TEST(ErasureCodeShec, minimum_to_decode2_3)
1207 {
1208 //init
1209 ErasureCodeShecTableCache tcache;
1210 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
1211 tcache,
1212 ErasureCodeShec::MULTIPLE);
1213 ErasureCodeProfile *profile = new ErasureCodeProfile();
1214 (*profile)["plugin"] = "shec";
1215 (*profile)["technique"] = "";
1216 (*profile)["crush-failure-domain"] = "osd";
1217 (*profile)["k"] = "4";
1218 (*profile)["m"] = "3";
1219 (*profile)["c"] = "2";
1220 shec->init(*profile, &cerr);
1221
1222 //minimum_to_decode
1223 set<int> want_to_decode;
1224 set<int> available_chunks;
1225 set<int> minimum_chunks;
1226
1227 want_to_decode.insert(0);
1228 want_to_decode.insert(2);
1229 available_chunks.insert(0);
1230 available_chunks.insert(1);
1231 available_chunks.insert(2);
1232 available_chunks.insert(3);
1233
1234 pthread_t tid;
1235 g_flag = 0;
1236 pthread_create(&tid, NULL, thread1, shec);
1237 while (g_flag == 0) {
1238 usleep(1);
1239 }
1240 sleep(1);
1241 printf("*** test start ***\n");
1242 int r = shec->minimum_to_decode(want_to_decode, available_chunks,
1243 &minimum_chunks);
1244 EXPECT_TRUE(shec->matrix != NULL);
1245 EXPECT_EQ(0, r);
1246 EXPECT_EQ(want_to_decode, minimum_chunks);
1247 printf("*** test end ***\n");
1248 g_flag = 0;
1249 pthread_join(tid, NULL);
1250
1251 delete shec;
1252 delete profile;
1253 }
1254
1255 TEST(ErasureCodeShec, minimum_to_decode_with_cost_1)
1256 {
1257 //init
1258 ErasureCodeShecTableCache tcache;
1259 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
1260 tcache,
1261 ErasureCodeShec::MULTIPLE);
1262 ErasureCodeProfile *profile = new ErasureCodeProfile();
1263 (*profile)["plugin"] = "shec";
1264 (*profile)["technique"] = "";
1265 (*profile)["crush-failure-domain"] = "osd";
1266 (*profile)["k"] = "4";
1267 (*profile)["m"] = "3";
1268 (*profile)["c"] = "2";
1269 shec->init(*profile, &cerr);
1270
1271 //minimum_to_decode_with_cost
1272 set<int> want_to_decode;
1273 map<int, int> available_chunks;
1274 set<int> minimum_chunks;
1275
1276 for (int i = 0; i < 7; ++i) {
1277 want_to_decode.insert(i);
1278 available_chunks.insert(make_pair(i, i));
1279 }
1280
1281 int r = shec->minimum_to_decode_with_cost(want_to_decode, available_chunks,
1282 &minimum_chunks);
1283 EXPECT_TRUE(shec->matrix != NULL);
1284 EXPECT_EQ(0, r);
1285 EXPECT_TRUE(minimum_chunks.size());
1286
1287 delete shec;
1288 delete profile;
1289 }
1290
1291 TEST(ErasureCodeShec, minimum_to_decode_with_cost_2_3)
1292 {
1293 //init
1294 ErasureCodeShecTableCache tcache;
1295 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
1296 tcache,
1297 ErasureCodeShec::MULTIPLE);
1298 ErasureCodeProfile *profile = new ErasureCodeProfile();
1299 (*profile)["plugin"] = "shec";
1300 (*profile)["technique"] = "";
1301 (*profile)["crush-failure-domain"] = "osd";
1302 (*profile)["k"] = "4";
1303 (*profile)["m"] = "3";
1304 (*profile)["c"] = "2";
1305 shec->init(*profile, &cerr);
1306
1307 //minimum_to_decode_with_cost
1308 set<int> want_to_decode;
1309 map<int, int> available_chunks;
1310 set<int> minimum_chunks;
1311
1312 want_to_decode.insert(0);
1313 want_to_decode.insert(2);
1314 available_chunks[0] = 0;
1315 available_chunks[1] = 1;
1316 available_chunks[2] = 2;
1317 available_chunks[3] = 3;
1318
1319 pthread_t tid;
1320 g_flag = 0;
1321 pthread_create(&tid, NULL, thread2, shec);
1322 while (g_flag == 0) {
1323 usleep(1);
1324 }
1325 sleep(1);
1326 printf("*** test start ***\n");
1327 int r = shec->minimum_to_decode_with_cost(want_to_decode, available_chunks,
1328 &minimum_chunks);
1329 EXPECT_TRUE(shec->matrix != NULL);
1330 EXPECT_EQ(0, r);
1331 EXPECT_EQ(want_to_decode, minimum_chunks);
1332 printf("*** test end ***\n");
1333 g_flag = 0;
1334 pthread_join(tid, NULL);
1335
1336 delete shec;
1337 delete profile;
1338 }
1339
1340 TEST(ErasureCodeShec, encode_1)
1341 {
1342 //init
1343 ErasureCodeShecTableCache tcache;
1344 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
1345 tcache,
1346 ErasureCodeShec::MULTIPLE);
1347 ErasureCodeProfile *profile = new ErasureCodeProfile();
1348 (*profile)["plugin"] = "shec";
1349 (*profile)["technique"] = "";
1350 (*profile)["crush-failure-domain"] = "osd";
1351 (*profile)["k"] = "4";
1352 (*profile)["m"] = "3";
1353 (*profile)["c"] = "2";
1354 shec->init(*profile, &cerr);
1355
1356 //encode
1357 bufferlist in;
1358 set<int> want_to_encode;
1359 map<int, bufferlist> encoded;
1360
1361 in.append("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//length = 62
1362 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//124
1363 "0123"//128
1364 );
1365 for (unsigned int i = 0; i < shec->get_chunk_count(); ++i) {
1366 want_to_encode.insert(i);
1367 }
1368
1369 int r = shec->encode(want_to_encode, in, &encoded);
1370 EXPECT_EQ(0, r);
1371 EXPECT_EQ(shec->get_chunk_count(), encoded.size());
1372 EXPECT_EQ(shec->get_chunk_size(in.length()), encoded[0].length());
1373
1374 //decode
1375 int want_to_decode[] = { 0, 1, 2, 3, 4, 5, 6 };
1376 map<int, bufferlist> decoded;
1377 decoded.clear();
1378 r = shec->decode(set<int>(want_to_decode, want_to_decode + 2),
1379 encoded,
1380 &decoded);
1381 EXPECT_TRUE(shec->matrix != NULL);
1382 EXPECT_EQ(0, r);
1383 EXPECT_EQ(2u, decoded.size());
1384 EXPECT_EQ(32u, decoded[0].length());
1385
1386 bufferlist out1, out2, usable;
1387 //out1 is "encoded"
1388 for (unsigned int i = 0; i < encoded.size(); ++i) {
1389 out1.append(encoded[i]);
1390 }
1391 //out2 is "decoded"
1392 r = shec->decode_concat(encoded, &out2);
1393 usable.substr_of(out2, 0, in.length());
1394 EXPECT_FALSE(out1 == in);
1395 EXPECT_TRUE(usable == in);
1396
1397 delete shec;
1398 delete profile;
1399 }
1400
1401 TEST(ErasureCodeShec, encode_2)
1402 {
1403 //init
1404 ErasureCodeShecTableCache tcache;
1405 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
1406 tcache,
1407 ErasureCodeShec::MULTIPLE);
1408 ErasureCodeProfile *profile = new ErasureCodeProfile();
1409 (*profile)["plugin"] = "shec";
1410 (*profile)["technique"] = "";
1411 (*profile)["crush-failure-domain"] = "osd";
1412 (*profile)["k"] = "4";
1413 (*profile)["m"] = "3";
1414 (*profile)["c"] = "2";
1415 shec->init(*profile, &cerr);
1416
1417 //encode
1418 bufferlist in;
1419 set<int> want_to_encode;
1420 map<int, bufferlist> encoded;
1421
1422 in.append("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//length = 62
1423 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//124
1424 );
1425 for (unsigned int i = 0; i < shec->get_chunk_count(); ++i) {
1426 want_to_encode.insert(i);
1427 }
1428
1429 int r = shec->encode(want_to_encode, in, &encoded);
1430 EXPECT_EQ(0, r);
1431 EXPECT_EQ(shec->get_chunk_count(), encoded.size());
1432 EXPECT_EQ(shec->get_chunk_size(in.length()), encoded[0].length());
1433
1434 //decode
1435 int want_to_decode[] = { 0, 1, 2, 3, 4, 5, 6 };
1436 map<int, bufferlist> decoded;
1437 r = shec->decode(set<int>(want_to_decode, want_to_decode + 2), encoded,
1438 &decoded);
1439 EXPECT_TRUE(shec->matrix != NULL);
1440 EXPECT_EQ(0, r);
1441 EXPECT_EQ(2u, decoded.size());
1442 EXPECT_EQ(32u, decoded[0].length());
1443
1444 bufferlist out1, out2, usable;
1445 //out1 is "encoded"
1446 for (unsigned int i = 0; i < encoded.size(); ++i)
1447 out1.append(encoded[i]);
1448 //out2 is "decoded"
1449 shec->decode_concat(encoded, &out2);
1450 usable.substr_of(out2, 0, in.length());
1451 EXPECT_FALSE(out1 == in);
1452 EXPECT_TRUE(usable == in);
1453
1454 delete shec;
1455 delete profile;
1456 }
1457
1458 TEST(ErasureCodeShec, encode_3)
1459 {
1460 ErasureCodeShecTableCache tcache;
1461 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
1462 tcache,
1463 ErasureCodeShec::MULTIPLE);
1464 ErasureCodeProfile *profile = new ErasureCodeProfile();
1465 (*profile)["plugin"] = "shec";
1466 (*profile)["technique"] = "";
1467 (*profile)["crush-failure-domain"] = "osd";
1468 (*profile)["k"] = "4";
1469 (*profile)["m"] = "3";
1470 (*profile)["c"] = "2";
1471 shec->init(*profile, &cerr);
1472
1473 bufferlist in;
1474 in.append("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//length = 62
1475 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//124
1476 );
1477 set<int> want_to_encode;
1478 for (unsigned int i = 0; i < shec->get_chunk_count(); ++i) {
1479 want_to_encode.insert(i);
1480 }
1481 want_to_encode.insert(10);
1482 want_to_encode.insert(11);
1483 map<int, bufferlist> encoded;
1484 int r = shec->encode(want_to_encode, in, &encoded);
1485 EXPECT_EQ(0, r);
1486 EXPECT_EQ(shec->get_chunk_count(), encoded.size());
1487 EXPECT_EQ(shec->get_chunk_size(in.length()), encoded[0].length());
1488
1489 //decode
1490 int want_to_decode[] = { 0, 1, 2, 3, 4, 5, 6 };
1491 map<int, bufferlist> decoded;
1492 r = shec->decode(set<int>(want_to_decode, want_to_decode + 2), encoded,
1493 &decoded);
1494 EXPECT_TRUE(shec->matrix != NULL);
1495 EXPECT_EQ(0, r);
1496 EXPECT_EQ(2u, decoded.size());
1497 EXPECT_EQ(shec->get_chunk_size(in.length()), decoded[0].length());
1498
1499 bufferlist out1, out2, usable;
1500 //out1 is "encoded"
1501 for (unsigned int i = 0; i < encoded.size(); ++i) {
1502 out1.append(encoded[i]);
1503 }
1504 //out2 is "decoded"
1505 shec->decode_concat(encoded, &out2);
1506 usable.substr_of(out2, 0, in.length());
1507 EXPECT_FALSE(out1 == in);
1508 EXPECT_TRUE(usable == in);
1509
1510 delete shec;
1511 delete profile;
1512 }
1513
1514 TEST(ErasureCodeShec, encode_4)
1515 {
1516 //init
1517 ErasureCodeShecTableCache tcache;
1518 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
1519 tcache,
1520 ErasureCodeShec::MULTIPLE);
1521 ErasureCodeProfile *profile = new ErasureCodeProfile();
1522 (*profile)["plugin"] = "shec";
1523 (*profile)["technique"] = "";
1524 (*profile)["crush-failure-domain"] = "osd";
1525 (*profile)["k"] = "4";
1526 (*profile)["m"] = "3";
1527 (*profile)["c"] = "2";
1528 shec->init(*profile, &cerr);
1529
1530 //encode
1531 bufferlist in;
1532 set<int> want_to_encode;
1533 map<int, bufferlist> encoded;
1534
1535 in.append("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//length = 62
1536 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//124
1537 );
1538 for (unsigned int i = 0; i < shec->get_chunk_count() - 1; ++i) {
1539 want_to_encode.insert(i);
1540 }
1541 want_to_encode.insert(100);
1542
1543 int r = shec->encode(want_to_encode, in, &encoded);
1544 EXPECT_EQ(0, r);
1545 EXPECT_EQ(shec->get_chunk_count()-1, encoded.size());
1546 EXPECT_EQ(shec->get_chunk_size(in.length()), encoded[0].length());
1547
1548 //decode
1549 int want_to_decode[] = { 0, 1, 2, 3, 4, 5, 6 };
1550 map<int, bufferlist> decoded;
1551 r = shec->decode(set<int>(want_to_decode, want_to_decode + 2), encoded,
1552 &decoded);
1553 EXPECT_TRUE(shec->matrix != NULL);
1554 EXPECT_EQ(0, r);
1555 EXPECT_EQ(2u, decoded.size());
1556 EXPECT_EQ(shec->get_chunk_size(in.length()), decoded[0].length());
1557
1558 bufferlist out1, out2, usable;
1559 //out1 is "encoded"
1560 for (unsigned int i = 0; i < encoded.size(); ++i) {
1561 out1.append(encoded[i]);
1562 }
1563 //out2 is "decoded"
1564 shec->decode_concat(encoded, &out2);
1565 usable.substr_of(out2, 0, in.length());
1566 EXPECT_FALSE(out1 == in);
1567 EXPECT_TRUE(usable == in);
1568
1569 delete shec;
1570 delete profile;
1571 }
1572
1573 TEST(ErasureCodeShec, encode_8)
1574 {
1575 //init
1576 ErasureCodeShecTableCache tcache;
1577 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
1578 tcache,
1579 ErasureCodeShec::MULTIPLE);
1580 ErasureCodeProfile *profile = new ErasureCodeProfile();
1581 (*profile)["plugin"] = "shec";
1582 (*profile)["technique"] = "";
1583 (*profile)["crush-failure-domain"] = "osd";
1584 (*profile)["k"] = "4";
1585 (*profile)["m"] = "3";
1586 (*profile)["c"] = "2";
1587 shec->init(*profile, &cerr);
1588
1589 //encode
1590 bufferlist in;
1591 set<int> want_to_encode;
1592
1593 in.append("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//length = 62
1594 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//124
1595 );
1596 for (unsigned int i = 0; i < shec->get_chunk_count(); ++i) {
1597 want_to_encode.insert(i);
1598 }
1599
1600 int r = shec->encode(want_to_encode, in, NULL); //encoded = NULL
1601 EXPECT_EQ(-EINVAL, r);
1602
1603 delete shec;
1604 delete profile;
1605 }
1606
1607 TEST(ErasureCodeShec, encode_9)
1608 {
1609 //init
1610 ErasureCodeShecTableCache tcache;
1611 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
1612 tcache,
1613 ErasureCodeShec::MULTIPLE);
1614 ErasureCodeProfile *profile = new ErasureCodeProfile();
1615 (*profile)["plugin"] = "shec";
1616 (*profile)["technique"] = "";
1617 (*profile)["crush-failure-domain"] = "osd";
1618 (*profile)["k"] = "4";
1619 (*profile)["m"] = "3";
1620 (*profile)["c"] = "2";
1621 shec->init(*profile, &cerr);
1622
1623 //encode
1624 bufferlist in;
1625 set<int> want_to_encode;
1626 map<int, bufferlist> encoded;
1627
1628 in.append("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//length = 62
1629 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//124
1630 );
1631 for (unsigned int i = 0; i < shec->get_chunk_count(); ++i) {
1632 want_to_encode.insert(i);
1633 }
1634 for (int i = 0; i < 100; ++i) {
1635 encoded[i].append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
1636 }
1637
1638 int r = shec->encode(want_to_encode, in, &encoded);
1639 EXPECT_EQ(-EINVAL, r);
1640
1641 delete shec;
1642 delete profile;
1643 }
1644
1645 TEST(ErasureCodeShec, encode2_1)
1646 {
1647 //init
1648 ErasureCodeShecTableCache tcache;
1649 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
1650 tcache,
1651 ErasureCodeShec::MULTIPLE);
1652 ErasureCodeProfile *profile = new ErasureCodeProfile();
1653 (*profile)["plugin"] = "shec";
1654 (*profile)["technique"] = "";
1655 (*profile)["crush-failure-domain"] = "osd";
1656 (*profile)["k"] = "4";
1657 (*profile)["m"] = "3";
1658 (*profile)["c"] = "2";
1659 shec->init(*profile, &cerr);
1660
1661 //encode
1662 bufferlist in;
1663 set<int> want_to_encode;
1664 map<int, bufferlist> encoded;
1665
1666 in.append("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//length = 62
1667 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//124
1668 "0123"//128
1669 );
1670 for (unsigned int i = 0; i < shec->get_chunk_count(); ++i) {
1671 want_to_encode.insert(i);
1672 }
1673
1674 int r = shec->encode(want_to_encode, in, &encoded);
1675 EXPECT_EQ(0, r);
1676 EXPECT_EQ(shec->get_chunk_count(), encoded.size());
1677 EXPECT_EQ(shec->get_chunk_size(in.length()), encoded[0].length());
1678
1679 //decode
1680 int want_to_decode[] = { 0, 1, 2, 3, 4, 5, 6 };
1681 map<int, bufferlist> decoded;
1682 r = shec->decode(set<int>(want_to_decode, want_to_decode + 2), encoded,
1683 &decoded);
1684 EXPECT_TRUE(shec->matrix != NULL);
1685 EXPECT_EQ(0, r);
1686 EXPECT_EQ(2u, decoded.size());
1687 EXPECT_EQ(32u, decoded[0].length());
1688
1689 bufferlist out1, out2, usable;
1690 //out1 is "encoded"
1691 for (unsigned int i = 0; i < encoded.size(); ++i) {
1692 out1.append(encoded[i]);
1693 }
1694 //out2 is "decoded"
1695 shec->decode_concat(encoded, &out2);
1696 usable.substr_of(out2, 0, in.length());
1697 EXPECT_FALSE(out1 == in);
1698 EXPECT_TRUE(usable == in);
1699
1700 delete shec;
1701 delete profile;
1702 }
1703
1704 TEST(ErasureCodeShec, encode2_3)
1705 {
1706 //init
1707 ErasureCodeShecTableCache tcache;
1708 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
1709 tcache,
1710 ErasureCodeShec::MULTIPLE);
1711 ErasureCodeProfile *profile = new ErasureCodeProfile();
1712 (*profile)["plugin"] = "shec";
1713 (*profile)["technique"] = "";
1714 (*profile)["crush-failure-domain"] = "osd";
1715 (*profile)["k"] = "4";
1716 (*profile)["m"] = "3";
1717 (*profile)["c"] = "2";
1718 shec->init(*profile, &cerr);
1719
1720 //encode
1721 bufferlist in;
1722 set<int> want_to_encode;
1723 map<int, bufferlist> encoded;
1724
1725 in.append("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//length = 62
1726 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//124
1727 "0123"//128
1728 );
1729 for (unsigned int i = 0; i < shec->get_chunk_count(); ++i) {
1730 want_to_encode.insert(i);
1731 }
1732
1733 pthread_t tid;
1734 g_flag = 0;
1735 pthread_create(&tid, NULL, thread4, shec);
1736 while (g_flag == 0) {
1737 usleep(1);
1738 }
1739 sleep(1);
1740 printf("*** test start ***\n");
1741 int r = shec->encode(want_to_encode, in, &encoded);
1742 EXPECT_EQ(0, r);
1743 EXPECT_EQ(shec->get_chunk_count(), encoded.size());
1744 EXPECT_EQ(shec->get_chunk_size(in.length()), encoded[0].length());
1745 printf("*** test end ***\n");
1746 g_flag = 0;
1747 pthread_join(tid, NULL);
1748
1749 //decode
1750 int want_to_decode[] = { 0, 1, 2, 3, 4, 5, 6 };
1751 map<int, bufferlist> decoded;
1752
1753 r = shec->decode(set<int>(want_to_decode, want_to_decode + 2), encoded,
1754 &decoded);
1755 EXPECT_TRUE(shec->matrix != NULL);
1756 EXPECT_EQ(0, r);
1757 EXPECT_EQ(2u, decoded.size());
1758 EXPECT_EQ(32u, decoded[0].length());
1759
1760 bufferlist out1, out2, usable;
1761 //out1 is "encoded"
1762 for (unsigned int i = 0; i < encoded.size(); ++i) {
1763 out1.append(encoded[i]);
1764 }
1765 //out2 is "decoded"
1766 shec->decode_concat(encoded, &out2);
1767 usable.substr_of(out2, 0, in.length());
1768 EXPECT_FALSE(out1 == in);
1769 EXPECT_TRUE(usable == in);
1770
1771 delete shec;
1772 delete profile;
1773 }
1774
1775 TEST(ErasureCodeShec, decode_1)
1776 {
1777 //init
1778 ErasureCodeShecTableCache tcache;
1779 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
1780 tcache,
1781 ErasureCodeShec::MULTIPLE);
1782 ErasureCodeProfile *profile = new ErasureCodeProfile();
1783 (*profile)["plugin"] = "shec";
1784 (*profile)["technique"] = "";
1785 (*profile)["crush-failure-domain"] = "osd";
1786 (*profile)["k"] = "4";
1787 (*profile)["m"] = "3";
1788 (*profile)["c"] = "2";
1789 shec->init(*profile, &cerr);
1790
1791 //encode
1792 bufferlist in;
1793 set<int> want_to_encode;
1794 map<int, bufferlist> encoded;
1795
1796 in.append("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//length = 62
1797 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//124
1798 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//186
1799 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//248
1800 );
1801 for (unsigned int i = 0; i < shec->get_chunk_count(); ++i) {
1802 want_to_encode.insert(i);
1803 }
1804
1805 int r = shec->encode(want_to_encode, in, &encoded);
1806 EXPECT_EQ(0, r);
1807 EXPECT_EQ(shec->get_chunk_count(), encoded.size());
1808 EXPECT_EQ(shec->get_chunk_size(in.length()), encoded[0].length());
1809
1810 // all chunks are available
1811 //decode
1812 int want_to_decode[] = { 0, 1, 2, 3, 4, 5, 6 };
1813 map<int, bufferlist> decoded;
1814
1815 r = shec->decode(set<int>(want_to_decode, want_to_decode + 7), encoded,
1816 &decoded);
1817 EXPECT_TRUE(shec->matrix != NULL);
1818 EXPECT_EQ(0, r);
1819 EXPECT_EQ(7u, decoded.size());
1820
1821 bufferlist usable;
1822 int cmp;
1823 unsigned int c_size = shec->get_chunk_size(in.length());
1824 for (unsigned int i = 0; i < shec->get_data_chunk_count(); ++i) {
1825 usable.clear();
1826 EXPECT_EQ(c_size, decoded[i].length());
1827 if ( c_size * (i+1) <= in.length() ) {
1828 usable.substr_of(in, c_size * i, c_size);
1829 cmp = memcmp(decoded[i].c_str(), usable.c_str(), c_size);
1830 } else {
1831 usable.substr_of(in, c_size * i, in.length() % c_size);
1832 cmp = memcmp(decoded[i].c_str(), usable.c_str(), in.length() % c_size);
1833 }
1834 EXPECT_EQ(0, cmp);
1835 }
1836
1837 delete shec;
1838 delete profile;
1839 }
1840
1841 TEST(ErasureCodeShec, decode_8)
1842 {
1843 //init
1844 ErasureCodeShecTableCache tcache;
1845 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
1846 tcache,
1847 ErasureCodeShec::MULTIPLE);
1848 ErasureCodeProfile *profile = new ErasureCodeProfile();
1849 (*profile)["plugin"] = "shec";
1850 (*profile)["technique"] = "";
1851 (*profile)["crush-failure-domain"] = "osd";
1852 (*profile)["k"] = "4";
1853 (*profile)["m"] = "3";
1854 (*profile)["c"] = "2";
1855 shec->init(*profile, &cerr);
1856
1857 //encode
1858 bufferlist in;
1859 set<int> want_to_encode;
1860 map<int, bufferlist> encoded;
1861
1862 in.append("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//length = 62
1863 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//124
1864 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//186
1865 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//248
1866 );
1867 for (unsigned int i = 0; i < shec->get_chunk_count(); ++i) {
1868 want_to_encode.insert(i);
1869 }
1870
1871 int r = shec->encode(want_to_encode, in, &encoded);
1872 EXPECT_EQ(0, r);
1873 EXPECT_EQ(shec->get_chunk_count(), encoded.size());
1874 EXPECT_EQ(shec->get_chunk_size(in.length()), encoded[0].length());
1875
1876 // all chunks are available
1877 //decode
1878 int want_to_decode[] = { 0, 1, 2, 3, 4, 5, 6, 7 }; //more than k+m
1879 map<int, bufferlist> decoded;
1880
1881 r = shec->decode(set<int>(want_to_decode, want_to_decode + 8), encoded,
1882 &decoded);
1883 EXPECT_EQ(0, r);
1884 EXPECT_EQ(7u, decoded.size());
1885 EXPECT_EQ(shec->get_chunk_size(in.length()), encoded[0].length());
1886
1887 bufferlist usable;
1888 int cmp;
1889 unsigned int c_size = shec->get_chunk_size(in.length());
1890 for (unsigned int i = 0; i < shec->get_data_chunk_count(); ++i) {
1891 usable.clear();
1892 EXPECT_EQ(c_size, decoded[i].length());
1893 if ( c_size * (i+1) <= in.length() ) {
1894 usable.substr_of(in, c_size * i, c_size);
1895 cmp = memcmp(decoded[i].c_str(), usable.c_str(), c_size);
1896 } else {
1897 usable.substr_of(in, c_size * i, in.length() % c_size);
1898 cmp = memcmp(decoded[i].c_str(), usable.c_str(), in.length() % c_size);
1899 }
1900 EXPECT_EQ(0, cmp);
1901 }
1902
1903 delete shec;
1904 delete profile;
1905 }
1906
1907 TEST(ErasureCodeShec, decode_9)
1908 {
1909 //init
1910 ErasureCodeShecTableCache tcache;
1911 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
1912 tcache,
1913 ErasureCodeShec::MULTIPLE);
1914 ErasureCodeProfile *profile = new ErasureCodeProfile();
1915 (*profile)["plugin"] = "shec";
1916 (*profile)["technique"] = "";
1917 (*profile)["crush-failure-domain"] = "osd";
1918 (*profile)["k"] = "4";
1919 (*profile)["m"] = "3";
1920 (*profile)["c"] = "2";
1921 shec->init(*profile, &cerr);
1922
1923 //encode
1924 bufferlist in;
1925 set<int> want_to_encode;
1926 map<int, bufferlist> encoded;
1927
1928 in.append("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//length = 62
1929 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//124
1930 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//186
1931 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//248
1932 );
1933 for (unsigned int i = 0; i < shec->get_chunk_count(); ++i) {
1934 want_to_encode.insert(i);
1935 }
1936
1937 int r = shec->encode(want_to_encode, in, &encoded);
1938 EXPECT_EQ(0, r);
1939 EXPECT_EQ(shec->get_chunk_count(), encoded.size());
1940 EXPECT_EQ(shec->get_chunk_size(in.length()), encoded[0].length());
1941
1942 // all chunks are available
1943 //decode
1944 int want_to_decode[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
1945 map<int, bufferlist> decoded;
1946
1947 //extra data
1948 bufferlist buf;
1949 buf.append("abc");
1950 encoded[100] = buf;
1951
1952 r = shec->decode(set<int>(want_to_decode, want_to_decode + 10), encoded,
1953 &decoded);
1954 EXPECT_TRUE(shec->matrix != NULL);
1955 EXPECT_EQ(0, r);
1956 EXPECT_EQ(7u, decoded.size());
1957 EXPECT_EQ(shec->get_chunk_size(in.length()), decoded[0].length());
1958
1959 bufferlist out1, usable;
1960 //out1 is "encoded"
1961 for (unsigned int i = 0; i < encoded.size(); ++i) {
1962 out1.append(encoded[i]);
1963 }
1964 EXPECT_FALSE(out1 == in);
1965 //usable is "decoded"
1966 int cmp;
1967 unsigned int c_size = shec->get_chunk_size(in.length());
1968 for (unsigned int i = 0; i < shec->get_data_chunk_count(); ++i) {
1969 usable.clear();
1970 EXPECT_EQ(c_size, decoded[i].length());
1971 if ( c_size * (i+1) <= in.length() ) {
1972 usable.substr_of(in, c_size * i, c_size);
1973 cmp = memcmp(decoded[i].c_str(), usable.c_str(), c_size);
1974 } else {
1975 usable.substr_of(in, c_size * i, in.length() % c_size);
1976 cmp = memcmp(decoded[i].c_str(), usable.c_str(), in.length() % c_size);
1977 }
1978 EXPECT_EQ(0, cmp);
1979 }
1980
1981 delete shec;
1982 delete profile;
1983 }
1984
1985 TEST(ErasureCodeShec, decode_10)
1986 {
1987 //init
1988 ErasureCodeShecTableCache tcache;
1989 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
1990 tcache,
1991 ErasureCodeShec::MULTIPLE);
1992 ErasureCodeProfile *profile = new ErasureCodeProfile();
1993 (*profile)["plugin"] = "shec";
1994 (*profile)["technique"] = "";
1995 (*profile)["crush-failure-domain"] = "osd";
1996 (*profile)["k"] = "4";
1997 (*profile)["m"] = "3";
1998 (*profile)["c"] = "2";
1999 shec->init(*profile, &cerr);
2000
2001 //encode
2002 bufferlist in;
2003 set<int> want_to_encode;
2004 map<int, bufferlist> encoded;
2005
2006 in.append("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//length = 62
2007 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//124
2008 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//186
2009 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//248
2010 );
2011 for (unsigned int i = 0; i < shec->get_chunk_count(); ++i) {
2012 want_to_encode.insert(i);
2013 }
2014
2015 int r = shec->encode(want_to_encode, in, &encoded);
2016 EXPECT_EQ(0, r);
2017 EXPECT_EQ(shec->get_chunk_count(), encoded.size());
2018 EXPECT_EQ(shec->get_chunk_size(in.length()), encoded[0].length());
2019
2020 //decode
2021 int want_to_decode[] = { 0, 1, 2, 3, 4, 5, 6 }; //more than k+m
2022 map<int, bufferlist> decoded, inchunks;
2023
2024 for ( unsigned int i = 0; i < 3; ++i) {
2025 inchunks.insert(make_pair(i, encoded[i]));
2026 }
2027
2028 r = shec->decode(set<int>(want_to_decode, want_to_decode + 7), inchunks,
2029 &decoded);
2030 EXPECT_EQ(-1, r);
2031
2032 delete shec;
2033 delete profile;
2034 }
2035
2036 TEST(ErasureCodeShec, decode_11)
2037 {
2038 //init
2039 ErasureCodeShecTableCache tcache;
2040 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
2041 tcache,
2042 ErasureCodeShec::MULTIPLE);
2043 ErasureCodeProfile *profile = new ErasureCodeProfile();
2044 (*profile)["plugin"] = "shec";
2045 (*profile)["technique"] = "";
2046 (*profile)["crush-failure-domain"] = "osd";
2047 (*profile)["k"] = "4";
2048 (*profile)["m"] = "3";
2049 (*profile)["c"] = "2";
2050 shec->init(*profile, &cerr);
2051
2052 //encode
2053 bufferlist in;
2054 set<int> want_to_encode;
2055 map<int, bufferlist> encoded;
2056
2057 in.append("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//length = 62
2058 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//124
2059 "ABCD"//128
2060 );
2061 for (unsigned int i = 0; i < shec->get_chunk_count(); ++i) {
2062 want_to_encode.insert(i);
2063 }
2064
2065 int r = shec->encode(want_to_encode, in, &encoded);
2066 EXPECT_EQ(0, r);
2067 EXPECT_EQ(shec->get_chunk_count(), encoded.size());
2068 EXPECT_EQ(shec->get_chunk_size(in.length()), encoded[0].length());
2069
2070 //decode
2071 int want_to_decode[] = { 0, 1, 2, 3, 4 };
2072 map<int, bufferlist> decoded, inchunks;
2073
2074 for ( unsigned int i = 4; i < 7; ++i) {
2075 inchunks.insert(make_pair(i, encoded[i]));
2076 }
2077
2078 r = shec->decode(set<int>(want_to_decode, want_to_decode + 5), inchunks,
2079 &decoded);
2080 EXPECT_EQ(-1, r);
2081
2082 delete shec;
2083 delete profile;
2084 }
2085
2086 TEST(ErasureCodeShec, decode_12)
2087 {
2088 //init
2089 ErasureCodeShecTableCache tcache;
2090 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
2091 tcache,
2092 ErasureCodeShec::MULTIPLE);
2093 ErasureCodeProfile *profile = new ErasureCodeProfile();
2094 (*profile)["plugin"] = "shec";
2095 (*profile)["technique"] = "";
2096 (*profile)["crush-failure-domain"] = "osd";
2097 (*profile)["k"] = "4";
2098 (*profile)["m"] = "3";
2099 (*profile)["c"] = "2";
2100 shec->init(*profile, &cerr);
2101
2102 //encode
2103 bufferlist in;
2104 set<int> want_to_encode;
2105 map<int, bufferlist> encoded;
2106
2107 in.append("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//length = 62
2108 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//124
2109 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//186
2110 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//248
2111 );
2112 for (unsigned int i = 0; i < shec->get_chunk_count(); ++i) {
2113 want_to_encode.insert(i);
2114 }
2115
2116 int r = shec->encode(want_to_encode, in, &encoded);
2117 EXPECT_EQ(0, r);
2118 EXPECT_EQ(shec->get_chunk_count(), encoded.size());
2119 EXPECT_EQ(shec->get_chunk_size(in.length()), encoded[0].length());
2120
2121 // all chunks are available
2122 //decode
2123 int want_to_decode[] = { 0, 1, 2, 3, 4, 5, 6 };
2124
2125 //decoded = NULL
2126 r = shec->decode(set<int>(want_to_decode, want_to_decode + 7), encoded,
2127 NULL);
2128 EXPECT_NE(0, r);
2129
2130 delete shec;
2131 delete profile;
2132 }
2133
2134 TEST(ErasureCodeShec, decode_13)
2135 {
2136 //init
2137 ErasureCodeShecTableCache tcache;
2138 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
2139 tcache,
2140 ErasureCodeShec::MULTIPLE);
2141 ErasureCodeProfile *profile = new ErasureCodeProfile();
2142 (*profile)["plugin"] = "shec";
2143 (*profile)["technique"] = "";
2144 (*profile)["crush-failure-domain"] = "osd";
2145 (*profile)["k"] = "4";
2146 (*profile)["m"] = "3";
2147 (*profile)["c"] = "2";
2148 shec->init(*profile, &cerr);
2149
2150 //encode
2151 bufferlist in;
2152 set<int> want_to_encode;
2153 map<int, bufferlist> encoded;
2154
2155 in.append("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//length = 62
2156 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//124
2157 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//186
2158 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//248
2159 );
2160 for (unsigned int i = 0; i < shec->get_chunk_count(); ++i) {
2161 want_to_encode.insert(i);
2162 }
2163
2164 int r = shec->encode(want_to_encode, in, &encoded);
2165 EXPECT_EQ(0, r);
2166 EXPECT_EQ(shec->get_chunk_count(), encoded.size());
2167 EXPECT_EQ(shec->get_chunk_size(in.length()), encoded[0].length());
2168
2169 // all chunks are available
2170 //decode
2171 int want_to_decode[] = { 0, 1, 2, 3, 4, 5, 6 };
2172 map<int, bufferlist> decoded;
2173
2174 //extra data
2175 bufferlist buf;
2176 buf.append("a");
2177 for (int i = 0; i < 100; ++i) {
2178 decoded[i] = buf;
2179 }
2180
2181 r = shec->decode(set<int>(want_to_decode, want_to_decode + 7), encoded,
2182 &decoded);
2183 EXPECT_NE(0, r);
2184
2185 delete shec;
2186 delete profile;
2187 }
2188
2189 TEST(ErasureCodeShec, decode2_1)
2190 {
2191 //init
2192 ErasureCodeShecTableCache tcache;
2193 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
2194 tcache,
2195 ErasureCodeShec::MULTIPLE);
2196 ErasureCodeProfile *profile = new ErasureCodeProfile();
2197 (*profile)["plugin"] = "shec";
2198 (*profile)["technique"] = "";
2199 (*profile)["crush-failure-domain"] = "osd";
2200 (*profile)["k"] = "4";
2201 (*profile)["m"] = "3";
2202 (*profile)["c"] = "2";
2203 shec->init(*profile, &cerr);
2204
2205 //encode
2206 bufferlist in;
2207 set<int> want_to_encode;
2208 map<int, bufferlist> encoded;
2209
2210 in.append("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//length = 62
2211 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//124
2212 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//186
2213 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//248
2214 );
2215 for (unsigned int i = 0; i < shec->get_chunk_count(); ++i) {
2216 want_to_encode.insert(i);
2217 }
2218
2219 int r = shec->encode(want_to_encode, in, &encoded);
2220 EXPECT_EQ(0, r);
2221 EXPECT_EQ(shec->get_chunk_count(), encoded.size());
2222 EXPECT_EQ(shec->get_chunk_size(in.length()), encoded[0].length());
2223
2224 // all chunks are available
2225 //decode
2226 int want_to_decode[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
2227 map<int, bufferlist> decoded;
2228
2229 r = shec->decode(set<int>(want_to_decode, want_to_decode + 2), encoded,
2230 &decoded);
2231 EXPECT_TRUE(shec->matrix != NULL);
2232 EXPECT_EQ(0, r);
2233 EXPECT_EQ(2u, decoded.size());
2234
2235 bufferlist out;
2236 shec->decode_concat(encoded, &out);
2237 bufferlist usable;
2238 usable.substr_of(out, 0, in.length());
2239 EXPECT_TRUE(usable == in);
2240
2241 delete shec;
2242 delete profile;
2243 }
2244
2245 TEST(ErasureCodeShec, decode2_3)
2246 {
2247 //init
2248 ErasureCodeShecTableCache tcache;
2249 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
2250 tcache,
2251 ErasureCodeShec::MULTIPLE);
2252 ErasureCodeProfile *profile = new ErasureCodeProfile();
2253 (*profile)["plugin"] = "shec";
2254 (*profile)["technique"] = "";
2255 (*profile)["crush-failure-domain"] = "osd";
2256 (*profile)["k"] = "4";
2257 (*profile)["m"] = "3";
2258 (*profile)["c"] = "2";
2259 shec->init(*profile, &cerr);
2260
2261 //encode
2262 bufferlist in;
2263 set<int> want_to_encode;
2264 map<int, bufferlist> encoded;
2265
2266 in.append("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//length = 62
2267 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//124
2268 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//186
2269 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//248
2270 );
2271 for (unsigned int i = 0; i < shec->get_chunk_count(); ++i) {
2272 want_to_encode.insert(i);
2273 }
2274
2275 int r = shec->encode(want_to_encode, in, &encoded);
2276 EXPECT_EQ(0, r);
2277 EXPECT_EQ(shec->get_chunk_count(), encoded.size());
2278 EXPECT_EQ(shec->get_chunk_size(in.length()), encoded[0].length());
2279
2280 // all chunks are available
2281 //decode
2282 int want_to_decode[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
2283 map<int, bufferlist> decoded;
2284
2285 pthread_t tid;
2286 g_flag = 0;
2287 pthread_create(&tid, NULL, thread4, shec);
2288 while (g_flag == 0) {
2289 usleep(1);
2290 }
2291 sleep(1);
2292 printf("*** test start ***\n");
2293 r = shec->decode(set<int>(want_to_decode, want_to_decode + 2), encoded,
2294 &decoded);
2295 EXPECT_TRUE(shec->matrix != NULL);
2296 EXPECT_EQ(0, r);
2297 EXPECT_EQ(2u, decoded.size());
2298 printf("*** test end ***\n");
2299 g_flag = 0;
2300 pthread_join(tid, NULL);
2301
2302 bufferlist out;
2303 shec->decode_concat(encoded, &out);
2304 bufferlist usable;
2305 usable.substr_of(out, 0, in.length());
2306 EXPECT_TRUE(usable == in);
2307
2308 delete shec;
2309 delete profile;
2310 }
2311
2312 TEST(ErasureCodeShec, decode2_4)
2313 {
2314 //init
2315 ErasureCodeShecTableCache tcache;
2316 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
2317 tcache,
2318 ErasureCodeShec::MULTIPLE);
2319 ErasureCodeProfile *profile = new ErasureCodeProfile();
2320 (*profile)["plugin"] = "shec";
2321 (*profile)["technique"] = "";
2322 (*profile)["crush-failure-domain"] = "osd";
2323 (*profile)["k"] = "4";
2324 (*profile)["m"] = "3";
2325 (*profile)["c"] = "2";
2326 shec->init(*profile, &cerr);
2327
2328 //encode
2329 bufferlist in;
2330 set<int> want_to_encode;
2331 map<int, bufferlist> encoded;
2332
2333 in.append("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//length = 62
2334 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//124
2335 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//186
2336 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//248
2337 );
2338 for (unsigned int i = 0; i < shec->get_chunk_count(); ++i) {
2339 want_to_encode.insert(i);
2340 }
2341
2342 int r = shec->encode(want_to_encode, in, &encoded);
2343 EXPECT_EQ(0, r);
2344 EXPECT_EQ(shec->get_chunk_count(), encoded.size());
2345 EXPECT_EQ(shec->get_chunk_size(in.length()), encoded[0].length());
2346
2347 //decode
2348 int want_to_decode[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
2349 map<int, bufferlist> decoded;
2350
2351 // cannot recover
2352 bufferlist out;
2353 map<int, bufferlist> degraded;
2354 degraded[0] = encoded[0];
2355
2356 r = shec->decode(set<int>(want_to_decode, want_to_decode + 2), degraded,
2357 &decoded);
2358 EXPECT_EQ(-1, r);
2359
2360 delete shec;
2361 delete profile;
2362 }
2363
2364 TEST(ErasureCodeShec, create_rule_1_2)
2365 {
2366 //create ruleset
2367 CrushWrapper *crush = new CrushWrapper;
2368 crush->create();
2369 crush->set_type_name(2, "root");
2370 crush->set_type_name(1, "host");
2371 crush->set_type_name(0, "osd");
2372
2373 int rootno;
2374 crush->add_bucket(0, CRUSH_BUCKET_STRAW, CRUSH_HASH_RJENKINS1, 2, 0, NULL,
2375 NULL, &rootno);
2376 crush->set_item_name(rootno, "default");
2377
2378 map < string, string > loc;
2379 loc["root"] = "default";
2380
2381 int num_host = 2;
2382 int num_osd = 5;
2383 int osd = 0;
2384 for (int h = 0; h < num_host; ++h) {
2385 loc["host"] = string("host-") + stringify(h);
2386 for (int o = 0; o < num_osd; ++o, ++osd) {
2387 crush->insert_item(g_ceph_context, osd, 1.0,
2388 string("osd.") + stringify(osd), loc);
2389 }
2390 }
2391
2392 //init
2393 ErasureCodeShecTableCache tcache;
2394 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
2395 tcache,
2396 ErasureCodeShec::MULTIPLE);
2397 ErasureCodeProfile *profile = new ErasureCodeProfile();
2398 (*profile)["plugin"] = "shec";
2399 (*profile)["technique"] = "";
2400 (*profile)["crush-failure-domain"] = "osd";
2401 (*profile)["k"] = "4";
2402 (*profile)["m"] = "3";
2403 (*profile)["c"] = "2";
2404 shec->init(*profile, &cerr);
2405
2406 //create_rule
2407 stringstream ss;
2408
2409 int r = shec->create_rule("myrule", *crush, &ss);
2410 EXPECT_EQ(0, r);
2411 EXPECT_STREQ("myrule", crush->rule_name_map[0].c_str());
2412
2413 //reexecute create_rule
2414 r = shec->create_rule("myrule", *crush, &ss);
2415 EXPECT_EQ(-EEXIST, r);
2416
2417 delete shec;
2418 delete profile;
2419 delete crush;
2420 }
2421
2422 TEST(ErasureCodeShec, create_rule_4)
2423 {
2424 //create ruleset
2425 CrushWrapper *crush = new CrushWrapper;
2426 crush->create();
2427 crush->set_type_name(2, "root");
2428 crush->set_type_name(1, "host");
2429 crush->set_type_name(0, "osd");
2430
2431 int rootno;
2432 crush->add_bucket(0, CRUSH_BUCKET_STRAW, CRUSH_HASH_RJENKINS1, 2, 0, NULL,
2433 NULL, &rootno);
2434 crush->set_item_name(rootno, "default");
2435
2436 map < string, string > loc;
2437 loc["root"] = "default";
2438
2439 int num_host = 2;
2440 int num_osd = 5;
2441 int osd = 0;
2442 for (int h = 0; h < num_host; ++h) {
2443 loc["host"] = string("host-") + stringify(h);
2444 for (int o = 0; o < num_osd; ++o, ++osd) {
2445 crush->insert_item(g_ceph_context, osd, 1.0,
2446 string("osd.") + stringify(osd), loc);
2447 }
2448 }
2449
2450 //init
2451 ErasureCodeShecTableCache tcache;
2452 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
2453 tcache,
2454 ErasureCodeShec::MULTIPLE);
2455 ErasureCodeProfile *profile = new ErasureCodeProfile();
2456 (*profile)["plugin"] = "shec";
2457 (*profile)["technique"] = "";
2458 (*profile)["crush-failure-domain"] = "osd";
2459 (*profile)["k"] = "4";
2460 (*profile)["m"] = "3";
2461 (*profile)["c"] = "2";
2462 shec->init(*profile, &cerr);
2463
2464 //create_rule
2465 int r = shec->create_rule("myrule", *crush, NULL); //ss = NULL
2466 EXPECT_EQ(0, r);
2467
2468 delete shec;
2469 delete profile;
2470 delete crush;
2471 }
2472
2473 TEST(ErasureCodeShec, create_rule2_1)
2474 {
2475 //create ruleset
2476 CrushWrapper *crush = new CrushWrapper;
2477 crush->create();
2478 crush->set_type_name(2, "root");
2479 crush->set_type_name(1, "host");
2480 crush->set_type_name(0, "osd");
2481
2482 int rootno;
2483 crush->add_bucket(0, CRUSH_BUCKET_STRAW, CRUSH_HASH_RJENKINS1, 2, 0, NULL,
2484 NULL, &rootno);
2485 crush->set_item_name(rootno, "default");
2486
2487 map < string, string > loc;
2488 loc["root"] = "default";
2489
2490 int num_host = 2;
2491 int num_osd = 5;
2492 int osd = 0;
2493 for (int h = 0; h < num_host; ++h) {
2494 loc["host"] = string("host-") + stringify(h);
2495 for (int o = 0; o < num_osd; ++o, ++osd) {
2496 crush->insert_item(g_ceph_context, osd, 1.0,
2497 string("osd.") + stringify(osd), loc);
2498 }
2499 }
2500
2501 //init
2502 ErasureCodeShecTableCache tcache;
2503 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
2504 tcache,
2505 ErasureCodeShec::MULTIPLE);
2506 ErasureCodeProfile *profile = new ErasureCodeProfile();
2507 (*profile)["plugin"] = "shec";
2508 (*profile)["technique"] = "";
2509 (*profile)["crush-failure-domain"] = "osd";
2510 (*profile)["k"] = "4";
2511 (*profile)["m"] = "3";
2512 (*profile)["c"] = "2";
2513 shec->init(*profile, &cerr);
2514
2515 //create_rule
2516 stringstream ss;
2517
2518 int r = shec->create_rule("myrule", *crush, &ss);
2519 EXPECT_EQ(0, r);
2520 EXPECT_STREQ("myrule", crush->rule_name_map[0].c_str());
2521
2522 delete shec;
2523 delete profile;
2524 delete crush;
2525 }
2526
2527 struct CreateRuleset2_3_Param_d {
2528 ErasureCodeShec *shec;
2529 CrushWrapper *crush;
2530 };
2531
2532 TEST(ErasureCodeShec, create_rule2_3)
2533 {
2534 //create ruleset
2535 CrushWrapper *crush = new CrushWrapper;
2536 crush->create();
2537 crush->set_type_name(2, "root");
2538 crush->set_type_name(1, "host");
2539 crush->set_type_name(0, "osd");
2540
2541 int rootno;
2542 crush->add_bucket(0, CRUSH_BUCKET_STRAW, CRUSH_HASH_RJENKINS1, 2, 0, NULL,
2543 NULL, &rootno);
2544 crush->set_item_name(rootno, "default");
2545
2546 map < string, string > loc;
2547 loc["root"] = "default";
2548
2549 int num_host = 2;
2550 int num_osd = 5;
2551 int osd = 0;
2552 for (int h = 0; h < num_host; ++h) {
2553 loc["host"] = string("host-") + stringify(h);
2554 for (int o = 0; o < num_osd; ++o, ++osd) {
2555 crush->insert_item(g_ceph_context, osd, 1.0,
2556 string("osd.") + stringify(osd), loc);
2557 }
2558 }
2559
2560 //init
2561 ErasureCodeShecTableCache tcache;
2562 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
2563 tcache,
2564 ErasureCodeShec::MULTIPLE);
2565 ErasureCodeProfile *profile = new ErasureCodeProfile();
2566 (*profile)["plugin"] = "shec";
2567 (*profile)["technique"] = "";
2568 (*profile)["crush-failure-domain"] = "osd";
2569 (*profile)["k"] = "4";
2570 (*profile)["m"] = "3";
2571 (*profile)["c"] = "2";
2572 shec->init(*profile, &cerr);
2573
2574 //create_rule
2575 stringstream ss;
2576
2577 pthread_t tid;
2578 g_flag = 0;
2579 pthread_create(&tid, NULL, thread3, shec);
2580 while (g_flag == 0) {
2581 usleep(1);
2582 }
2583 sleep(1);
2584 printf("*** test start ***\n");
2585 int r = (shec->create_rule("myrule", *crush, &ss));
2586 EXPECT_TRUE(r >= 0);
2587 printf("*** test end ***\n");
2588 g_flag = 0;
2589 pthread_join(tid, NULL);
2590
2591 delete shec;
2592 delete profile;
2593 delete crush;
2594 }
2595
2596 TEST(ErasureCodeShec, get_chunk_count_1)
2597 {
2598 //init
2599 ErasureCodeShecTableCache tcache;
2600 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
2601 tcache,
2602 ErasureCodeShec::MULTIPLE);
2603 ErasureCodeProfile *profile = new ErasureCodeProfile();
2604 (*profile)["plugin"] = "shec";
2605 (*profile)["technique"] = "";
2606 (*profile)["crush-failure-domain"] = "osd";
2607 (*profile)["k"] = "4";
2608 (*profile)["m"] = "3";
2609 (*profile)["c"] = "2";
2610 shec->init(*profile, &cerr);
2611
2612 //get_chunk_count
2613 EXPECT_EQ(7u, shec->get_chunk_count());
2614
2615 delete shec;
2616 delete profile;
2617 }
2618
2619 TEST(ErasureCodeShec, get_data_chunk_count_1)
2620 {
2621 //init
2622 ErasureCodeShecTableCache tcache;
2623 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
2624 tcache,
2625 ErasureCodeShec::MULTIPLE);
2626 ErasureCodeProfile *profile = new ErasureCodeProfile();
2627 (*profile)["plugin"] = "shec";
2628 (*profile)["technique"] = "";
2629 (*profile)["crush-failure-domain"] = "osd";
2630 (*profile)["k"] = "4";
2631 (*profile)["m"] = "3";
2632 (*profile)["c"] = "2";
2633 shec->init(*profile, &cerr);
2634
2635 //get_data_chunk_count
2636 EXPECT_EQ(4u, shec->get_data_chunk_count());
2637
2638 delete shec;
2639 delete profile;
2640 }
2641
2642 TEST(ErasureCodeShec, get_chunk_size_1_2)
2643 {
2644 //init
2645 ErasureCodeShecTableCache tcache;
2646 ErasureCodeShec* shec = new ErasureCodeShecReedSolomonVandermonde(
2647 tcache,
2648 ErasureCodeShec::MULTIPLE);
2649 ErasureCodeProfile *profile = new ErasureCodeProfile();
2650 (*profile)["plugin"] = "shec";
2651 (*profile)["technique"] = "";
2652 (*profile)["crush-failure-domain"] = "osd";
2653 (*profile)["k"] = "4";
2654 (*profile)["m"] = "3";
2655 (*profile)["c"] = "2";
2656 (*profile)["w"] = "8";
2657 shec->init(*profile, &cerr);
2658
2659 //when there is no padding(128=k*w*4)
2660 EXPECT_EQ(32u, shec->get_chunk_size(128));
2661 //when there is padding(126=k*w*4-2)
2662 EXPECT_EQ(32u, shec->get_chunk_size(126));
2663
2664 delete shec;
2665 delete profile;
2666 }
2667
2668 void* thread1(void* pParam)
2669 {
2670 ErasureCodeShec* shec = (ErasureCodeShec*) pParam;
2671 set<int> want_to_decode;
2672 set<int> available_chunks;
2673 set<int> minimum_chunks;
2674
2675 want_to_decode.insert(0);
2676 want_to_decode.insert(1);
2677 available_chunks.insert(0);
2678 available_chunks.insert(1);
2679 available_chunks.insert(2);
2680
2681 printf("*** thread loop start ***\n");
2682 g_flag = 1;
2683 while (g_flag == 1) {
2684 shec->minimum_to_decode(want_to_decode, available_chunks, &minimum_chunks);
2685 }
2686 printf("*** thread loop end ***\n");
2687
2688 return NULL;
2689 }
2690
2691 void* thread2(void* pParam)
2692 {
2693 ErasureCodeShec* shec = (ErasureCodeShec*) pParam;
2694 set<int> want_to_decode;
2695 map<int, int> available_chunks;
2696 set<int> minimum_chunks;
2697
2698 want_to_decode.insert(0);
2699 want_to_decode.insert(1);
2700 available_chunks[0] = 0;
2701 available_chunks[1] = 1;
2702 available_chunks[2] = 2;
2703
2704 printf("*** thread loop start ***\n");
2705 g_flag = 1;
2706 while (g_flag == 1) {
2707 shec->minimum_to_decode_with_cost(want_to_decode, available_chunks,
2708 &minimum_chunks);
2709 minimum_chunks.clear();
2710 }
2711 printf("*** thread loop end ***\n");
2712
2713 return NULL;
2714 }
2715
2716 void* thread3(void* pParam)
2717 {
2718 ErasureCodeShec* shec = (ErasureCodeShec*) pParam;
2719
2720 CrushWrapper *crush = new CrushWrapper;
2721 crush->create();
2722 crush->set_type_name(2, "root");
2723 crush->set_type_name(1, "host");
2724 crush->set_type_name(0, "osd");
2725
2726 int rootno;
2727 crush->add_bucket(0, CRUSH_BUCKET_STRAW, CRUSH_HASH_RJENKINS1, 2, 0, NULL,
2728 NULL, &rootno);
2729 crush->set_item_name(rootno, "default");
2730
2731 map < string, string > loc;
2732 loc["root"] = "default";
2733
2734 int num_host = 2;
2735 int num_osd = 5;
2736 int osd = 0;
2737 for (int h = 0; h < num_host; ++h) {
2738 loc["host"] = string("host-") + stringify(h);
2739 for (int o = 0; o < num_osd; ++o, ++osd) {
2740 crush->insert_item(g_ceph_context, osd, 1.0,
2741 string("osd.") + stringify(osd), loc);
2742 }
2743 }
2744
2745 stringstream ss;
2746 int i = 0;
2747 char name[30];
2748
2749 printf("*** thread loop start ***\n");
2750 g_flag = 1;
2751 while (g_flag == 1) {
2752 sprintf(name, "myrule%d", i);
2753 shec->create_rule(name, *crush, &ss);
2754 ++i;
2755 }
2756 printf("*** thread loop end ***\n");
2757
2758 return NULL;
2759 }
2760
2761 void* thread4(void* pParam)
2762 {
2763 ErasureCodeShec* shec = (ErasureCodeShec*) pParam;
2764
2765 bufferlist in;
2766 in.append("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//length = 62
2767 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//124
2768 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//186
2769 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//248
2770 );
2771 set<int> want_to_encode;
2772 for (unsigned int i = 0; i < shec->get_chunk_count(); ++i) {
2773 want_to_encode.insert(i);
2774 }
2775
2776 map<int, bufferlist> encoded;
2777
2778 printf("*** thread loop start ***\n");
2779 g_flag = 1;
2780 while (g_flag == 1) {
2781 shec->encode(want_to_encode, in, &encoded);
2782 encoded.clear();
2783 }
2784 printf("*** thread loop end ***\n");
2785
2786 return NULL;
2787 }
2788
2789 void* thread5(void* pParam)
2790 {
2791 ErasureCodeShec* shec = (ErasureCodeShec*) pParam;
2792
2793 bufferlist in;
2794 in.append("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//length = 62
2795 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//124
2796 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//186
2797 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//248
2798 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"//310
2799 );
2800 set<int> want_to_encode;
2801 for (unsigned int i = 0; i < shec->get_chunk_count(); ++i) {
2802 want_to_encode.insert(i);
2803 }
2804 map<int, bufferlist> encoded;
2805 shec->encode(want_to_encode, in, &encoded);
2806
2807 int want_to_decode[] = { 0, 1, 2, 3, 4, 5 };
2808 map<int, bufferlist> decoded;
2809
2810 printf("*** thread loop start ***\n");
2811 g_flag = 1;
2812 while (g_flag == 1) {
2813 shec->decode(set<int>(want_to_decode, want_to_decode + 2), encoded,
2814 &decoded);
2815 decoded.clear();
2816 }
2817 printf("*** thread loop end ***\n");
2818
2819 return NULL;
2820 }
Ceph