page_pool.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_PAGE_POOL_HPP_
#define FOEDUS_MEMORY_PAGE_POOL_HPP_
#include <stdint.h>

#include <iosfwd>
#include <string>

#include "foedus/assert_nd.hpp"
#include "foedus/cxx11.hpp"
#include "foedus/error_stack.hpp"
#include "foedus/fwd.hpp"
#include "foedus/initializable.hpp"
#include "foedus/assorted/assorted_func.hpp"
#include "foedus/memory/fwd.hpp"
#include "foedus/memory/memory_id.hpp"
#include "foedus/memory/page_resolver.hpp"
#include "foedus/storage/page.hpp"
#include "foedus/storage/storage_id.hpp"
#include "foedus/thread/thread_id.hpp"

namespace foedus {
namespace memory {
class PagePoolOffsetChunk {
 public:
  enum Constants {
    kMaxSize = (1 << 12) - 1,
  };
  PagePoolOffsetChunk() : size_(0) {}

  uint32_t                capacity() const { return kMaxSize; }
  uint32_t                size()  const   { return size_; }
  bool                    empty() const   { return size_ == 0; }
  bool                    full()  const   { return size_ == kMaxSize; }
  void                    clear()         { size_ = 0; }

  PagePoolOffset          pop_back() {
    ASSERT_ND(!empty());
    return chunk_[--size_];
  }
  void                    push_back(PagePoolOffset pointer) {
    ASSERT_ND(!full());
    chunk_[size_++] = pointer;
  }
  void                    push_back(const PagePoolOffset* begin, const PagePoolOffset* end);
  void                    move_to(PagePoolOffset* destination, uint32_t count);

 private:
  uint32_t        size_;
  PagePoolOffset  chunk_[kMaxSize];
};

class PagePoolOffsetDynamicChunk {
 public:
  PagePoolOffsetDynamicChunk(uint32_t size, PagePoolOffset* chunk)
    : size_(size), padding_(0), chunk_(chunk) {}

  uint32_t                capacity() const { return size_; }
  uint32_t                size()  const   { return size_; }
  bool                    empty() const   { return size_ == 0; }
  bool                    full()  const   { return true; }

  void                    move_to(PagePoolOffset* destination, uint32_t count);

  uint32_t                unused_dummy_func_padding() const { return padding_; }

 private:
  uint32_t              size_;
  const uint32_t        padding_;
  PagePoolOffset*       chunk_;  // of arbitrary size
};

class PagePoolOffsetAndEpochChunk {
 public:
  enum Constants {
    kMaxSize = (1 << 16) - 1,
  };
  struct OffsetAndEpoch {
    PagePoolOffset      offset_;
    Epoch::EpochInteger safe_epoch_;
  };
  PagePoolOffsetAndEpochChunk() : size_(0) {}

  uint32_t                capacity() const { return kMaxSize; }
  uint32_t                size()  const   { return size_; }
  bool                    empty() const   { return size_ == 0; }
  bool                    full()  const   { return size_ == kMaxSize; }
  void                    clear()         { size_ = 0; }
  bool                    is_sorted() const;  // only for assertion

  void                    push_back(PagePoolOffset offset, const Epoch& safe_epoch) {
    ASSERT_ND(!full());
    ASSERT_ND(empty() || Epoch(chunk_[size_ - 1U].safe_epoch_) <= safe_epoch);
    chunk_[size_].offset_ = offset;
    chunk_[size_].safe_epoch_ = safe_epoch.value();
    ++size_;
  }
  void                    move_to(PagePoolOffset* destination, uint32_t count);
  uint32_t                get_safe_offset_count(const Epoch& threshold) const;

  uint32_t                unused_dummy_func_dummy() const { return dummy_; }

 private:
  uint32_t        size_;
  uint32_t        dummy_;
  OffsetAndEpoch  chunk_[kMaxSize];
};

class PagePool CXX11_FINAL : public virtual Initializable {
 public:
  struct Stat {
    uint64_t total_pages_;
    uint64_t allocated_pages_;
  };

  PagePool();
  ~PagePool();
  void attach(
    PagePoolControlBlock* control_block,
    void* memory,
    uint64_t memory_size,
    bool owns,
    bool rigorous_page_boundary_check);

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

  ErrorStack  initialize() CXX11_OVERRIDE;
  bool        is_initialized() const CXX11_OVERRIDE;
  ErrorStack  uninitialize() CXX11_OVERRIDE;

  storage::Page*        get_base() const;
  uint64_t              get_free_pool_capacity() const;
  uint64_t              get_memory_size() const;
  uint32_t              get_recommended_pages_per_grab() const;
  Stat                  get_stat() const;
  std::string           get_debug_pool_name() const;
  void                  set_debug_pool_name(const std::string& name);

  ErrorCode   grab(uint32_t desired_grab_count, PagePoolOffsetChunk *chunk);
  ErrorCode   grab_one(PagePoolOffset *offset);

  void        release(uint32_t desired_release_count, PagePoolOffsetChunk* chunk);
  void        release(uint32_t desired_release_count, PagePoolOffsetDynamicChunk* chunk);

  void        release(uint32_t desired_release_count, PagePoolOffsetAndEpochChunk* chunk);

  void        release_one(PagePoolOffset offset);

  const LocalPageResolver& get_resolver() const;

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

 private:
  PagePoolPimpl *pimpl_;
};

class PageReleaseBatch CXX11_FINAL {
 public:
  typedef PagePoolOffsetChunk* ChunkPtr;
  explicit PageReleaseBatch(Engine* engine);
  ~PageReleaseBatch();

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

  void        release(storage::VolatilePagePointer page_id) {
    release(page_id.get_numa_node(), page_id.get_offset());
  }

  void        release(thread::ThreadGroupId numa_node, PagePoolOffset offset);

  void        release_chunk(thread::ThreadGroupId numa_node);

  void        release_all();

 private:
  Engine* const   engine_;
  const uint16_t  numa_node_count_;
  ChunkPtr        chunks_[256];
};

class RoundRobinPageGrabBatch CXX11_FINAL {
 public:
  explicit RoundRobinPageGrabBatch(Engine* engine);
  ~RoundRobinPageGrabBatch();

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

  storage::VolatilePagePointer grab();

  void        release_all();

 private:
  Engine* const           engine_;
  const uint16_t          numa_node_count_;
  thread::ThreadGroupId   current_node_;
  PagePoolOffsetChunk     chunk_;
};

class DivvyupPageGrabBatch CXX11_FINAL {
 public:
  explicit DivvyupPageGrabBatch(Engine* engine);
  ~DivvyupPageGrabBatch();

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

  storage::VolatilePagePointer grab(thread::ThreadGroupId node);

  storage::VolatilePagePointer grab_evenly(uint64_t cur, uint64_t total);

  void        release_all();

 private:
  Engine* const           engine_;
  const uint16_t          node_count_;
  PagePoolOffsetChunk*    chunks_;
};


STATIC_SIZE_CHECK(sizeof(PagePoolOffset), 4)
// Size of PagePoolOffsetChunk should be power of two (<=> x & (x-1) == 0)
STATIC_SIZE_CHECK(sizeof(PagePoolOffsetChunk) & (sizeof(PagePoolOffsetChunk) - 1), 0)
STATIC_SIZE_CHECK(sizeof(PagePoolOffsetChunk) * 32U, sizeof(PagePoolOffsetAndEpochChunk))

}  // namespace memory
}  // namespace foedus
#endif  // FOEDUS_MEMORY_PAGE_POOL_HPP_