shared_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_SHARED_MEMORY_HPP_
#define FOEDUS_MEMORY_SHARED_MEMORY_HPP_

#include <stdint.h>
#include <sys/types.h>

#include <iosfwd>
#include <string>

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

namespace foedus {
namespace memory {
class SharedMemory CXX11_FINAL {
 public:
  SharedMemory() CXX11_NOEXCEPT
    : size_(0), numa_node_(0), shmid_(0), shmkey_(0), owner_pid_(0), block_(CXX11_NULLPTR) {}

  // Disable copy constructor
  SharedMemory(const SharedMemory &other) CXX11_FUNC_DELETE;
  SharedMemory& operator=(const SharedMemory &other) CXX11_FUNC_DELETE;

#ifndef DISABLE_CXX11_IN_PUBLIC_HEADERS

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

  ~SharedMemory() { release_block(); }

  ErrorStack  alloc(const std::string& meta_path, uint64_t size, int numa_node, bool use_hugepages);
  void        attach(const std::string& meta_path, bool use_hugepages);

  const std::string& get_meta_path() const { return meta_path_; }
  char*       get_block() const { return block_; }
  int         get_shmid() const { return shmid_; }
  key_t       get_shmkey() const { return shmkey_; }
  pid_t       get_owner_pid() const { return owner_pid_; }
  bool        is_null() const { return block_ == CXX11_NULLPTR; }
  bool        is_owned() const;
  uint64_t    get_size() const { return size_; }
  int         get_numa_node() const { return numa_node_; }

  void        mark_for_release();

  void        release_block();

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

 private:
  std::string meta_path_;
  uint64_t    size_;
  int         numa_node_;
  int         shmid_;
  key_t       shmkey_;
  pid_t       owner_pid_;
  char*       block_;
};

}  // namespace memory
}  // namespace foedus

#endif  // FOEDUS_MEMORY_SHARED_MEMORY_HPP_