3 #include <unordered_map>
13 #include "txn_btree.h"
15 #include "small_vector.h"
16 #include "static_vector.h"
17 #include "small_unordered_map.h"
18 #include "static_unordered_map.h"
20 #include "record/encoder.h"
21 #include "record/inline_str.h"
22 #include "record/cursor.h"
24 #ifdef PROTO2_CAN_DISABLE_GC
25 #include "txn_proto2_impl.h"
28 #define MYREC_KEY_FIELDS(x, y) \
31 #define MYREC_VALUE_FIELDS(x, y) \
34 DO_STRUCT(myrec, MYREC_KEY_FIELDS, MYREC_VALUE_FIELDS)
36 #define CURSORREC_KEY_FIELDS(x, y) \
39 #define CURSORREC_VALUE_FIELDS(x, y) \
43 y(inline_str_8<25>,v3) \
44 y(inline_str_fixed<25>,v4) \
47 DO_STRUCT(cursorrec, CURSORREC_KEY_FIELDS, CURSORREC_VALUE_FIELDS)
52 static event_counter evt_test("test");
53 static event_counter evt_test1("test1");
54 static event_avg_counter evt_test_avg("test_avg");
56 namespace varkeytest {
60 const string s0 = u64_varkey(1).str();
61 ALWAYS_ASSERT(s0.size() == 8);
62 const char e0[] = { 0, 0, 0, 0, 0, 0, 0, 1 };
63 ALWAYS_ASSERT(memcmp(s0.data(), &e0[0], 8) == 0);
64 cout << "varkey test passed" << endl;
68 namespace pxqueuetest {
76 static inline rcu::deleter_t
79 return (rcu::deleter_t) n;
84 operator()(const rcu::delete_entry &a,
85 const rcu::delete_entry &b) const
87 return (a.ptr < b.ptr) || (a.ptr == b.ptr && a.action < b.action);
94 typedef basic_px_queue<rcu::delete_entry, 8> px_queue;
98 for (size_t i = 0; i < 14; i++)
99 q0.enqueue(rcu::delete_entry(N2P(i), N2D(i)), 1);
100 ALWAYS_ASSERT(!q0.empty());
105 ALWAYS_ASSERT(p.ptr == N2P(i));
106 ALWAYS_ASSERT((rcu::deleter_t) p.action == N2D(i));
109 ALWAYS_ASSERT(i == 14);
112 q1.enqueue(rcu::delete_entry(N2P(123), N2D(543)), 1);
113 q1.enqueue(rcu::delete_entry(N2P(12345), N2D(54321)), 1);
115 auto q1_it = q1.begin();
116 ALWAYS_ASSERT(q1_it != q1.end());
117 ALWAYS_ASSERT(q1_it->ptr == N2P(123));
118 ALWAYS_ASSERT((rcu::deleter_t) q1_it->action == N2D(543));
120 ALWAYS_ASSERT(q1_it != q1.end());
121 ALWAYS_ASSERT(q1_it->ptr == N2P(12345));
122 ALWAYS_ASSERT((rcu::deleter_t) q1_it->action == N2D(54321));
124 ALWAYS_ASSERT(q1_it == q1.end());
129 q1.enqueue(rcu::delete_entry(N2P(1), N2D(1)), 1);
130 q1.enqueue(rcu::delete_entry(N2P(2), N2D(2)), 2);
135 q0.empty_accept_from(q1, 1);
136 ALWAYS_ASSERT(q0.get_ngroups() == 1);
137 ALWAYS_ASSERT(q1.get_ngroups() == 1);
139 vector<rcu::delete_entry> v0(q0.begin(), q0.end());
140 vector<rcu::delete_entry> v0test = {{N2P(1), N2D(1)}};
142 vector<rcu::delete_entry> v1(q1.begin(), q1.end());
143 vector<rcu::delete_entry> v1test = {{N2P(2), N2D(2)}};
145 sort(v0.begin(), v0.end(), sorter());
146 sort(v0test.begin(), v0test.end(), sorter());
147 sort(v1.begin(), v1.end(), sorter());
148 sort(v1test.begin(), v1test.end(), sorter());
150 ALWAYS_ASSERT(v0 == v0test);
151 ALWAYS_ASSERT(v1 == v1test);
154 ALWAYS_ASSERT(q0.empty());
158 ALWAYS_ASSERT(q1.empty());
164 q0.enqueue(rcu::delete_entry(N2P(1), N2D(1)), 1);
165 q0.enqueue(rcu::delete_entry(N2P(3), N2D(3)), 1);
167 q1.enqueue(rcu::delete_entry(N2P(2), N2D(2)), 1);
168 q1.enqueue(rcu::delete_entry(N2P(4), N2D(4)), 1);
169 q1.enqueue(rcu::delete_entry(N2P(6), N2D(6)), 2);
174 q0.transfer_freelist(q1);
178 q1.transfer_freelist(q0);
183 ALWAYS_ASSERT(q0.empty());
185 ALWAYS_ASSERT(q1.empty());
190 cout << "pxqueue test passed" << endl;
198 int values[] = {0, 1, 2, 3, 4};
199 circbuf<int, ARRAY_NELEMS(values)> b;
200 ALWAYS_ASSERT(b.empty());
201 for (size_t i = 0; i < ARRAY_NELEMS(values); i++) {
206 ALWAYS_ASSERT(pxs.size() == ARRAY_NELEMS(values));
207 ALWAYS_ASSERT(set<int *>(pxs.begin(), pxs.end()).size() == pxs.size());
208 for (size_t i = 0; i < ARRAY_NELEMS(values); i++)
209 ALWAYS_ASSERT(pxs[i] == &values[i]);
210 for (size_t i = 0; i < ARRAY_NELEMS(values); i++) {
211 ALWAYS_ASSERT(!b.empty());
212 ALWAYS_ASSERT(b.peek() == &values[i]);
213 ALWAYS_ASSERT(*b.peek() == values[i]);
214 ALWAYS_ASSERT(b.deq() == &values[i]);
216 ALWAYS_ASSERT(b.empty());
222 auto testlist = vector<int *>({&values[0], &values[1], &values[2]});
223 ALWAYS_ASSERT(pxs == testlist);
225 ALWAYS_ASSERT(b.deq() == &values[0]);
226 ALWAYS_ASSERT(b.deq() == &values[1]);
227 ALWAYS_ASSERT(b.deq() == &values[2]);
229 cout << "circbuf test passed" << endl;
235 #ifdef ENABLE_EVENT_COUNTERS
238 evt_test_avg.offer(1);
239 evt_test_avg.offer(2);
240 evt_test_avg.offer(3);
241 map<string, counter_data> m = event_counter::get_all_counters();
242 ALWAYS_ASSERT(m.find("test") != m.end());
243 ALWAYS_ASSERT(m.find("test1") != m.end());
244 ALWAYS_ASSERT(m.find("test_avg") != m.end());
246 ALWAYS_ASSERT(m["test"].count_ == 2);
247 ALWAYS_ASSERT(m["test1"].count_ == 0);
248 ALWAYS_ASSERT(m["test_avg"].count_ == 3);
249 ALWAYS_ASSERT(m["test_avg"].sum_ == 6);
250 ALWAYS_ASSERT(m["test_avg"].max_ == 3);
252 cout << "event counters test passed" << endl;
259 static_assert(CACHELINE_SIZE == 64, "xx");
260 static_assert(LG_CACHELINE_SIZE == 6, "xx");
262 const bool e0 = round_up<size_t, 1>(3) == 4;
264 const bool e1 = round_down<size_t, 1>(3) == 2;
266 const bool e2 = round_up<size_t, 1>(2) == 2;
268 const bool e3 = round_down<size_t, 1>(2) == 2;
270 const bool e4 = round_down<size_t, LG_CACHELINE_SIZE>(2) == 0;
272 const bool e5 = round_down<size_t, LG_CACHELINE_SIZE>(CACHELINE_SIZE) == CACHELINE_SIZE;
274 const bool e6 = round_down<size_t, LG_CACHELINE_SIZE>(CACHELINE_SIZE + 10) == CACHELINE_SIZE;
277 cout << "util test passed" << endl;
280 namespace small_vector_ns {
282 typedef small_vector<string, 4> vec_type;
283 typedef static_vector<string, 4> static_vec_type;
284 typedef vector<string> stl_vec_type;
286 template <typename VecType>
288 init_vec0(VecType &v)
290 ALWAYS_ASSERT(v.empty());
291 ALWAYS_ASSERT(v.size() == 0);
294 ALWAYS_ASSERT(!v.empty());
295 ALWAYS_ASSERT(v.size() == 1);
296 ALWAYS_ASSERT(v.front() == "a");
297 ALWAYS_ASSERT(v.back() == "a");
300 ALWAYS_ASSERT(v.size() == 2);
301 ALWAYS_ASSERT(v.front() == "a");
302 ALWAYS_ASSERT(v.back() == "b");
305 ALWAYS_ASSERT(v.size() == 3);
306 ALWAYS_ASSERT(v.front() == "a");
307 ALWAYS_ASSERT(v.back() == "c");
310 ALWAYS_ASSERT(v.size() == 4);
311 ALWAYS_ASSERT(v.front() == "a");
312 ALWAYS_ASSERT(v.back() == "d");
315 template <typename VecType>
317 init_vec1(VecType &v)
319 ALWAYS_ASSERT(v.empty());
320 ALWAYS_ASSERT(v.size() == 0);
323 ALWAYS_ASSERT(!v.empty());
324 ALWAYS_ASSERT(v.size() == 1);
325 ALWAYS_ASSERT(v.front() == "a");
326 ALWAYS_ASSERT(v.back() == "a");
329 ALWAYS_ASSERT(v.size() == 2);
330 ALWAYS_ASSERT(v.front() == "a");
331 ALWAYS_ASSERT(v.back() == "b");
334 ALWAYS_ASSERT(v.size() == 3);
335 ALWAYS_ASSERT(v.front() == "a");
336 ALWAYS_ASSERT(v.back() == "c");
339 ALWAYS_ASSERT(v.size() == 4);
340 ALWAYS_ASSERT(v.front() == "a");
341 ALWAYS_ASSERT(v.back() == "d");
344 ALWAYS_ASSERT(v.size() == 5);
345 ALWAYS_ASSERT(v.front() == "a");
346 ALWAYS_ASSERT(v.back() == "e");
349 ALWAYS_ASSERT(v.size() == 6);
350 ALWAYS_ASSERT(v.front() == "a");
351 ALWAYS_ASSERT(v.back() == "f");
354 template <typename VecA, typename VecB>
356 assert_vecs_equal(VecA &v, const VecB &stl_v)
358 ALWAYS_ASSERT(v.size() == stl_v.size());
359 VecB tmp(v.begin(), v.end());
360 ALWAYS_ASSERT(tmp == stl_v);
362 VecB tmp1(cv.begin(), cv.end());
363 ALWAYS_ASSERT(tmp1 == stl_v);
376 foo(int a, int b, int c, int d)
377 : a(a), b(b), c(c), d(d)
383 operator()(const pair<uint32_t, uint32_t> &a,
384 const pair<uint32_t, uint32_t> &b) const
386 return a.first < b.first;
395 static_vec_type static_v;
403 ALWAYS_ASSERT(v_assign.empty());
406 static_vec_type static_v_copy(static_v);
407 static_vec_type static_v_assign;
408 ALWAYS_ASSERT(static_v_assign.empty());
409 static_v_assign = static_v;
411 assert_vecs_equal(v, stl_v);
412 assert_vecs_equal(v_copy, stl_v);
413 assert_vecs_equal(v_assign, stl_v);
415 assert_vecs_equal(static_v, stl_v);
416 assert_vecs_equal(static_v_copy, stl_v);
417 assert_vecs_equal(static_v_assign, stl_v);
420 assert_vecs_equal(v, stl_vec_type());
423 assert_vecs_equal(static_v, stl_vec_type());
433 ALWAYS_ASSERT(v_assign.empty());
435 assert_vecs_equal(v, stl_v);
436 assert_vecs_equal(v_copy, stl_v);
437 assert_vecs_equal(v_assign, stl_v);
439 assert_vecs_equal(v, stl_vec_type());
443 for (int iter = 0; iter < 10; iter++) {
445 for (int i = 0; i < 20; i++) {
446 v.push_back(foo(i, i + 1, i + 2, i + 3));
447 ALWAYS_ASSERT(v.back().a == i);
448 ALWAYS_ASSERT(v.back().b == (i + 1));
449 ALWAYS_ASSERT(v.back().c == (i + 2));
450 ALWAYS_ASSERT(v.back().d == (i + 3));
451 ALWAYS_ASSERT(v[i].a == i);
452 ALWAYS_ASSERT(v[i].b == (i + 1));
453 ALWAYS_ASSERT(v[i].c == (i + 2));
454 ALWAYS_ASSERT(v[i].d == (i + 3));
456 for (int i = 0; i < 20; i++) {
457 ALWAYS_ASSERT(v[i].a == i);
458 ALWAYS_ASSERT(v[i].b == (i + 1));
459 ALWAYS_ASSERT(v[i].c == (i + 2));
460 ALWAYS_ASSERT(v[i].d == (i + 3));
473 sort(v.begin(), v.end());
475 small_vector<int> v1;
490 stl_v.push_back(100);
491 sort(stl_v.begin(), stl_v.end());
493 assert_vecs_equal(v, stl_v);
494 assert_vecs_equal(v1, stl_v);
498 small_vector<int, 3> v;
505 sort(v.begin(), v.end());
507 small_vector<int, 3> v1;
522 stl_v.push_back(100);
523 sort(stl_v.begin(), stl_v.end());
525 assert_vecs_equal(v, stl_v);
526 assert_vecs_equal(v1, stl_v);
530 fast_random r(29395);
531 small_vector< pair<uint32_t, uint32_t> > v;
532 vector< pair<uint32_t, uint32_t> > stl_v;
533 for (size_t i = 0; i < 48; i++) {
534 uint32_t x = r.next();
535 v.push_back(make_pair(x, x + 1));
536 stl_v.push_back(make_pair(x, x + 1));
538 sort(v.begin(), v.end(), PComp());
539 sort(stl_v.begin(), stl_v.end(), PComp());
540 assert_vecs_equal(v, stl_v);
541 for (size_t i = 0; i < 48; i++)
542 ALWAYS_ASSERT(v[i].first + 1 == v[i].second);
546 // test C++11 features
547 small_vector<string, 4> v;
548 v.emplace_back("hello");
549 string world = "world";
550 v.push_back(move(world));
551 //ALWAYS_ASSERT(world.empty());
552 ALWAYS_ASSERT(v.size() == 2);
553 ALWAYS_ASSERT(v[0] == "hello");
554 ALWAYS_ASSERT(v[1] == "world");
560 v0.emplace_back("a");
561 v0.emplace_back("b");
562 v0.emplace_back("c");
563 v0.emplace_back("d");
566 sv0.emplace_back("a");
567 sv0.emplace_back("b");
568 sv0.emplace_back("c");
569 sv0.emplace_back("d");
571 stl_vec_type test(v0.rbegin(), v0.rend());
572 stl_vec_type svtest(sv0.rbegin(), sv0.rend());
573 ALWAYS_ASSERT(test == svtest);
575 v0.emplace_back("e");
576 sv0.emplace_back("e");
578 stl_vec_type test1(v0.rbegin(), v0.rend());
579 stl_vec_type svtest1(sv0.rbegin(), sv0.rend());
580 ALWAYS_ASSERT(test1 == svtest1);
583 cout << "vec test passed" << endl;
588 namespace small_map_ns {
590 typedef small_unordered_map<string, string, 4> map_type;
591 typedef static_unordered_map<string, string, 4> static_map_type;
592 typedef map<string, string> stl_map_type;
594 template <typename MapType>
596 assert_map_contains(MapType &m, const string &k, const string &v)
598 ALWAYS_ASSERT(!m.empty());
599 ALWAYS_ASSERT(m[k] == v);
601 typename MapType::iterator it = m.find(k);
602 ALWAYS_ASSERT(it != m.end());
603 ALWAYS_ASSERT(it->first == k);
604 ALWAYS_ASSERT(it->second == v);
606 const MapType &const_m = m;
608 typename MapType::const_iterator it = const_m.find(k);
609 ALWAYS_ASSERT(it != const_m.end());
610 ALWAYS_ASSERT(it->first == k);
611 ALWAYS_ASSERT(it->second == v);
615 template <typename MapType>
617 assert_map_equals(MapType &m, const stl_map_type &stl_m)
619 ALWAYS_ASSERT(m.size() == stl_m.size());
621 // reg version prefix
624 for (typename MapType::iterator it = m.begin();
625 it != m.end(); ++it) {
626 ALWAYS_ASSERT(test.find(it->first) == test.end());
627 test[it->first] = it->second;
629 ALWAYS_ASSERT(test == stl_m);
632 // reg version postfix
635 for (typename MapType::iterator it = m.begin();
636 it != m.end(); it++) {
637 ALWAYS_ASSERT(test.find(it->first) == test.end());
638 test[it->first] = it->second;
640 ALWAYS_ASSERT(test == stl_m);
643 // const version prefix
645 const MapType &const_m = m;
647 for (typename MapType::const_iterator it = const_m.begin();
648 it != const_m.end(); ++it) {
649 ALWAYS_ASSERT(test.find(it->first) == test.end());
650 test[it->first] = it->second;
652 ALWAYS_ASSERT(test == stl_m);
655 // const version postfix
657 const MapType &const_m = m;
659 for (typename MapType::const_iterator it = const_m.begin();
660 it != const_m.end(); it++) {
661 ALWAYS_ASSERT(test.find(it->first) == test.end());
662 test[it->first] = it->second;
664 ALWAYS_ASSERT(test == stl_m);
668 template <typename T>
678 template <typename T>
695 static_map_type static_m, static_m_copy;
701 ALWAYS_ASSERT(m.is_small_type());
702 ALWAYS_ASSERT(static_m.is_small_type());
703 INVARIANT(m.size() == 4);
704 INVARIANT(static_m.size() == 4);
708 ALWAYS_ASSERT(m_copy.is_small_type());
710 ALWAYS_ASSERT(m_copy.is_small_type());
711 INVARIANT(m_copy.size() == 4);
713 static_m_copy = static_m;
714 INVARIANT(static_m_copy.size() == 4);
716 map_type m_construct(m);
717 INVARIANT(m_construct.size() == 4);
718 for (stl_map_type::iterator it = stl_m.begin();
719 it != stl_m.end(); ++it) {
720 assert_map_contains(m, it->first, it->second);
721 assert_map_contains(m_copy, it->first, it->second);
722 assert_map_contains(m_construct, it->first, it->second);
724 assert_map_equals(m, stl_m);
725 assert_map_equals(m_copy, stl_m);
726 assert_map_equals(m_construct, stl_m);
727 ALWAYS_ASSERT(m.is_small_type());
728 ALWAYS_ASSERT(m_copy.is_small_type());
729 ALWAYS_ASSERT(m_construct.is_small_type());
731 static_map_type static_m_construct(static_m);
732 INVARIANT(static_m_construct.size() == 4);
733 for (stl_map_type::iterator it = stl_m.begin();
734 it != stl_m.end(); ++it) {
735 assert_map_contains(static_m, it->first, it->second);
736 assert_map_contains(static_m_copy, it->first, it->second);
737 assert_map_contains(static_m_construct, it->first, it->second);
739 assert_map_equals(static_m, stl_m);
740 assert_map_equals(static_m_copy, stl_m);
741 assert_map_equals(static_m_construct, stl_m);
742 ALWAYS_ASSERT(static_m.is_small_type());
743 ALWAYS_ASSERT(static_m_copy.is_small_type());
744 ALWAYS_ASSERT(static_m_construct.is_small_type());
753 map_type m_construct(m);
754 for (stl_map_type::iterator it = stl_m.begin();
755 it != stl_m.end(); ++it) {
756 assert_map_contains(m, it->first, it->second);
757 assert_map_contains(m_copy, it->first, it->second);
759 assert_map_equals(m, stl_m);
760 assert_map_equals(m_copy, stl_m);
761 assert_map_equals(m_construct, stl_m);
766 ALWAYS_ASSERT(m.empty());
767 ALWAYS_ASSERT(m.size() == 0);
769 ALWAYS_ASSERT(!m.empty());
770 ALWAYS_ASSERT(m.size() == 1);
772 ALWAYS_ASSERT(!m.empty());
773 ALWAYS_ASSERT(m.size() == 2);
775 ALWAYS_ASSERT(!m.empty());
776 ALWAYS_ASSERT(m.size() == 2);
778 ALWAYS_ASSERT(!m.empty());
779 ALWAYS_ASSERT(m.size() == 3);
781 ALWAYS_ASSERT(!m.empty());
782 ALWAYS_ASSERT(m.size() == 4);
785 ALWAYS_ASSERT(m.empty());
786 ALWAYS_ASSERT(m.size() == 0);
794 ALWAYS_ASSERT(!m.empty());
795 ALWAYS_ASSERT(m.size() == 5);
798 { // check primitive key type maps
799 small_unordered_map<int, int> m;
803 ALWAYS_ASSERT(m.find(0) != m.end());
804 ALWAYS_ASSERT(m.find(1) != m.end());
805 ALWAYS_ASSERT(m.find(2) != m.end());
806 ALWAYS_ASSERT(m.find(0)->first == 0 && m.find(0)->second == 1);
807 ALWAYS_ASSERT(m.find(1)->first == 1 && m.find(1)->second == 2);
808 ALWAYS_ASSERT(m.find(2)->first == 2 && m.find(2)->second == 3);
811 cout << "map test passed" << endl;
815 namespace recordtest {
818 operator<<(ostream &o, const myrec::key &k)
820 o << "[k0=" << k.k0 << ", k1=" << k.k1 << "]" << endl;
825 operator<<(ostream &o, const myrec::value &v)
827 o << "[v0=" << v.v0 << ", v1=" << v.v1 << "]" << endl;
834 const cursorrec::value v(12345, 1, 54321, "foo", "bar", 98765, 2);
835 const string enc_v = Encode(v);
837 read_record_cursor<cursorrec> rc((const uint8_t *) enc_v.data(), enc_v.size());
838 for (size_t i = rc.field();
839 i < cursorrec::value_descriptor::nfields();
841 rc.read_current_and_advance(&v0);
842 ALWAYS_ASSERT(v == v0);
844 // mutate v2 => 98765432, v4 => "asdfasdfasdf"
846 v0.v4.assign("asdfasdfasdf");
850 const size_t v2_oldsz = rc.read_current_raw_size_and_advance();
852 const size_t v4_oldsz = rc.read_current_raw_size_and_advance();
854 typedef serializer<int32_t, true> si32;
855 typedef serializer<inline_str_fixed<25>, true> sistr25;
856 ALWAYS_ASSERT(si32::nbytes(&v.v2) == v2_oldsz);
857 ALWAYS_ASSERT(sistr25::nbytes(&v.v4) == v4_oldsz);
858 ALWAYS_ASSERT(cursorrec::value_descriptor::nbytes_fn(2)((const uint8_t *) &v.v2) == v2_oldsz);
859 ALWAYS_ASSERT(cursorrec::value_descriptor::nbytes_fn(4)((const uint8_t *) &v.v4) == v4_oldsz);
861 const size_t v2_newsz =
862 cursorrec::value_descriptor::nbytes_fn(2)((const uint8_t *) &v0.v2);
863 const size_t v4_newsz =
864 cursorrec::value_descriptor::nbytes_fn(4)((const uint8_t *) &v0.v4);
866 uint8_t v2_oldraw_v[cursorrec::value_descriptor::max_nbytes(2)];
867 uint8_t v4_oldraw_v[cursorrec::value_descriptor::max_nbytes(4)];
869 string enc_v0 = enc_v;
870 if ((v2_oldsz + v4_oldsz) < (v2_newsz + v4_newsz))
872 enc_v0.resize(enc_v0.size() + (v2_newsz + v4_newsz) - (v2_oldsz + v4_oldsz));
873 write_record_cursor<cursorrec> wc((uint8_t *) enc_v0.data());
875 wc.write_current_and_advance(&v0, &v2_oldraw_v[0]);
877 wc.write_current_and_advance(&v0, &v4_oldraw_v[0]);
879 read_record_cursor<cursorrec> rc1((const uint8_t *) enc_v0.data(), enc_v0.size());
881 for (size_t i = rc1.field();
882 i < cursorrec::value_descriptor::nfields();
884 rc1.read_current_and_advance(&v2);
885 ALWAYS_ASSERT(v2 == v0);
886 cerr << "v2: " << v2 << endl;
887 cerr << "v0: " << v2 << endl;
893 const myrec::key k0(123, 456);
894 const myrec::key k1(999, 123);
895 const myrec::key k2(123, 457);
896 myrec::key k0_temp, k1_temp, k2_temp;
898 ALWAYS_ASSERT(Size(k0) == sizeof(k0));
899 ALWAYS_ASSERT(Size(k1) == sizeof(k1));
900 ALWAYS_ASSERT(Size(k2) == sizeof(k2));
903 const string s0 = Encode(k0);
904 const string s1 = Encode(k1);
905 const string s2 = Encode(k2);
906 ALWAYS_ASSERT(s0 < s1);
907 ALWAYS_ASSERT(s0 < s2);
911 ALWAYS_ASSERT(k0 == k0_temp);
912 ALWAYS_ASSERT(k1 == k1_temp);
913 ALWAYS_ASSERT(k2 == k2_temp);
916 const myrec::key *p0 = Decode(Encode(k0), k0_temp);
917 const myrec::key *p1 = Decode(Encode(k1), k1_temp);
918 const myrec::key *p2 = Decode(Encode(k2), k2_temp);
919 ALWAYS_ASSERT(*p0 == k0);
920 ALWAYS_ASSERT(*p1 == k1);
921 ALWAYS_ASSERT(*p2 == k2);
924 const myrec::value v0(859435, 2834);
925 const myrec::value v1(0, 73);
926 const myrec::value v2(654, 8);
927 myrec::value v0_temp, v1_temp, v2_temp;
930 const size_t sz0 = Size(v0);
931 const size_t sz1 = Size(v1);
932 const size_t sz2 = Size(v2);
933 uint8_t buf0[sz0], buf1[sz1], buf2[sz2];
938 const string s0((const char *) buf0, sz0);
939 const string s1((const char *) buf1, sz1);
940 const string s2((const char *) buf2, sz2);
945 ALWAYS_ASSERT(v0 == v0_temp);
946 ALWAYS_ASSERT(v1 == v1_temp);
947 ALWAYS_ASSERT(v2 == v2_temp);
952 cout << "encoder test passed" << endl;
957 class main_thread : public ndb_thread {
959 main_thread(int argc, char **argv)
960 : ndb_thread(false, string("main")),
961 argc(argc), argv(argv), ret(0)
967 #ifndef CHECK_INVARIANTS
968 cerr << "WARNING: tests are running without invariant checking" << endl;
970 cerr << "PID: " << getpid() << endl;
974 // initialize the numa allocator subsystem with the number of CPUs running
975 // + reasonable size per core
976 ::allocator::Initialize(coreid::num_cpus_online(), size_t(128 * (1<<20)));
977 #ifdef PROTO2_CAN_DISABLE_GC
978 transaction_proto2_static::InitGC();
980 //varkeytest::Test();
981 //pxqueuetest::Test();
985 //small_vector_ns::Test();
986 //small_map_ns::Test();
987 //recordtest::Test();
989 extern void TestConcurrentBtreeFast();
990 extern void TestConcurrentBtreeSlow();
991 // either tests Masstree or Silotree, depending on NDB_MASSTREE
992 TestConcurrentBtreeFast();
993 TestConcurrentBtreeSlow();
1010 main(int argc, char **argv)
1012 main_thread t(argc, argv);