basic_manager.hpp

Go to the documentation of this file.

// Copyright 2019 Lawrence Livermore National Security, LLC and other Metall
// Project Developers. See the top-level COPYRIGHT file for details.
//
// SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
#ifndef METALL_BASIC_MANAGER_HPP
#define METALL_BASIC_MANAGER_HPP
 
#include <cstddef>
#include <memory>
 
#include <metall/tags.hpp>
#include <metall/stl_allocator.hpp>
#include <metall/container/scoped_allocator.hpp>
#include <metall/container/fallback_allocator.hpp>
#include <metall/kernel/manager_kernel.hpp>
#include <metall/detail/named_proxy.hpp>
#include <metall/kernel/segment_storage.hpp>
#include <metall/kernel/storage.hpp>
#include <metall/kernel/segment_storage.hpp>
 
namespace metall {
 
#if !defined(DOXYGEN_SKIP)
// Forward declaration
template <typename storage, typename segment_storage, typename chunk_no_type,
          std::size_t k_chunk_size>
class basic_manager;
#endif  // DOXYGEN_SKIP
 
template <typename storage = kernel::storage,
          typename segment_storage = kernel::segment_storage,
          typename chunk_no_type = uint32_t,
          std::size_t k_chunk_size = (1ULL << 21ULL)>
class basic_manager {
 public:
  // -------------------- //
  // Public types and static values
  // -------------------- //
 
  using manager_kernel_type =
      kernel::manager_kernel<storage, segment_storage, chunk_no_type,
                             k_chunk_size>;
 
  using void_pointer = typename manager_kernel_type::void_pointer;
 
  using char_type = typename manager_kernel_type::char_type;
 
  using size_type = typename manager_kernel_type::size_type;
 
  using difference_type = typename manager_kernel_type::difference_type;
 
  template <typename T>
  using allocator_type = stl_allocator<T, manager_kernel_type>;
 
  template <typename OuterT, typename... InnerT>
  using scoped_allocator_type =
      container::scoped_allocator_adaptor<allocator_type<OuterT>,
                                          allocator_type<InnerT>...>;
 
  template <typename T>
  using fallback_allocator =
      container::fallback_allocator_adaptor<allocator_type<T>>;
 
  template <typename T>
  using scoped_fallback_allocator_type =
      container::scoped_allocator_adaptor<fallback_allocator<T>>;
 
  template <typename T>
  using construct_proxy =
      metall::mtlldetail::named_proxy<manager_kernel_type, T, false>;
 
  template <typename T>
  using construct_iter_proxy =
      metall::mtlldetail::named_proxy<manager_kernel_type, T, true>;
 
  using instance_kind = typename manager_kernel_type::instance_kind;
 
  using const_named_iterator =
      typename manager_kernel_type::const_named_iterator;
 
  using const_unique_iterator =
      typename manager_kernel_type::const_unique_iterator;
 
  using const_anonymous_iterator =
      typename manager_kernel_type::const_anonymous_iterator;
 
  using named_object_attribute_accessor_type =
      typename manager_kernel_type::named_object_attr_accessor_type;
 
  using unique_object_attribute_accessor_type =
      typename manager_kernel_type::unique_object_attr_accessor_type;
 
  using anonymous_object_attribute_accessor_type =
      typename manager_kernel_type::anonymous_object_attr_accessor_type;
 
  using chunk_number_type = chunk_no_type;
 
  using path_type = typename manager_kernel_type::path_type;
 
 private:
  // -------------------- //
  // Private types and static values
  // -------------------- //
  using char_ptr_holder_type =
      typename manager_kernel_type::char_ptr_holder_type;
  using self_type =
      basic_manager<storage, segment_storage, chunk_no_type, k_chunk_size>;
 
 public:
  // -------------------- //
  // Constructor & assign operator
  // -------------------- //
 
