storage.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_STORAGE_STORAGE_HPP_
#define FOEDUS_STORAGE_STORAGE_HPP_
#include <iosfwd>
#include <string>

#include "foedus/attachable.hpp"
#include "foedus/cxx11.hpp"
#include "foedus/epoch.hpp"
#include "foedus/error_stack.hpp"
#include "foedus/fwd.hpp"
#include "foedus/initializable.hpp"
#include "foedus/log/fwd.hpp"
#include "foedus/soc/shared_mutex.hpp"
#include "foedus/storage/fwd.hpp"
#include "foedus/storage/metadata.hpp"
#include "foedus/storage/storage_id.hpp"
#include "foedus/thread/fwd.hpp"
#include "foedus/xct/fwd.hpp"

namespace foedus {
namespace storage {

StorageControlBlock* get_storage_control_block(Engine* engine, StorageId id);
StorageControlBlock* get_storage_control_block(Engine* engine, const StorageName& name);

struct StorageControlBlock CXX11_FINAL {
  // this is backed by shared memory. not instantiation. just reinterpret_cast.
  StorageControlBlock() CXX11_FUNC_DELETE;
  ~StorageControlBlock() CXX11_FUNC_DELETE;

  bool exists() const { return status_ == kExists; }
  bool is_valid_status() const {
    return status_ == kNotExists || status_ == kExists || status_ == kMarkedForDeath;
  }

  void initialize() {
    status_mutex_.initialize();
    status_ = kNotExists;
    root_page_pointer_.snapshot_pointer_ = 0;
    root_page_pointer_.volatile_pointer_.word = 0;
  }
  void uninitialize() {
    status_mutex_.uninitialize();
  }

  soc::SharedMutex  status_mutex_;
  StorageStatus     status_;
  DualPagePointer   root_page_pointer_;
  Metadata          meta_;

  char              padding_[
    4096 - sizeof(soc::SharedMutex) - 8 - sizeof(DualPagePointer) - sizeof(Metadata)];
};

template <typename CONTROL_BLOCK>
class Storage : public Attachable<CONTROL_BLOCK> {
 public:
  Storage() : Attachable<CONTROL_BLOCK>() {}
  Storage(Engine* engine, CONTROL_BLOCK* control_block)
    : Attachable<CONTROL_BLOCK>(engine, control_block) {}
  Storage(Engine* engine, StorageControlBlock* control_block)
    : Attachable<CONTROL_BLOCK>(engine, reinterpret_cast<CONTROL_BLOCK*>(control_block)) {}
  Storage(Engine* engine, StorageId id)
    : Attachable<CONTROL_BLOCK>(
        engine,
        reinterpret_cast<CONTROL_BLOCK*>(get_storage_control_block(engine, id))) {}
  Storage(Engine* engine, const StorageName& name)
    : Attachable<CONTROL_BLOCK>(
      engine,
      reinterpret_cast<CONTROL_BLOCK*>(get_storage_control_block(engine, name))) {}

  Storage(const Storage& other)
    : Attachable<CONTROL_BLOCK>(other.engine_, other.control_block_) {}
  Storage& operator=(const Storage& other) {
    this->engine_ = other.engine_;
    this->control_block_ = other.control_block_;
    return *this;
  }

  StorageId           get_id() const { return get_metadata()->id_; }

  StorageType         get_type() const { return get_metadata()->type_; }

  const StorageName&  get_name() const { return get_metadata()->name_; }

  const Metadata*     get_metadata() const {
    return &(reinterpret_cast<const StorageControlBlock*>(this->control_block_)->meta_);
  }

  bool                exists() const {
    return this->control_block_ != CXX11_NULLPTR &&
      reinterpret_cast<const StorageControlBlock*>(this->control_block_)->exists();
  }

  // The following only defines the "interface", it's not actual virtual method
  // you can invoke in a polymorphic manner. No virtual methods in shared memory, unluckily.
  // In other words, the followings are just 'concepts', tho we don't actually define template
  // concepts which is taking forever to get into the c++ standard.

  // ErrorStack          create(const Metadata &metadata);

  // ErrorStack          drop();
};


CXX11_STATIC_ASSERT(sizeof(StorageControlBlock) == 1 << 12, "StorageControlBlock is not 4kb");
}  // namespace storage
}  // namespace foedus
#endif  // FOEDUS_STORAGE_STORAGE_HPP_