hash_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_HASH_HASH_STORAGE_HPP_
#define FOEDUS_STORAGE_HASH_HASH_STORAGE_HPP_
#include <iosfwd>
#include <string>

#include "foedus/attachable.hpp"
#include "foedus/cxx11.hpp"
#include "foedus/fwd.hpp"
#include "foedus/storage/fwd.hpp"
#include "foedus/storage/storage.hpp"
#include "foedus/storage/storage_id.hpp"
#include "foedus/storage/hash/fwd.hpp"
#include "foedus/storage/hash/hash_combo.hpp"
#include "foedus/storage/hash/hash_id.hpp"
#include "foedus/thread/fwd.hpp"
#include "foedus/xct/fwd.hpp"
#include "foedus/xct/xct_id.hpp"

namespace foedus {
namespace storage {
namespace hash {
class HashStorage CXX11_FINAL : public Storage<HashStorageControlBlock> {
 public:
  typedef HashStoragePimpl   ThisPimpl;
  typedef HashCreateLogType  ThisCreateLogType;
  typedef HashMetadata       ThisMetadata;

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

  // Storage interface
  const HashMetadata* get_hash_metadata()  const;
  uint8_t             get_levels() const;
  HashBin             get_bin_count() const;
  uint8_t             get_bin_bits() const;
  uint8_t             get_bin_shifts() const;
  uint16_t            get_root_children() const;
  ErrorStack          create(const Metadata &metadata);
  ErrorStack          load(const StorageControlBlock& snapshot_block);
  ErrorStack          drop();
  friend std::ostream& operator<<(std::ostream& o, const HashStorage& v);

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

  ErrorStack  verify_single_thread(Engine* engine);
  ErrorStack  verify_single_thread(thread::Thread* context);

  ErrorStack  hcc_reset_all_temperature_stat();

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

  // TASK(Hideaki) Add primitive-optimized versions and increment versions.
  // Low priority. Most costs are from page-traversal and hashinate.


  inline HashCombo combo(const void* key, uint16_t key_length) const {
    return HashCombo(key, key_length, *get_hash_metadata());
  }
  template <typename KEY>
  inline HashCombo combo(KEY* key) const {
    return HashCombo(key, sizeof(KEY), *get_hash_metadata());
  }


  // get_record() methods

  inline ErrorCode get_record(
    thread::Thread* context,
    const void* key,
    uint16_t key_length,
    void* payload,
    uint16_t* payload_capacity,
    bool read_only) {
    HashCombo c(combo(key, key_length));
    return get_record(context, key, key_length, c, payload, payload_capacity, read_only);
  }

  template <typename KEY>
  inline ErrorCode get_record(
    thread::Thread* context,
    KEY key,
    void* payload,
    uint16_t* payload_capacity,
    bool read_only) {
    HashCombo c(combo<KEY>(&key));
    return get_record(context, &key, sizeof(key), c, payload, payload_capacity, read_only);
  }

  ErrorCode get_record(
    thread::Thread* context,
    const void* key,
    uint16_t key_length,
    const HashCombo& combo,
    void* payload,
    uint16_t* payload_capacity,
    bool read_only);

  inline ErrorCode get_record_part(
    thread::Thread* context,
    const void* key,
    uint16_t key_length,
    void* payload,
    uint16_t payload_offset,
    uint16_t payload_count,
    bool read_only) {
    HashCombo c(combo(key, key_length));
    return get_record_part(
      context,
      key,
      key_length,
      c,
      payload,
      payload_offset,
      payload_count,
      read_only);
  }

  template <typename KEY>
  inline ErrorCode get_record_part(
    thread::Thread* context,
    KEY key,
    void* payload,
    uint16_t payload_offset,
    uint16_t payload_count,
    bool read_only) {
    HashCombo c(combo<KEY>(&key));
    return get_record_part(
      context,
      &key,
      sizeof(key),
      c,
      payload,
      payload_offset,
      payload_count,
      read_only);
  }

  ErrorCode get_record_part(
    thread::Thread* context,
    const void* key,
    uint16_t key_length,
    const HashCombo& combo,
    void* payload,
    uint16_t payload_offset,
    uint16_t payload_count,
    bool read_only);

  template <typename PAYLOAD>
  inline ErrorCode get_record_primitive(
    thread::Thread* context,
    const void* key,
    uint16_t key_length,
    PAYLOAD* payload,
    uint16_t payload_offset,
    bool read_only) {
    HashCombo c(combo(key, key_length));
    return get_record_primitive<PAYLOAD>(
      context,
      key,
      key_length,
      c,
      payload,
      payload_offset,
      read_only);
  }

  template <typename KEY, typename PAYLOAD>
  inline ErrorCode get_record_primitive(
    thread::Thread* context,
    KEY key,
    PAYLOAD* payload,
    uint16_t payload_offset,
    bool read_only) {
    HashCombo c(combo<KEY>(&key));
    return get_record_primitive<PAYLOAD>(
      context,
      &key,
      sizeof(key),
      c,
      payload,
      payload_offset,
      read_only);
  }

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

  // insert_record() methods

