masstree_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_MASSTREE_MASSTREE_STORAGE_HPP_
#define FOEDUS_STORAGE_MASSTREE_MASSTREE_STORAGE_HPP_

#include <iosfwd>
#include <string>

#include "foedus/attachable.hpp"
#include "foedus/cxx11.hpp"
#include "foedus/fwd.hpp"
#include "foedus/initializable.hpp"
#include "foedus/storage/fwd.hpp"
#include "foedus/storage/storage.hpp"
#include "foedus/storage/storage_id.hpp"
#include "foedus/storage/masstree/fwd.hpp"
#include "foedus/storage/masstree/masstree_id.hpp"
#include "foedus/thread/fwd.hpp"
#include "foedus/xct/xct_id.hpp"

namespace foedus {
namespace storage {
namespace masstree {
class MasstreeStorage CXX11_FINAL : public Storage<MasstreeStorageControlBlock> {
 public:
  typedef MasstreeStoragePimpl   ThisPimpl;
  typedef MasstreeCreateLogType  ThisCreateLogType;
  typedef MasstreeMetadata       ThisMetadata;

  MasstreeStorage();
  MasstreeStorage(Engine* engine, MasstreeStorageControlBlock* control_block);
  MasstreeStorage(Engine* engine, StorageControlBlock* control_block);
  MasstreeStorage(Engine* engine, StorageId id);
  MasstreeStorage(Engine* engine, const StorageName& name);
  MasstreeStorage(const MasstreeStorage& other);
  MasstreeStorage& operator=(const MasstreeStorage& other);

  // Storage interface
  const MasstreeMetadata*  get_masstree_metadata()  const;
  ErrorStack          create(const Metadata &metadata);
  ErrorStack          load(const StorageControlBlock& snapshot_block);
  ErrorStack          drop();
  friend std::ostream& operator<<(std::ostream& o, const MasstreeStorage& v);


  ErrorCode prefetch_pages_normalized(
    thread::Thread* context,
    bool install_volatile,
    bool cache_snapshot,
    KeySlice from = kInfimumSlice,
    KeySlice to = kSupremumSlice);

  // TASK(Hideaki) implement non key-slice version of prefetch_pages. so far this is enough, tho.

  xct::TrackMovedRecordResult track_moved_record(
    xct::RwLockableXctId* old_address,
    xct::WriteXctAccess* write_set);


  // get_record() methods

  ErrorCode   get_record(
    thread::Thread* context,
    const void* key,
    KeyLength key_length,
    void* payload,
    PayloadLength* payload_capacity,
    bool read_only);

  ErrorCode   get_record_part(
    thread::Thread* context,
    const void* key,
    KeyLength key_length,
    void* payload,
    PayloadLength payload_offset,
    PayloadLength payload_count,
    bool read_only);

  template <typename PAYLOAD>
  ErrorCode   get_record_primitive(
    thread::Thread* context,
    const void* key,
    KeyLength key_length,
    PAYLOAD* payload,
    PayloadLength payload_offset,
    bool read_only);

  ErrorCode   get_record_normalized(
    thread::Thread* context,
    KeySlice key,
    void* payload,
    PayloadLength* payload_capacity,
    bool read_only);

  ErrorCode   get_record_part_normalized(
    thread::Thread* context,
    KeySlice key,
    void* payload,
    PayloadLength payload_offset,
    PayloadLength payload_count,
    bool read_only);

  template <typename PAYLOAD>
  ErrorCode   get_record_primitive_normalized(
    thread::Thread* context,
    KeySlice key,
    PAYLOAD* payload,
    PayloadLength payload_offset,
    bool read_only);

  // insert_record() methods

  inline ErrorCode insert_record(
    thread::Thread* context,
    const void* key,
    KeyLength key_length,
    const void* payload,
    PayloadLength payload_count) ALWAYS_INLINE {
    return insert_record(context, key, key_length, payload, payload_count, payload_count);
  }

  ErrorCode   insert_record(
    thread::Thread* context,
    const void* key,
    KeyLength key_length,
    const void* payload,
    PayloadLength payload_count,
    PayloadLength physical_payload_hint);

  ErrorCode   insert_record(
    thread::Thread* context,
    const void* key,
    KeyLength key_length) ALWAYS_INLINE {
      return insert_record(context, key, key_length, CXX11_NULLPTR, 0U);
  }

  inline ErrorCode insert_record_normalized(
    thread::Thread* context,
    KeySlice key,
    const void* payload,
    PayloadLength payload_count) ALWAYS_INLINE {
    return insert_record_normalized(context, key, payload, payload_count, payload_count);
  }

