//! Testing upper_bound compatibility //! \param volume Volume int run_upper_bound_test(size_t volume) { const size_t size = volume / sizeof(value_type); STXXL_CHECK(volume > ea_type::block_size); STXXL_VARDUMP(size); STXXL_CHECK(size > 2000); ea_type::pool_type rw_pool; std::vector<value_type> v(size); { stxxl::scoped_print_timer timer("filling vector / internal array", volume); for (size_t i = 0; i < size; ++i) { v[i] = std::make_pair(i + 1, i + 1); } } ia_type a(v); ea_type b(size - 10, &rw_pool); { stxxl::scoped_print_timer timer("filling external array", volume); ea_type::writer_type ea_writer(b, 1); ea_type::writer_type::iterator it = ea_writer.begin(); for (size_t i = 0; i < size - 10; ++i, ++it) { *it = std::make_pair(2 * i, 2 * i); } it = ea_writer.begin(); for (size_t i = 0; i < size - 10; ++i, ++it) { STXXL_CHECK_EQUAL(it->first, 2 * i); } } { stxxl::scoped_print_timer timer("running upper_bound", 2 * volume); b.hint_next_block(); b.wait_next_blocks(); value_type minmax = std::make_pair(2000, 2000); ea_type::iterator uba = std::upper_bound(a.begin(), a.end(), minmax, value_comp()); ea_type::iterator ubb = std::upper_bound(b.begin(), b.end(), minmax, value_comp()); STXXL_CHECK_EQUAL((uba - 1)->first, 2000); STXXL_CHECK_EQUAL((ubb - 1)->first, 2000); STXXL_CHECK_EQUAL(uba->first, 2001); STXXL_CHECK_EQUAL(ubb->first, 2002); STXXL_CHECK_EQUAL(uba.get_index(), 2000); STXXL_CHECK_EQUAL(ubb.get_index(), 1001); } return EXIT_SUCCESS; }
void exit_handler_intel_x64::unittest_1009_containers_set() const { auto myset = std::set<int>({0, 1, 2, 3}); auto myset2 = std::set<int>({0, 1, 2, 3}); auto total = 0; for (auto iter = myset.begin(); iter != myset.end(); iter++) total += *iter; auto rtotal = 0; for (auto iter = myset.rbegin(); iter != myset.rend(); iter++) rtotal += *iter; auto ctotal = 0; for (auto iter = myset.cbegin(); iter != myset.cend(); iter++) ctotal += *iter; auto crtotal = 0; for (auto iter = myset.crbegin(); iter != myset.crend(); iter++) crtotal += *iter; expect_true(total == 6); expect_true(rtotal == 6); expect_true(ctotal == 6); expect_true(crtotal == 6); expect_true(myset.size() == 4); expect_true(myset.max_size() >= 4); expect_false(myset.empty()); myset.insert(myset.begin(), 0); myset.erase(myset.begin()); myset = myset2; myset.swap(myset2); myset.swap(myset2); myset.emplace(); myset.emplace_hint(myset.begin()); myset = myset2; myset.key_comp(); myset.value_comp(); expect_true(myset.find(0) != myset.end()); expect_true(myset.count(0) == 1); expect_true(myset.lower_bound(0) != myset.end()); expect_true(myset.upper_bound(0) != myset.end()); myset.equal_range(0); myset.get_allocator(); myset.clear(); }
Cmp const & get_internal_cmp(void) const { return value_comp(); }
bool operator()(internal_type const & lhs, internal_type const & rhs) const { return value_comp().operator()(lhs, rhs); }
void exit_handler_intel_x64::unittest_100A_containers_map() const { auto mymap = std::map<int, int>(); auto mymap2 = std::map<int, int>(); mymap2[0] = 0; mymap2[1] = 1; mymap2[2] = 2; mymap2[3] = 3; mymap = mymap2; auto total = 0; for (auto iter = mymap.begin(); iter != mymap.end(); iter++) total += iter->second; auto rtotal = 0; for (auto iter = mymap.rbegin(); iter != mymap.rend(); iter++) rtotal += iter->second; auto ctotal = 0; for (auto iter = mymap.cbegin(); iter != mymap.cend(); iter++) ctotal += iter->second; auto crtotal = 0; for (auto iter = mymap.crbegin(); iter != mymap.crend(); iter++) crtotal += iter->second; expect_true(total == 6); expect_true(rtotal == 6); expect_true(ctotal == 6); expect_true(crtotal == 6); expect_true(mymap.size() == 4); expect_true(mymap.max_size() >= 4); expect_false(mymap.empty()); expect_true(mymap.at(0) == 0); expect_true(mymap.at(3) == 3); mymap.insert(std::pair<int, int>(4, 4)); mymap.erase(4); mymap = mymap2; mymap.swap(mymap2); mymap.swap(mymap2); mymap.emplace(); mymap.emplace_hint(mymap.begin(), std::pair<int, int>(4, 4)); mymap = mymap2; mymap.key_comp(); mymap.value_comp(); expect_true(mymap.find(0) != mymap.end()); expect_true(mymap.count(0) == 1); expect_true(mymap.lower_bound(0) != mymap.end()); expect_true(mymap.upper_bound(0) != mymap.end()); mymap.equal_range(0); mymap.get_allocator(); mymap.clear(); }
int run_multiway_merge(size_t volume) { const size_t block_size = ea_type::block_size; const size_t size = volume / sizeof(value_type); const size_t num_blocks = stxxl::div_ceil(size, block_size); STXXL_MSG("--- Running run_multiway_merge() test with " << NumEAs << " external arrays"); STXXL_VARDUMP(block_size); STXXL_VARDUMP(size); STXXL_VARDUMP(num_blocks); std::vector<value_type> v(size); { stxxl::scoped_print_timer timer("filling vector / internal array for multiway_merge test", volume); for (size_t i = 0; i < size; ++i) { v[i] = std::make_pair(i + 1, i + 1); } } ia_type ia(v); typedef std::vector<ea_type*> ea_vector_type; typedef ea_vector_type::iterator ea_iterator; ea_type::pool_type rw_pool1; ea_vector_type ealist; for (int i = 0; i < NumEAs; ++i) ealist.push_back(new ea_type(size, &rw_pool1)); ea_type::pool_type rw_pool2; ea_type out(size * (NumEAs + 1), &rw_pool2); { stxxl::scoped_print_timer timer("filling external arrays for multiway_merge test", volume * NumEAs); for (ea_iterator ea = ealist.begin(); ea != ealist.end(); ++ea) fill(*(*ea), 0, size); } { stxxl::scoped_print_timer timer("loading input arrays into RAM and requesting output buffer", volume * NumEAs); if (ealist.size()) rw_pool1.resize_prefetch(ealist.size() * ealist[0]->num_blocks()); for (ea_iterator ea = ealist.begin(); ea != ealist.end(); ++ea) { while ((*ea)->has_unhinted_em_data()) (*ea)->hint_next_block(); while ((*ea)->num_hinted_blocks()) (*ea)->wait_next_blocks(); } for (ea_iterator ea = ealist.begin(); ea != ealist.end(); ++ea) STXXL_CHECK_EQUAL((*ea)->buffer_size(), size); } if (NumEAs > 0) // test ea ppq_iterators { stxxl::scoped_print_timer timer("test ea ppq_iterators", volume); ea_type::iterator begin = ealist[0]->begin(), end = ealist[0]->end(); size_t index = 1; // prefix operator ++ for (ea_type::iterator it = begin; it != end; ++it, ++index) STXXL_CHECK_EQUAL(it->first, index); // prefix operator -- for (ea_type::iterator it = end; it != begin; ) { --it, --index; STXXL_CHECK_EQUAL(it->first, index); } STXXL_CHECK_EQUAL(index, 1); // addition operator + for (ea_type::iterator it = begin; it != end; it = it + 1, ++index) STXXL_CHECK_EQUAL(it->first, index); // subtraction operator - for (ea_type::iterator it = end; it != begin; ) { it = it - 1, --index; STXXL_CHECK_EQUAL(it->first, index); } } { stxxl::scoped_print_timer timer("running multiway merge", volume * (NumEAs + 1)); std::vector<std::pair<ea_type::iterator, ea_type::iterator> > seqs; for (ea_iterator ea = ealist.begin(); ea != ealist.end(); ++ea) seqs.push_back(std::make_pair((*ea)->begin(), (*ea)->end())); seqs.push_back(std::make_pair(ia.begin(), ia.end())); ea_type::writer_type ea_writer(out); stxxl::potentially_parallel::multiway_merge( seqs.begin(), seqs.end(), ea_writer.begin(), (NumEAs + 1) * size, value_comp()); // sequential: //__gnu_parallel::multiway_merge(seqs.begin(), seqs.end(), c.begin(), // 2*size, value_comp()); // , __gnu_parallel::sequential_tag() } { stxxl::scoped_print_timer timer("checking the order", volume * NumEAs); // each index is contained (NumEAs + 1) times size_t index = 1 * (NumEAs + 1); while (out.has_em_data()) { out.hint_next_block(); out.wait_next_blocks(); for (ea_type::iterator it = out.begin(); it != out.end(); ++it) { progress("Extracting element", index, (NumEAs + 1) * size); STXXL_CHECK_EQUAL(it->first, index / (NumEAs + 1)); ++index; } out.remove_items(out.buffer_size()); } } return EXIT_SUCCESS; }