  inline ErrorCode insert_record(
    thread::Thread* context,
    const void* key,
    uint16_t key_length,
    const void* payload,
    uint16_t payload_count) {
    HashCombo c(combo(key, key_length));
    return insert_record(context, key, key_length, c, payload, payload_count, payload_count);
  }

  template <typename KEY>
  inline ErrorCode insert_record(
    thread::Thread* context,
    KEY key,
    const void* payload,
    uint16_t payload_count) {
    HashCombo c(combo<KEY>(&key));
    return insert_record(context, &key, sizeof(key), c, payload, payload_count, payload_count);
  }

  ErrorCode   insert_record(
    thread::Thread* context,
    const void* key,
    uint16_t key_length,
    const HashCombo& combo,
    const void* payload,
    uint16_t payload_count,
    uint16_t physical_payload_hint);

  // delete_record() methods

  inline ErrorCode delete_record(thread::Thread* context, const void* key, uint16_t key_length) {
    HashCombo c(combo(key, key_length));
    return delete_record(context, key, key_length, c);
  }

  template <typename KEY>
  inline ErrorCode delete_record(thread::Thread* context, KEY key) {
    HashCombo c(combo<KEY>(&key));
    return delete_record(context, &key, sizeof(key), c);
  }

  ErrorCode   delete_record(
    thread::Thread* context,
    const void* key,
    uint16_t key_length,
    const HashCombo& combo);

  // upsert_record() methods

  inline ErrorCode upsert_record(
    thread::Thread* context,
    const void* key,
    uint16_t key_length,
    const void* payload,
    uint16_t payload_count) {
    HashCombo c(combo(key, key_length));
    return upsert_record(context, key, key_length, c, payload, payload_count, payload_count);
  }

  template <typename KEY>
  inline ErrorCode upsert_record(
    thread::Thread* context,
    KEY key,
    const void* payload,
    uint16_t payload_count) {
    HashCombo c(combo<KEY>(&key));
    return upsert_record(context, &key, sizeof(key), c, payload, payload_count, payload_count);
  }

  ErrorCode   upsert_record(
    thread::Thread* context,
    const void* key,
    uint16_t key_length,
    const HashCombo& combo,
    const void* payload,
    uint16_t payload_count,
    uint16_t physical_payload_hint);

  // overwrite_record() methods

  inline ErrorCode overwrite_record(
    thread::Thread* context,
    const void* key,
    uint16_t key_length,
    const void* payload,
    uint16_t payload_offset,
    uint16_t payload_count) {
    HashCombo c(combo(key, key_length));
    return overwrite_record(
      context,
      key,
      key_length,
      c,
      payload,
      payload_offset,
      payload_count);
  }

  template <typename KEY>
  inline ErrorCode overwrite_record(
    thread::Thread* context,
    KEY key,
    const void* payload,
    uint16_t payload_offset,
    uint16_t payload_count) {
    HashCombo c(combo<KEY>(&key));
    return overwrite_record(context, &key, sizeof(key), c, payload, payload_offset, payload_count);
  }

  ErrorCode   overwrite_record(
    thread::Thread* context,
    const void* key,
    uint16_t key_length,
    const HashCombo& combo,
    const void* payload,
    uint16_t payload_offset,
    uint16_t payload_count);

  template <typename PAYLOAD>
  inline ErrorCode overwrite_record_primitive(
    thread::Thread* context,
    const void* key,
    uint16_t key_length,
    PAYLOAD payload,
    uint16_t payload_offset) {
    HashCombo c(combo(key, key_length));
    return overwrite_record_primitive(context, key, key_length, c, payload, payload_offset);
  }

  template <typename KEY, typename PAYLOAD>
  inline ErrorCode overwrite_record_primitive(
    thread::Thread* context,
    KEY key,
    PAYLOAD payload,
    uint16_t payload_offset) {
    HashCombo c(combo<KEY>(&key));
    return overwrite_record_primitive(context, &key, sizeof(key), c, payload, payload_offset);
  }

  template <typename PAYLOAD>
  ErrorCode   overwrite_record_primitive(
    thread::Thread* context,
    const void* key,
    uint16_t key_length,
    const HashCombo& combo,
    PAYLOAD payload,
    uint16_t payload_offset);

  // increment_record() methods

  template <typename PAYLOAD>
  inline ErrorCode increment_record(
    thread::Thread* context,
    const void* key,
    uint16_t key_length,
    PAYLOAD* value,
    uint16_t payload_offset) {
    HashCombo c(combo(key, key_length));
    return increment_record(context, key, key_length, c, value, payload_offset);
  }

  template <typename KEY, typename PAYLOAD>
  inline ErrorCode increment_record(
    thread::Thread* context,
    KEY key,
    PAYLOAD* value,
    uint16_t payload_offset) {
    HashCombo c(combo<KEY>(&key));
    return increment_record(context, &key, sizeof(key), c, value, payload_offset);
  }

  template <typename PAYLOAD>
  ErrorCode       increment_record(
    thread::Thread* context,
    const void* key,
    uint16_t key_length,
    const HashCombo& combo,
    PAYLOAD* value,
    uint16_t payload_offset);
};
}  // namespace hash
}  // namespace storage
}  // namespace foedus
#endif  // FOEDUS_STORAGE_HASH_HASH_STORAGE_HPP_