single_phf_view.h

Go to the documentation of this file.

 
#ifndef GRAPHSCOPE_PTHASH_UTILS_SINGLE_PHF_VIEW_H_
#define GRAPHSCOPE_PTHASH_UTILS_SINGLE_PHF_VIEW_H_
 
#ifdef USE_PTHASH
 
#include "flex/utils/mmap_array.h"
#include "flex/utils/pthash_utils/encoders_view.h"
#include "utils/bucketers.hpp"
#include "utils/hasher.hpp"
 
namespace gs {
 
struct default_loader {
  default_loader(const char* buffer) : buffer_(buffer) {}
  ~default_loader() = default;
 
  template <typename T>
  void visit(T& val) {
    if constexpr (std::is_pod<T>::value) {
      memcpy(&val, buffer_, sizeof(T));
      buffer_ += sizeof(T);
    } else {
      val.visit(*this);
    }
  }
 
  template <typename T>
  void visit_vec(ref_vector<T>& vec) {
    size_t size;
    visit(size);
    vec.init(reinterpret_cast<const T*>(buffer_), size);
    buffer_ += sizeof(T) * size;
  }
 
  const char* buffer() const { return buffer_; }
 
 private:
  const char* buffer_;
};
 
// This code is an adaptation from
// https://github.com/jermp/pthash/blob/master/include/single_phf.hpp
template <typename Hasher>
struct SinglePHFView {
 public:
  SinglePHFView() = default;
  ~SinglePHFView() = default;
 
  SinglePHFView(const SinglePHFView& rhs) : buffer_(rhs.buffer_) {
    default_loader loader(buffer_.data());
    loader.visit(m_seed);
    loader.visit(m_num_keys);
    loader.visit(m_table_size);
    loader.visit(m_M);
    loader.visit(m_bucketer);
    loader.visit(m_pilots);
    loader.visit(m_free_slots);
  }
 
  void Open(const std::string& filename) {
    buffer_.open(filename);
    default_loader loader(buffer_.data());
    loader.visit(m_seed);
    loader.visit(m_num_keys);
    loader.visit(m_table_size);
    loader.visit(m_M);
    loader.visit(m_bucketer);
    loader.visit(m_pilots);
    loader.visit(m_free_slots);
  }
 
  void Init(const std::vector<char>& buffer) {
    buffer_.resize(buffer.size());
    memcpy(buffer_.data(), buffer.data(), buffer.size());
    default_loader loader(buffer_.data());
    loader.visit(m_seed);
    loader.visit(m_num_keys);
    loader.visit(m_table_size);
    loader.visit(m_M);
    loader.visit(m_bucketer);
    loader.visit(m_pilots);
    loader.visit(m_free_slots);
  }
 
  void Save(const std::string& filename) { buffer_.dump(filename); }
 
  template <typename T>
  uint64_t operator()(T const& key) const {
    auto hash = Hasher::hash(key, m_seed);
    return position(hash);
  }
 
  uint64_t position(typename Hasher::hash_type hash) const {
    uint64_t bucket = m_bucketer.bucket(hash.first());
    uint64_t pilot = m_pilots.access(bucket);
    uint64_t hashed_pilot = pthash::default_hash64(pilot, m_seed);
    uint64_t p =
        fastmod::fastmod_u64(hash.second() ^ hashed_pilot, m_M, m_table_size);
    if (PTHASH_LIKELY(p < m_num_keys))
      return p;
    return m_free_slots.access(p - m_num_keys);
  }
 
 private:
  uint64_t m_seed;
  uint64_t m_num_keys;
  uint64_t m_table_size;
  __uint128_t m_M;
  pthash::skew_bucketer m_bucketer;
  dual_dictionary_view m_pilots;
  ef_sequence_view m_free_slots;
  mmap_array<char> buffer_;
};
 
}  // namespace gs
 
#endif  // USE_PTHASH
 
#endif  // GRAPHSCOPE_PTHASH_UTILS_SINGLE_PHF_VIEW_H_