aligned_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_ALIGNED_MEMORY_HPP_
#define FOEDUS_MEMORY_ALIGNED_MEMORY_HPP_

#include <stdint.h>

#include <iosfwd>

#include "foedus/assert_nd.hpp"
#include "foedus/cxx11.hpp"
#include "foedus/error_code.hpp"

namespace foedus {
namespace memory {
class AlignedMemory CXX11_FINAL {
 public:
  enum AllocType {
    kPosixMemalign = 0,
    kNumaAllocInterleaved,
    kNumaAllocOnnode,
    // kNormal,
    // kVirtualAlloc,
    kNumaMmapOneGbPages,
  };

  AlignedMemory() CXX11_NOEXCEPT : size_(0), alignment_(0), alloc_type_(kPosixMemalign),
    numa_node_(0), block_(CXX11_NULLPTR) {}

  AlignedMemory(uint64_t size, uint64_t alignment,
    AllocType alloc_type, int numa_node) CXX11_NOEXCEPT;

  // Disable default constructors
  AlignedMemory(const AlignedMemory &other) CXX11_FUNC_DELETE;
  AlignedMemory& operator=(const AlignedMemory &other) CXX11_FUNC_DELETE;

#ifndef DISABLE_CXX11_IN_PUBLIC_HEADERS

  AlignedMemory(AlignedMemory &&other) noexcept;
  AlignedMemory& operator=(AlignedMemory &&other) noexcept;
#endif  // DISABLE_CXX11_IN_PUBLIC_HEADERS

  ~AlignedMemory() { release_block(); }

  void        alloc(
    uint64_t size,
    uint64_t alignment,
    AllocType alloc_type,
    int numa_node) CXX11_NOEXCEPT;
  void        alloc_onnode(uint64_t size, uint64_t alignment, int numa_node) CXX11_NOEXCEPT {
    alloc(size, alignment, kNumaAllocOnnode, numa_node);
  }

  ErrorCode   assure_capacity(
    uint64_t required_size,
    double expand_margin = 2.0,
    bool retain_content = false) CXX11_NOEXCEPT;

  void*       get_block() const { return block_; }
  bool        is_null() const { return block_ == CXX11_NULLPTR; }
  uint64_t    get_size() const { return size_; }
  uint64_t    get_alignment() const { return alignment_; }
  AllocType   get_alloc_type() const { return alloc_type_; }
  int         get_numa_node() const { return numa_node_; }

  void        release_block();

  friend std::ostream&    operator<<(std::ostream& o, const AlignedMemory& v);

 private:
  uint64_t    size_;
  uint64_t    alignment_;
  AllocType   alloc_type_;
  int         numa_node_;
  void*       block_;
};

struct AlignedMemorySlice CXX11_FINAL {
  AlignedMemorySlice() : memory_(CXX11_NULLPTR), offset_(0), count_(0) {}

  explicit AlignedMemorySlice(AlignedMemory *memory)
    : memory_(memory), offset_(0), count_(memory->get_size()) {}

  AlignedMemorySlice(AlignedMemory *memory, uint64_t offset, uint64_t count)
    : memory_(memory), offset_(offset), count_(count) {
    ASSERT_ND(memory->get_size() >= count + offset);
  }

  AlignedMemorySlice(const AlignedMemorySlice &slice, uint64_t offset, uint64_t count)
    : memory_(slice.memory_), offset_(slice.offset_ + offset), count_(count) {
    ASSERT_ND(slice.get_size() >= count + offset);
  }

  friend std::ostream&    operator<<(std::ostream& o, const AlignedMemorySlice& v);

  void        clear() { memory_ = CXX11_NULLPTR; }
  bool        is_valid()  const { return memory_; }
  uint64_t    get_size()  const { return count_; }
  void*       get_block() const { return reinterpret_cast<char*>(memory_->get_block()) + offset_; }

  AlignedMemory*  memory_;
  uint64_t        offset_;
  uint64_t        count_;
};

bool is_1gb_hugepage_enabled();

}  // namespace memory
}  // namespace foedus

#endif  // FOEDUS_MEMORY_ALIGNED_MEMORY_HPP_