//! 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;
}
