numa_core_memory.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014-2015, Hewlett-Packard Development Company, LP.
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details. You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 * HP designates this particular file as subject to the "Classpath" exception
 * as provided by HP in the LICENSE.txt file that accompanied this code.
 */
#ifndef FOEDUS_MEMORY_NUMA_CORE_MEMORY_HPP_
#define FOEDUS_MEMORY_NUMA_CORE_MEMORY_HPP_
#include <stdint.h>

#include "foedus/cxx11.hpp"
#include "foedus/epoch.hpp"
#include "foedus/error_stack.hpp"
#include "foedus/fwd.hpp"
#include "foedus/initializable.hpp"
#include "foedus/memory/aligned_memory.hpp"
#include "foedus/memory/fwd.hpp"
#include "foedus/memory/memory_id.hpp"
#include "foedus/storage/storage_id.hpp"
#include "foedus/thread/thread_id.hpp"
#include "foedus/xct/fwd.hpp"

namespace foedus {
namespace memory {
class NumaCoreMemory CXX11_FINAL : public DefaultInitializable {
 public:
  struct SmallThreadLocalMemoryPieces {
    char* sysxct_workspace_memory_;
    char* xct_pointer_access_memory_;
    char* xct_page_version_memory_;
    char* xct_read_access_memory_;
    char* xct_write_access_memory_;
    char* xct_lock_free_read_access_memory_;
    char* xct_lock_free_write_access_memory_;
  };

  NumaCoreMemory() CXX11_FUNC_DELETE;
  NumaCoreMemory(Engine* engine, NumaNodeMemory *node_memory, thread::ThreadId core_id);
  ErrorStack  initialize_once() CXX11_OVERRIDE;
  ErrorStack  uninitialize_once() CXX11_OVERRIDE;

  AlignedMemorySlice get_log_buffer_memory() const { return log_buffer_memory_; }

  NumaNodeMemory* get_node_memory()       const { return node_memory_; }

  PagePoolOffset  grab_free_volatile_page();
  storage::VolatilePagePointer grab_free_volatile_page_pointer();
  PagePoolOffset  grab_free_snapshot_page();
  void            release_free_volatile_page(PagePoolOffset offset);
  void            release_free_snapshot_page(PagePoolOffset offset);

  memory::PagePool* get_volatile_pool() { return volatile_pool_; }
  memory::PagePool* get_snapshot_pool() { return snapshot_pool_; }
  PagePoolOffsetAndEpochChunk* get_retired_volatile_pool_chunk(uint16_t node);

  xct::LockEntry* get_current_lock_list_memory() const {
    return current_lock_list_memory_;
  }
  uint64_t get_current_lock_list_capacity() const {
    return current_lock_list_capacity_;
  }
  xct::LockEntry* get_retrospective_lock_list_memory() const {
    return retrospective_lock_list_memory_;
  }
  uint64_t get_retrospective_lock_list_capacity() const {
    return retrospective_lock_list_capacity_;
  }

  const SmallThreadLocalMemoryPieces& get_small_thread_local_memory_pieces() const {
    return small_thread_local_memory_pieces_;
  }

  void*           get_local_work_memory() const { return local_work_memory_.get_block(); }
  uint64_t        get_local_work_memory_size() const { return local_work_memory_.get_size(); }

  static uint64_t calculate_local_small_memory_size(const EngineOptions& options);

 private:
  static ErrorCode  grab_free_pages_from_node(
    PagePoolOffsetChunk* free_chunk,
    memory::PagePool *pool);
  static void       release_free_pages_to_node(
    PagePoolOffsetChunk* free_chunk,
    memory::PagePool *pool);

  Engine* const           engine_;

  NumaNodeMemory* const   node_memory_;

  const foedus::thread::ThreadId core_id_;
  const foedus::thread::ThreadGroupId     numa_node_;

  const thread::ThreadLocalOrdinal        core_local_ordinal_;

  memory::AlignedMemory   small_thread_local_memory_;
  SmallThreadLocalMemoryPieces small_thread_local_memory_pieces_;

  memory::AlignedMemory   local_work_memory_;

  PagePoolOffsetChunk*                    free_volatile_pool_chunk_;
  PagePoolOffsetChunk*                    free_snapshot_pool_chunk_;

  PagePoolOffsetAndEpochChunk*            retired_volatile_pool_chunks_;

  xct::LockEntry*                       current_lock_list_memory_;
  uint64_t                                current_lock_list_capacity_;
  xct::LockEntry*                 retrospective_lock_list_memory_;
  uint64_t                                retrospective_lock_list_capacity_;

  PagePool*                               volatile_pool_;
  PagePool*                               snapshot_pool_;

  AlignedMemorySlice                      log_buffer_memory_;
};

struct AutoVolatilePageReleaseScope {
  AutoVolatilePageReleaseScope(NumaCoreMemory* memory, PagePoolOffset offset)
    : memory_(memory), offset_(offset), released_(false) {}
  ~AutoVolatilePageReleaseScope() {
    if (!released_) {
      memory_->release_free_volatile_page(offset_);
      released_ = true;
    }
  }
  void set_released() {
    released_ = true;
  }
  NumaCoreMemory* const memory_;
  const PagePoolOffset  offset_;
  bool                  released_;
};

}  // namespace memory
}  // namespace foedus
#endif  // FOEDUS_MEMORY_NUMA_CORE_MEMORY_HPP_