test/core/test_big_hash_map.cpp

Go to the documentation of this file.

// test_big_hash_map.cpp -*- C++ -*-
// Copyright (C) 2011 Martin Trenkmann
#include <string>
#include <ostream>
#include <utility>
#include <boost/test/unit_test.hpp>
#include <boost/type_traits.hpp>

#include "generator.hpp"
#include "core/builder.hpp"
#include "core/big_hash_map.hpp"
#include "util/conversion.hpp"

using namespace aitools;

template <typename T>
struct record_generator
{
        typedef std::pair<std::string, T> record_type;

        record_generator()
        :       counter(0)
        {}

        const record_type operator()()
        {
                record_type record;
                record.first.assign("key");
                record.first += util::to_string(counter++);
                aitools::generator<T>::randomized(record.second);
                return record;
        }

        unsigned counter;
};

namespace std {

template <typename T>
ostream&
operator<<(ostream& os, const std::pair<std::string, T>& record)
{
        if (os)
        {
                os << record.first << '\t';
                value::value_traits<T>::print_to(record.second, os);
        }
        return os;
}
} // namespace std

template <typename T>
void
test(aitools::memory_type mode, size_t record_count)
{
        typedef std::pair<std::string, T>         record_type;
        typedef bighashmap::core::big_hash_map<T> hashmap_type;

        // -------------------------------------------------------------------------
        // Create records and write them to a text file.
        // -------------------------------------------------------------------------
        std::vector<record_type> records(record_count);
        std::generate(records.begin(), records.end(), record_generator<T>());
        const bfs::path input_file("bhm_test_input/records");
        const bfs::path output_dir("bhm_test_output");
        BOOST_REQUIRE(bfs::create_directory(input_file.parent_path()));
        BOOST_REQUIRE(bfs::create_directory(output_dir));
        bfs::ofstream ofs(input_file);
        BOOST_REQUIRE(ofs);
        // enable fixed floating-point notation
        ofs.setf(std::ios::fixed, std::ios::floatfield);
        std::copy(records.begin(), records.end(),
                        std::ostream_iterator<record_type>(ofs, "\n"));
        ofs.close();
        // -------------------------------------------------------------------------
        // Build a BigHashMap from the input record file.
        // -------------------------------------------------------------------------
        const bfs::path idx_file(bighashmap::core::builder<T>::build(
                        input_file.parent_path(), output_dir));
        // -------------------------------------------------------------------------
        // Open the BigHashMap and lookup the entire known key set.
        // -------------------------------------------------------------------------
        typename hashmap_type::value_type value;
        hashmap_type* bhm(hashmap_type::open(idx_file, mode));
        for (auto it(records.begin()); it != records.end(); ++it)
        {
                BOOST_REQUIRE(bhm->find(it->first, value));
                BOOST_REQUIRE_EQUAL(it->second, value);
        }
        // -------------------------------------------------------------------------
        // Lookup a set of unknown keys (should not find anything).
        // -------------------------------------------------------------------------
        for (unsigned i(0); i != record_count; ++i)
        {
                BOOST_REQUIRE(!bhm->find(util::to_string(std::rand()), value));
        }
        delete bhm;
        bfs::remove_all(output_dir);
        bfs::remove_all(input_file.parent_path());
}

// TEST CASES

BOOST_AUTO_TEST_SUITE(test_big_hash_map);

static const size_t k_record_count(100000);

BOOST_AUTO_TEST_CASE(test_i32_external)
{
        test<int32_t>(aitools::memory_type::min_required, k_record_count);
}

BOOST_AUTO_TEST_CASE(test_i32_internal)
{
        test<int32_t>(aitools::memory_type::mb4096, k_record_count);
}

BOOST_AUTO_TEST_CASE(test_i64_external)
{
        test<int64_t>(aitools::memory_type::min_required, k_record_count);
}

BOOST_AUTO_TEST_CASE(test_i64_internal)
{
        test<int64_t>(aitools::memory_type::mb4096, k_record_count);
}

BOOST_AUTO_TEST_CASE(test_dbl_external)
{
        test<double>(aitools::memory_type::min_required, k_record_count);
}

BOOST_AUTO_TEST_CASE(test_dbl_internal)
{
        test<double>(aitools::memory_type::mb4096, k_record_count);
}

BOOST_AUTO_TEST_CASE(test_i32_i64_external)
{
        typedef value::pair<int32_t, int64_t> value_type;
        test<value_type>(aitools::memory_type::min_required, k_record_count);
}

BOOST_AUTO_TEST_CASE(test_i32_i64_internal)
{
        typedef value::pair<int32_t, int64_t> value_type;
        test<value_type>(aitools::memory_type::mb4096, k_record_count);
}

BOOST_AUTO_TEST_CASE(test_i32_dbl_external)
{
        typedef value::pair<int32_t, double> value_type;
        test<value_type>(aitools::memory_type::min_required, k_record_count);
}

BOOST_AUTO_TEST_CASE(test_i32_dbl_internal)
{
        typedef value::pair<int32_t, double> value_type;
        test<value_type>(aitools::memory_type::mb4096, k_record_count);
}

BOOST_AUTO_TEST_CASE(test_i64_dbl_external)
{
        typedef value::pair<int64_t, double> value_type;
        test<value_type>(aitools::memory_type::min_required, k_record_count);
}

BOOST_AUTO_TEST_CASE(test_i64_dbl_internal)
{
        typedef value::pair<int64_t, double> value_type;
        test<value_type>(aitools::memory_type::mb4096, k_record_count);
}

// This test takes some time
BOOST_AUTO_TEST_CASE(test_i32_dbl_external_large_scale)
{
        typedef value::pair<int32_t, double> value_type;
        test<value_type>(aitools::memory_type::min_required, 10000000);
}

// This test takes not so much time
BOOST_AUTO_TEST_CASE(test_i32_dbl_internal_large_scale)
{
        typedef value::pair<int32_t, double> value_type;
        test<value_type>(aitools::memory_type::mb4096, 10000000);
}

BOOST_AUTO_TEST_SUITE_END();

---