array_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_ARRAY_ARRAY_STORAGE_HPP_
#define FOEDUS_STORAGE_ARRAY_ARRAY_STORAGE_HPP_

#include <cstring>
#include <iosfwd>
#include <string>

#include "foedus/assert_nd.hpp"
#include "foedus/attachable.hpp"
#include "foedus/cxx11.hpp"
#include "foedus/fwd.hpp"
#include "foedus/assorted/const_div.hpp"
#include "foedus/storage/fwd.hpp"
#include "foedus/storage/storage.hpp"
#include "foedus/storage/storage_id.hpp"
#include "foedus/storage/array/array_id.hpp"
#include "foedus/storage/array/array_metadata.hpp"
#include "foedus/storage/array/array_route.hpp"
#include "foedus/storage/array/fwd.hpp"
#include "foedus/thread/fwd.hpp"

namespace foedus {
namespace storage {
namespace array {

class ArrayStorage CXX11_FINAL : public Storage<ArrayStorageControlBlock> {
 public:
  typedef ArrayStoragePimpl   ThisPimpl;
  typedef ArrayCreateLogType  ThisCreateLogType;
  typedef ArrayMetadata       ThisMetadata;

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

  // Storage interface
  const ArrayMetadata*  get_array_metadata()  const;
  ErrorStack          create(const Metadata &metadata);
  ErrorStack          load(const StorageControlBlock& snapshot_block);
  ErrorStack          drop();

  ErrorCode prefetch_pages(
    thread::Thread* context,
    bool install_volatile,
    bool cache_snapshot,
    ArrayOffset from,
    ArrayOffset to);

  // this storage type doesn't use moved bit

  uint16_t    get_payload_size() const;

  ArrayOffset get_array_size() const;

  uint8_t     get_levels() const;

  ErrorCode  get_record(thread::Thread* context, ArrayOffset offset, void *payload);

  ErrorCode  get_record(thread::Thread* context, ArrayOffset offset,
            void *payload, uint16_t payload_offset, uint16_t payload_count);

  template <typename T>
  ErrorCode  get_record_primitive(thread::Thread* context, ArrayOffset offset,
            T *payload, uint16_t payload_offset);

  ErrorCode get_record_payload(thread::Thread* context, ArrayOffset offset, const void** payload);

  ErrorCode get_record_for_write(thread::Thread* context, ArrayOffset offset, Record** record);

  template <typename T>
  ErrorCode get_record_primitive_batch(
    thread::Thread* context,
    uint16_t payload_offset,
    uint16_t batch_size,
    const ArrayOffset* offset_batch,
    T *payload);
  ErrorCode get_record_payload_batch(
    thread::Thread* context,
    uint16_t batch_size,
    const ArrayOffset* offset_batch,
    const void** payload_batch);
  ErrorCode get_record_for_write_batch(
    thread::Thread* context,
    uint16_t batch_size,
    const ArrayOffset* offset_batch,
    Record** record_batch);

  ErrorCode  overwrite_record(thread::Thread* context, ArrayOffset offset, const void *payload) {
    return overwrite_record(context, offset, payload, 0, get_payload_size());
  }
  ErrorCode  overwrite_record(thread::Thread* context, ArrayOffset offset,
            const void *payload, uint16_t payload_offset, uint16_t payload_count);

  template <typename T>
  ErrorCode  overwrite_record_primitive(thread::Thread* context, ArrayOffset offset,
            T payload, uint16_t payload_offset);

  ErrorCode  overwrite_record(
    thread::Thread* context,
    ArrayOffset offset,
    Record* record,
    const void *payload,
    uint16_t payload_offset,
    uint16_t payload_count);

  template <typename T>
  ErrorCode  overwrite_record_primitive(
    thread::Thread* context,
    ArrayOffset offset,
    Record* record,
    T payload,
    uint16_t payload_offset);

  template <typename T>
  ErrorCode  increment_record(thread::Thread* context, ArrayOffset offset,
            T *value, uint16_t payload_offset);

  template <typename T>
  ErrorCode  increment_record_oneshot(
    thread::Thread* context,
    ArrayOffset offset,
    T value,
    uint16_t payload_offset);


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

  ErrorStack  hcc_reset_all_temperature_stat();

  ErrorStack  verify_single_thread(thread::Thread* context);
};

}  // namespace array
}  // namespace storage
}  // namespace foedus
#endif  // FOEDUS_STORAGE_ARRAY_ARRAY_STORAGE_HPP_