include/core/internal_map.hpp

Go to the documentation of this file.

// internal_map.hpp -*- C++ -*-
// Copyright (C) 2011 Martin Trenkmann
#ifndef AITOOLS_BIGHASHMAP_CORE_INTERNAL_MAP_HPP
#define AITOOLS_BIGHASHMAP_CORE_INTERNAL_MAP_HPP

#include <boost/filesystem/fstream.hpp>

#include "core/cmph_map.hpp"
#include "util/logging.hpp"
#include "util/checksum.hpp"
#include "util/systemio.hpp"
#include "value/pair.hpp"
#include "value/pair_traits.hpp"

namespace bfs = boost::filesystem;

namespace aitools {
namespace bighashmap {
namespace core {

template <typename T>
class internal_map : public cmph_map<T> {

public:

        typedef cmph_map<T>                       base_type;
        typedef typename base_type::key_type      key_type;
        typedef typename base_type::value_type    value_type;
        typedef typename base_type::checksum_type checksum_type;

private:

        typedef value::pair<checksum_type, value_type> entry_type;
        typedef value::value_traits<entry_type>        entry_traits;

private: // disallow instantiation

        internal_map()
        :       base_type() {}

        internal_map(const bfs::path& mph_file, const bfs::path& dat_file)
        :       base_type(mph_file)
        {
                const entry_type entry;
                data_ = static_cast<char*>(
                                std::calloc(this->size(), entry_traits::size_of(entry)));
                if (data_ == NULL)
                {
                        util::throw_runtime_error("Cannot allocate memory",
                                        this->size() * entry_traits::size_of(entry));
                }
                FILE* dat_rfs(util::fopen(dat_file, "rb"));
                util::fread(data_, entry_traits::size_of(entry), this->size(), dat_rfs);
                util::fclose(dat_rfs);
        }

public:

        ~internal_map()
        {
                std::free(data_);
        }

public:

        static internal_map*
        open(const bfs::path& idx_file)
        {
                bfs::ifstream ifs(idx_file);
                if (!ifs)
                {
                        util::throw_runtime_error("Cannot open", idx_file);
                }
                std::string mph_file;
                std::string dat_file;
                std::getline(ifs, mph_file);
                std::getline(ifs, dat_file);
                return new internal_map(idx_file.parent_path() / mph_file,
                                                idx_file.parent_path() / dat_file);
        }

public:

        bool
        find(const key_type& key, value_type& value)
        {
                entry_type entry;
                const uint64_t offset(hash(key) * entry_traits::size_of(entry));
                // Read checksum and value
                entry_traits::copy_from(entry, data_ + offset);
                // Check checksum
                const checksum_type checksum(util::hash<checksum_type>(key));
                if (entry.e1() != checksum)
                {
                        // This is no error, unknown keys normally cause a hash collision.
                        log_debug(__FILE__, __LINE__, "Key", key);
                        log_debug(__FILE__, __LINE__, "Memory offset", offset);
                        log_debug(__FILE__, __LINE__, "Actual checksum", checksum);
                        log_debug(__FILE__, __LINE__, "Expected checksum", entry.e1());
                        return false;
                }
                value = entry.e2();
                return true;
        }

private:

        char* data_;

};

} // namespace core
} // namespace bighashmap
} // namespace aitools

#endif // AITOOLS_BIGHASHMAP_CORE_INTERNAL_MAP_HPP

---