  ErrorCode   insert_record_normalized(
    thread::Thread* context,
    KeySlice key,
    const void* payload,
    PayloadLength payload_count,
    PayloadLength physical_payload_hint);

  ErrorCode   insert_record_normalized(thread::Thread* context, KeySlice key) ALWAYS_INLINE {
    return insert_record_normalized(context, key, CXX11_NULLPTR, 0U);
  }

  // delete_record() methods

  ErrorCode   delete_record(thread::Thread* context, const void* key, KeyLength key_length);

  ErrorCode   delete_record_normalized(thread::Thread* context, KeySlice key);

  // upsert_record() methods

  inline ErrorCode upsert_record(
    thread::Thread* context,
    const void* key,
    KeyLength key_length,
    const void* payload,
    PayloadLength payload_count) ALWAYS_INLINE {
    return upsert_record(context, key, key_length, payload, payload_count, payload_count);
  }

  ErrorCode   upsert_record(
    thread::Thread* context,
    const void* key,
    KeyLength key_length,
    const void* payload,
    PayloadLength payload_count,
    PayloadLength physical_payload_hint);

  ErrorCode   upsert_record(
    thread::Thread* context,
    const void* key,
    KeyLength key_length) ALWAYS_INLINE {
      return upsert_record(context, key, key_length, CXX11_NULLPTR, 0U);
  }

  inline ErrorCode upsert_record_normalized(
    thread::Thread* context,
    KeySlice key,
    const void* payload,
    PayloadLength payload_count) ALWAYS_INLINE {
    return upsert_record_normalized(context, key, payload, payload_count, payload_count);
  }

  ErrorCode   upsert_record_normalized(
    thread::Thread* context,
    KeySlice key,
    const void* payload,
    PayloadLength payload_count,
    PayloadLength physical_payload_hint);

  ErrorCode   upsert_record_normalized(thread::Thread* context, KeySlice key) ALWAYS_INLINE {
    return upsert_record_normalized(context, key, CXX11_NULLPTR, 0U);
  }

  // overwrite_record() methods

  ErrorCode   overwrite_record(
    thread::Thread* context,
    const void* key,
    KeyLength key_length,
    const void* payload,
    PayloadLength payload_offset,
    PayloadLength payload_count);

  template <typename PAYLOAD>
  ErrorCode   overwrite_record_primitive(
    thread::Thread* context,
    const void* key,
    KeyLength key_length,
    PAYLOAD payload,
    PayloadLength payload_offset);

  ErrorCode   overwrite_record_normalized(
    thread::Thread* context,
    KeySlice key,
    const void* payload,
    PayloadLength payload_offset,
    PayloadLength payload_count);

  template <typename PAYLOAD>
  ErrorCode   overwrite_record_primitive_normalized(
    thread::Thread* context,
    KeySlice key,
    PAYLOAD payload,
    PayloadLength payload_offset);


  // increment_record() methods

  template <typename PAYLOAD>
  ErrorCode   increment_record(
    thread::Thread* context,
    const void* key,
    KeyLength key_length,
    PAYLOAD* value,
    PayloadLength payload_offset);

  template <typename PAYLOAD>
  ErrorCode   increment_record_normalized(
    thread::Thread* context,
    KeySlice key,
    PAYLOAD* value,
    PayloadLength payload_offset);

  // TODO(Hideaki): Extend/shrink/update methods for payload. A bit faster than delete + insert.

  ErrorStack  verify_single_thread(thread::Thread* context);

  ErrorStack  debugout_single_thread(
    Engine* engine,
    bool volatile_only = false,
    uint32_t max_pages = 1024U);

  ErrorStack  hcc_reset_all_temperature_stat();

  struct PeekBoundariesArguments {
    const KeySlice* prefix_slices_;
    uint32_t prefix_slice_count_;
    uint32_t found_boundary_capacity_;
    KeySlice from_;
    KeySlice to_;
    KeySlice* found_boundaries_;
    uint32_t* found_boundary_count_;
  };

  ErrorCode   peek_volatile_page_boundaries(Engine* engine, const PeekBoundariesArguments& args);

  ErrorStack  fatify_first_root(
    thread::Thread* context,
    uint32_t desired_count,
    bool disable_no_record_split = true);

  static SlotIndex estimate_records_per_page(
    Layer layer,
    KeyLength key_length,
    PayloadLength payload_length);
};
}  // namespace masstree
}  // namespace storage
}  // namespace foedus
#endif  // FOEDUS_STORAGE_MASSTREE_MASSTREE_STORAGE_HPP_