  basic_manager(open_only_t, const path_type &base_path) noexcept {
    try {
      m_kernel = std::make_unique<manager_kernel_type>();
      m_kernel->open(base_path);
    } catch (...) {
      m_kernel.reset(nullptr);
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
  }
 
  basic_manager(open_read_only_t, const path_type &base_path) noexcept {
    try {
      m_kernel = std::make_unique<manager_kernel_type>();
      m_kernel->open_read_only(base_path);
    } catch (...) {
      m_kernel.reset(nullptr);
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
  }
 
  basic_manager(create_only_t, const path_type &base_path) noexcept {
    try {
      m_kernel = std::make_unique<manager_kernel_type>();
      m_kernel->create(base_path);
    } catch (...) {
      m_kernel.reset(nullptr);
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
  }
 
  // The actual limit could be smaller or larger than this value, depending on
  // the internal implementation. However, a close minimum capacity should be
  // available.
  basic_manager(create_only_t, const path_type &base_path,
                const size_type capacity) noexcept {
    try {
      m_kernel = std::make_unique<manager_kernel_type>();
      m_kernel->create(base_path, capacity);
    } catch (...) {
      m_kernel.reset(nullptr);
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
  }
 
  basic_manager() = delete;
 
  ~basic_manager() noexcept = default;
 
  basic_manager(const basic_manager &) = delete;
 
  basic_manager(basic_manager &&) noexcept = default;
 
  basic_manager &operator=(const basic_manager &) = delete;
 
  basic_manager &operator=(basic_manager &&) noexcept = default;
 
  // -------------------- //
  // Public methods
  // -------------------- //
 
 
 
 
 
 
 
 
  template <typename T>
  construct_proxy<T> construct(char_ptr_holder_type name) {
    return construct_proxy<T>(m_kernel.get(), name, false, false);
  }
 
  template <typename T>
  construct_proxy<T> find_or_construct(char_ptr_holder_type name) {
    return construct_proxy<T>(m_kernel.get(), name, true, false);
  }
 
  template <typename T>
  construct_iter_proxy<T> construct_it(char_ptr_holder_type name) {
    return construct_iter_proxy<T>(m_kernel.get(), name, false, false);
  }
 
  template <typename T>
  construct_iter_proxy<T> find_or_construct_it(char_ptr_holder_type name) {
    return construct_iter_proxy<T>(m_kernel.get(), name, true, false);
  }
 
  template <typename T>
  std::pair<T *, size_type> find(char_ptr_holder_type name) const noexcept {
    if (!check_sanity()) {
      return std::make_pair(nullptr, 0);
    }
 
    try {
      return m_kernel->template find<T>(name);
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
 
    return std::make_pair(nullptr, 0);
  }
 
  template <typename T>
  bool destroy(const char *name) {
    if (!check_sanity()) {
      return false;
    }
    return m_kernel->template destroy<T>(name);
  }
 
  template <typename T>
  bool destroy(const metall::mtlldetail::unique_instance_t *const) {
    if (!check_sanity()) {
      return false;
    }
    return m_kernel->template destroy<T>(metall::unique_instance);
  }
 
  template <class T>
  bool destroy_ptr(const T *ptr) {
    if (!check_sanity()) {
      return false;
    }
    return m_kernel->template destroy_ptr<T>(ptr);
  }
 
  template <class T>
  const char_type *get_instance_name(const T *ptr) const noexcept {
    if (!check_sanity()) {
      return nullptr;
    }
    try {
      return m_kernel->get_instance_name(ptr);
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return nullptr;
  }
 
  template <class T>
  instance_kind get_instance_kind(const T *ptr) const noexcept {
    if (!check_sanity()) {
      return instance_kind();
    }
    try {
      return m_kernel->get_instance_kind(ptr);
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return instance_kind();
  }
 
  template <class T>
  size_type get_instance_length(const T *ptr) const noexcept {
    if (!check_sanity()) {
      return 0;
    }
    try {
      return m_kernel->get_instance_length(ptr);
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return 0;
  }
 
  template <class T>
  bool is_instance_type(const void *const ptr) const noexcept {
    if (!check_sanity()) {
      return false;
    }
    try {
      return m_kernel->template is_instance_type<T>(ptr);
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return false;
  }
 
  template <class T>
  bool get_instance_description(const T *ptr,
                                std::string *description) const noexcept {
    if (!check_sanity()) {
      return false;
    }
    try {
      return m_kernel->get_instance_description(ptr, description);
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return false;
  }
 
  template <class T>
  bool set_instance_description(const T *ptr,
                                const std::string &description) noexcept {
    if (!check_sanity()) {
      return false;
    }
    try {
      return m_kernel->set_instance_description(ptr, description);
    } catch (...) {
      m_kernel.reset(nullptr);
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return false;
  }
 
  size_type get_num_named_objects() const noexcept {
    if (!check_sanity()) {
      return 0;
    }
    try {
      return m_kernel->get_num_named_objects();
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return 0;
  }
 
  size_type get_num_unique_objects() const noexcept {
    if (!check_sanity()) {
      return 0;
    }
    try {
      return m_kernel->get_num_unique_objects();
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return 0;
  }
 
  size_type get_num_anonymous_objects() const noexcept {
    if (!check_sanity()) {
      return 0;
    }
    try {
      return m_kernel->get_num_anonymous_objects();
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return 0;
  }
 
  const_named_iterator named_begin() const noexcept {
    if (!check_sanity()) {
      return const_named_iterator();
    }
    try {
      return m_kernel->named_begin();
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return const_named_iterator();
  }
 
  const_named_iterator named_end() const noexcept {
    if (!check_sanity()) {
      return const_named_iterator();
    }
    try {
      return m_kernel->named_end();
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return const_named_iterator();
  }
 
  const_unique_iterator unique_begin() const noexcept {
    if (!check_sanity()) {
      return const_unique_iterator();
    }
    try {
      return m_kernel->unique_begin();
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return const_unique_iterator();
  }
 
  const_unique_iterator unique_end() const noexcept {
    if (!check_sanity()) {
      return const_unique_iterator();
    }
    try {
      return m_kernel->unique_end();
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return const_unique_iterator();
  }
 
  const_anonymous_iterator anonymous_begin() const noexcept {
    if (!check_sanity()) {
      return const_anonymous_iterator();
    }
    try {
      return m_kernel->anonymous_begin();
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return const_anonymous_iterator();
  }
 
  const_anonymous_iterator anonymous_end() const noexcept {
    if (!check_sanity()) {
      return const_anonymous_iterator();
    }
    try {
      return m_kernel->anonymous_end();
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return const_anonymous_iterator();
  }
 
  // TODO: implement
  // bool belongs_to_segment (const void *ptr) const;
 
  // ---------- Allocate memory by size ---------- //
 
  void *allocate(size_type nbytes) noexcept {
    if (!check_sanity()) {
      return nullptr;
    }
    try {
      return m_kernel->allocate(nbytes);
    } catch (...) {
      m_kernel.reset(nullptr);
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return nullptr;
  }
 
  void *allocate_aligned(size_type nbytes, size_type alignment) noexcept {
    if (!check_sanity()) {
      return nullptr;
    }
    try {
      return m_kernel->allocate_aligned(nbytes, alignment);
    } catch (...) {
      m_kernel.reset(nullptr);
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return nullptr;
  }
 
  // void allocate_many(const std::nothrow_t &tag, size_type elem_bytes,
  // size_type n_elements, multiallocation_chain &chain);
 
  void deallocate(void *addr) noexcept {
    if (!check_sanity()) {
      return;
    }
    try {
      return m_kernel->deallocate(addr);
    } catch (...) {
      m_kernel.reset(nullptr);
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
  }
 
  // void deallocate_many(multiallocation_chain &chain);
 
  bool all_memory_deallocated() const noexcept {
    if (!check_sanity()) {
      return false;
    }
 
    try {
      return m_kernel->all_memory_deallocated();
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return false;
  }
 
  // ---------- Flush ---------- //
  void flush(const bool synchronous = true) noexcept {
    if (!check_sanity()) {
      return;
    }
    try {
      m_kernel->flush(synchronous);
    } catch (...) {
      m_kernel.reset(nullptr);
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
  }
 
  // -------- Snapshot, copy, data store management -------- //
  bool snapshot(const path_type &destination_path, const bool clone = true,
                const int num_max_copy_threads = 0) noexcept {
    if (!check_sanity()) {
      return false;
    }
    try {
      return m_kernel->snapshot(destination_path, clone, num_max_copy_threads);
    } catch (...) {
      m_kernel.reset(nullptr);
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return false;
  }
 
  static bool copy(const path_type &source_path,
                   const path_type &destination_path, const bool clone = true,
                   const int num_max_copy_threads = 0) noexcept {
    try {
      return manager_kernel_type::copy(source_path, destination_path, clone,
                                       num_max_copy_threads);
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return false;
  }
 
  static auto copy_async(const path_type source_path,
                         const path_type destination_path,
                         const bool clone = true,
                         const int num_max_copy_threads = 0) noexcept {
    try {
      return manager_kernel_type::copy_async(source_path, destination_path,
                                             clone, num_max_copy_threads);
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return std::future<bool>();
  }
 
  static bool remove(const path_type &path) noexcept {
    try {
      return manager_kernel_type::remove(path);
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return false;
  }
 
  static std::future<bool> remove_async(const path_type &path) noexcept {
    try {
      return std::async(std::launch::async, remove, path);
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return std::future<bool>();
  }
 
  static bool consistent(const path_type &path) noexcept {
    try {
      return manager_kernel_type::consistent(path);
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return false;
  }
 
  std::string get_uuid() const noexcept {
    if (!check_sanity()) {
      return std::string();
    }
    try {
      return m_kernel->get_uuid();
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return std::string();
  }
 
  static std::string get_uuid(const path_type &path) noexcept {
    try {
      return manager_kernel_type::get_uuid(path);
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return std::string();
  }
 
  version_type get_version() const noexcept {
    if (!check_sanity()) {
      return version_type();
    }
    try {
      return m_kernel->get_version();
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return version_type();
  }
 
  static version_type get_version(const path_type &path) noexcept {
    try {
      return manager_kernel_type::get_version(path);
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
      return version_type();
    }
  }
 
  // ---------- Data store description ---------- //
 
  bool set_description(const std::string &description) noexcept {
    if (!check_sanity()) {
      return false;
    }
    try {
      return m_kernel->set_description(description);
    } catch (...) {
      m_kernel.reset(nullptr);
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return false;
  }
 
  static bool set_description(const path_type &path,
                              const std::string &description) noexcept {
    try {
      return manager_kernel_type::set_description(path, description);
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return false;
  }
 
  bool get_description(std::string *description) const noexcept {
    if (!check_sanity()) {
      return false;
    }
    try {
      return m_kernel->get_description(description);
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return false;
  }
 
  static bool get_description(const path_type &path,
                              std::string *description) noexcept {
    try {
      return manager_kernel_type::get_description(path, description);
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return false;
  }
 
  // ---------- Object attribute ---------- //
  static named_object_attribute_accessor_type access_named_object_attribute(
      const path_type &path) noexcept {
    try {
      return manager_kernel_type::access_named_object_attribute(path);
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return named_object_attribute_accessor_type();
  }
 
  static unique_object_attribute_accessor_type access_unique_object_attribute(
      const path_type &path) noexcept {
    try {
      return manager_kernel_type::access_unique_object_attribute(path);
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return unique_object_attribute_accessor_type();
  }
 
  static anonymous_object_attribute_accessor_type
  access_anonymous_object_attribute(const path_type &path) noexcept {
    try {
      return manager_kernel_type::access_anonymous_object_attribute(path);
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return anonymous_object_attribute_accessor_type();
  }
 
  // ---------- etc ---------- //
  template <typename T = std::byte>
  allocator_type<T> get_allocator() const noexcept {
    if (!check_sanity()) {
      return allocator_type<T>(nullptr);
    }
    try {
      return allocator_type<T>(reinterpret_cast<manager_kernel_type *const *>(
          &(m_kernel->get_segment_header().manager_kernel_address)));
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return allocator_type<T>(nullptr);
  }
 
  static constexpr size_type chunk_size() noexcept { return k_chunk_size; }
 
  const void *get_address() const noexcept {
    if (!check_sanity()) {
      return nullptr;
    }
    try {
      return m_kernel->get_segment();
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return nullptr;
  }
 
  size_type get_size() const noexcept {
    if (!check_sanity()) {
      return 0;
    }
    try {
      return m_kernel->get_segment_size();
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return 0;
  }
 
  bool read_only() const noexcept {
    if (!check_sanity()) {
      return true;
    }
    try {
      return m_kernel->read_only();
    } catch (...) {
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
    return true;
  }
 
  // bool belongs_to_segment (const void *ptr) const
 
  bool check_sanity() const noexcept { return !!m_kernel && m_kernel->good(); }
 
  // ---------- For profiling and debug ---------- //
#if !defined(DOXYGEN_SKIP)
  template <typename out_stream_type>
  void profile(out_stream_type *log_out) noexcept {
    if (!check_sanity()) {
      return;
    }
    try {
      m_kernel->profile(log_out);
    } catch (...) {
      m_kernel.reset(nullptr);
      logger::out(logger::level::error, __FILE__, __LINE__,
                  "An exception has been thrown");
    }
  }
#endif
 
 private:
  // -------------------- //
  // Private fields
  // -------------------- //
  std::unique_ptr<manager_kernel_type> m_kernel{nullptr};
};
}  // namespace metall
 
#endif  // METALL_BASIC_MANAGER_HPP