storage_id.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_ID_HPP_
#define FOEDUS_STORAGE_STORAGE_ID_HPP_
#include <stdint.h>

#include <iosfwd>

#include "foedus/assert_nd.hpp"
#include "foedus/assorted/assorted_func.hpp"
#include "foedus/assorted/fixed_string.hpp"
#include "foedus/assorted/raw_atomics.hpp"
#include "foedus/memory/memory_id.hpp"
#include "foedus/thread/thread_id.hpp"

namespace foedus {
namespace storage {

const uint16_t kPageSize = 1 << 12;

typedef uint32_t StorageId;

typedef assorted::FixedString<60> StorageName;
STATIC_SIZE_CHECK(sizeof(StorageName), 64)


typedef thread::ThreadGroupId PartitionId;

typedef uint64_t SnapshotPagePointer;

typedef uint64_t SnapshotLocalPageId;

inline SnapshotLocalPageId extract_local_page_id_from_snapshot_pointer(
  SnapshotPagePointer pointer) {
  return pointer & 0x000000FFFFFFFFFFULL;
}
inline uint8_t extract_numa_node_from_snapshot_pointer(SnapshotPagePointer pointer) {
  return static_cast<uint8_t>(pointer >> 40);
}
inline uint16_t extract_snapshot_id_from_snapshot_pointer(SnapshotPagePointer pointer) {
  return static_cast<uint16_t>(pointer >> 48);
}

inline void assert_valid_snapshot_local_page_id(SnapshotLocalPageId page_id) {
  ASSERT_ND(page_id < (1ULL << 40));
}

inline SnapshotPagePointer to_snapshot_page_pointer(
  uint16_t snapshot_id,
  uint8_t node,
  SnapshotLocalPageId local_page_id) {
  assert_valid_snapshot_local_page_id(local_page_id);
  return static_cast<uint64_t>(snapshot_id) << 48
      | static_cast<uint64_t>(node) << 40
      | local_page_id;
}

void describe_snapshot_pointer(std::ostream* o, SnapshotPagePointer pointer);

enum StorageType {
  kInvalidStorage = 0,
  kArrayStorage,
  kHashStorage,
  kMasstreeStorage,
  kSequentialStorage,
};

inline const char* to_storage_type_name(StorageType type) {
  switch (type) {
  case kInvalidStorage: return "Invalid";
  case kArrayStorage: return "Array";
  case kHashStorage: return "Hash";
  case kMasstreeStorage: return "Masstree";
  case kSequentialStorage: return "Sequential";
  default: return "Unknown";
  }
}

enum StorageStatus {
  kNotExists = 0,
  kExists,
  kMarkedForDeath,
};

typedef uint32_t Checksum;

const uint8_t kVolatilePointerFlagSwappable = 0x02;

struct VolatilePagePointer {
  uint64_t        word;

  VolatilePagePointer() : word(0) {}
  explicit VolatilePagePointer(uint64_t the_word) : word(the_word) {}
  VolatilePagePointer(const VolatilePagePointer& other) : word(other.word) {}

  uint8_t                get_numa_node() const { return static_cast<uint8_t>(word >> 32); }
  memory::PagePoolOffset get_offset() const { return static_cast<uint32_t>(word & 0xFFFFFFFFULL); }
  void set_offset_unsafe(memory::PagePoolOffset offset) {
    set(get_numa_node(), offset);
  }
  bool is_null() const { return get_offset() == 0; }
  void clear() { word = 0; }
  void set(uint8_t numa_node, memory::PagePoolOffset offset) {
    word = (static_cast<uint64_t>(numa_node) << 32) | offset;
  }
  bool is_equivalent(const VolatilePagePointer& other) const {
    // Now that we got rid of unused flags/mod_count, this is simply a word comparison.
    return word == other.word;
  }
  bool operator==(const VolatilePagePointer& other) const {
    return word == other.word;
  }
  bool operator!=(const VolatilePagePointer& other) const {
    return word != other.word;
  }

  friend std::ostream& operator<<(std::ostream& o, const VolatilePagePointer& v);
};
void describe_volatile_pointer(std::ostream* o, VolatilePagePointer pointer);

inline VolatilePagePointer construct_volatile_page_pointer(uint64_t word) {
  VolatilePagePointer pointer;
  pointer.word = word;
  return pointer;
}
inline VolatilePagePointer combine_volatile_page_pointer(
  uint8_t numa_node,
  memory::PagePoolOffset offset) {
  VolatilePagePointer ret;
  ret.set(numa_node, offset);
  return ret;
}

struct DualPagePointer {
  DualPagePointer() : snapshot_pointer_(0) {
    volatile_pointer_.word = 0;
  }

  bool operator==(const DualPagePointer& other) const {
    return snapshot_pointer_ == other.snapshot_pointer_
      && volatile_pointer_.word == other.volatile_pointer_.word;
  }
  bool operator!=(const DualPagePointer& other) const {
    return !operator==(other);
  }

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

  bool atomic_compare_exchange_strong(
    const DualPagePointer &expected, const DualPagePointer &desired) {
    return assorted::raw_atomic_compare_exchange_strong_uint128(
      reinterpret_cast<uint64_t*>(this),
      reinterpret_cast<const uint64_t*>(&expected),
      reinterpret_cast<const uint64_t*>(&desired));
  }
  bool atomic_compare_exchange_weak(
    const DualPagePointer &expected, const DualPagePointer &desired) {
    return assorted::raw_atomic_compare_exchange_weak_uint128(
      reinterpret_cast<uint64_t*>(this),
      reinterpret_cast<const uint64_t*>(&expected),
      reinterpret_cast<const uint64_t*>(&desired));
  }

  bool is_both_null() const {
    return snapshot_pointer_ == 0 && volatile_pointer_.is_null();
  }

  SnapshotPagePointer snapshot_pointer_;
  VolatilePagePointer volatile_pointer_;
};
STATIC_SIZE_CHECK(sizeof(DualPagePointer), sizeof(uint64_t) * 2)

}  // namespace storage
}  // namespace foedus
#endif  // FOEDUS_STORAGE_STORAGE_ID_HPP_