Stxxl  1.3.2
containers/test_vector.cpp

This is an example of use of stxxl::vector and stxxl::VECTOR_GENERATOR. Vector type is configured to store 64-bit integers and have 2 pages each of 1 block

/***************************************************************************
* containers/test_vector.cpp
*
* Part of the STXXL. See http://stxxl.sourceforge.net
*
* Copyright (C) 2002, 2003, 2006 Roman Dementiev <[email protected]>
* Copyright (C) 2010 Johannes Singler <[email protected]>
*
* Distributed under the Boost Software License, Version 1.0.
* (See accompanying file LICENSE_1_0.txt or copy at
* http://www.boost.org/LICENSE_1_0.txt)
**************************************************************************/
#include <iostream>
#include <algorithm>
#include <stxxl/vector>
#include <stxxl/scan>
struct element // 24 bytes, not a power of 2 intentionally
{
stxxl::int64 key;
stxxl::int64 load0;
stxxl::int64 load1;
element & operator = (stxxl::int64 i)
{
key = i;
load0 = i + 42;
load1 = i ^ 42;
return *this;
}
bool operator == (const element & e2) const
{
return key == e2.key && load0 == e2.load0 && load1 == e2.load1;
}
};
struct counter
{
int value;
counter(int v) : value(v) { }
int operator () ()
{
int old_val = value;
value++;
return old_val;
}
};
template <class my_vec_type>
void test_const_iterator(const my_vec_type & x)
{
typename my_vec_type::const_iterator i = x.begin();
i = x.end() - 1;
i.block_externally_updated();
i.flush();
i++;
++i;
--i;
i--;
*i;
}
int main()
{
try
{
// use non-randomized striping to avoid side effects on random generator
typedef stxxl::VECTOR_GENERATOR<element, 2, 2, (2 * 1024 * 1024), stxxl::striping>::result vector_type;
vector_type v(64 * 1024 * 1024 / sizeof(element));
// test assignment const_iterator = iterator
vector_type::const_iterator c_it = v.begin();
STXXL_UNUSED(c_it);
unsigned int big_size = 1024 * 1024 * 2 * 16 * 16;
typedef stxxl::vector<double> vec_big;
vec_big my_vec(big_size);
vec_big::iterator big_it = my_vec.begin();
big_it += 6;
test_const_iterator(v);
stxxl::random_number32 rnd;
int offset = rnd();
STXXL_MSG("write " << v.size() << " elements");
stxxl::ran32State = 0xdeadbeef;
vector_type::size_type i;
// fill the vector with increasing sequence of integer numbers
for (i = 0; i < v.size(); ++i)
{
v[i].key = i + offset;
assert(v[i].key == stxxl::int64(i + offset));
}
// fill the vector with random numbers
stxxl::generate(v.begin(), v.end(), stxxl::random_number32(), 4);
v.flush();
STXXL_MSG("seq read of " << v.size() << " elements");
stxxl::ran32State = 0xdeadbeef;
// testing swap
vector_type a;
std::swap(v, a);
std::swap(v, a);
for (i = 0; i < v.size(); i++)
assert(v[i].key == rnd());
// check again
STXXL_MSG("clear");
v.clear();
stxxl::ran32State = 0xdeadbeef + 10;
v.resize(64 * 1024 * 1024 / sizeof(element));
STXXL_MSG("write " << v.size() << " elements");
stxxl::generate(v.begin(), v.end(), stxxl::random_number32(), 4);
stxxl::ran32State = 0xdeadbeef + 10;
STXXL_MSG("seq read of " << v.size() << " elements");
for (i = 0; i < v.size(); i++)
assert(v[i].key == rnd());
STXXL_MSG("copy vector of " << v.size() << " elements");
vector_type v_copy0(v);
assert(v == v_copy0);
vector_type v_copy1;
v_copy1 = v;
assert(v == v_copy1);
}
catch (const std::exception & ex)
{
STXXL_MSG("Caught exception: " << ex.what());
}
catch (...)
{
STXXL_MSG("Caught unknown exception.");
}
return 0;
}