xct_access.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_XCT_XCT_ACCESS_HPP_
#define FOEDUS_XCT_XCT_ACCESS_HPP_
#include <stdint.h>

#include <iosfwd>

#include "foedus/compiler.hpp"
#include "foedus/log/fwd.hpp"
#include "foedus/memory/fwd.hpp"
#include "foedus/storage/fwd.hpp"
#include "foedus/storage/page.hpp"
#include "foedus/storage/storage_id.hpp"
#include "foedus/xct/fwd.hpp"
#include "foedus/xct/xct_id.hpp"

namespace foedus {
namespace xct {

struct PointerAccess {
  friend std::ostream& operator<<(std::ostream& o, const PointerAccess& v);

  const storage::VolatilePagePointer* address_;

  storage::VolatilePagePointer        observed_;
};

struct PageVersionAccess {
  friend std::ostream& operator<<(std::ostream& o, const PageVersionAccess& v);

  const storage::PageVersion* address_;

  storage::PageVersionStatus observed_;
};

struct RecordXctAccess {
  storage::StorageId    storage_id_;

  uint32_t              ordinal_;

  RwLockableXctId*      owner_id_address_;

  UniversalLockId       owner_lock_id_;

  void set_owner_id_and_lock_id(RwLockableXctId* owner_id_address, UniversalLockId owner_lock_id) {
    owner_id_address_ = owner_id_address;
    owner_lock_id_ = owner_lock_id;
  }
  void set_owner_id_resolve_lock_id(
    const memory::GlobalVolatilePageResolver& resolver,
    RwLockableXctId* owner_id_address);

  static bool compare(const RecordXctAccess &left, const RecordXctAccess& right) ALWAYS_INLINE;
};

struct ReadXctAccess : public RecordXctAccess {
  friend std::ostream& operator<<(std::ostream& o, const ReadXctAccess& v);

  XctId               observed_owner_id_;

  WriteXctAccess*     related_write_;

  static bool compare(const ReadXctAccess &left, const ReadXctAccess& right) ALWAYS_INLINE {
    return RecordXctAccess::compare(left, right);
  }
};

struct WriteXctAccess : public RecordXctAccess {
  friend std::ostream& operator<<(std::ostream& o, const WriteXctAccess& v);

  char*                 payload_address_;

  log::RecordLogType*   log_entry_;

  ReadXctAccess*        related_read_;

  static bool compare(const WriteXctAccess &left, const WriteXctAccess& right) ALWAYS_INLINE {
    return RecordXctAccess::compare(left, right);
  }
};

struct LockFreeReadXctAccess {
  friend std::ostream& operator<<(std::ostream& o, const LockFreeReadXctAccess& v);

  XctId               observed_owner_id_;

  storage::StorageId  storage_id_;

  RwLockableXctId*    owner_id_address_;

  // no related-write in this object.
  // also, no sorting needed for this object.
};

struct LockFreeWriteXctAccess {
  friend std::ostream& operator<<(std::ostream& o, const LockFreeWriteXctAccess& v);

  storage::StorageId    storage_id_;

  log::RecordLogType*   log_entry_;

  // no need for compare method or storing version/record/etc. it's lock-free!
};

inline bool RecordXctAccess::compare(
  const RecordXctAccess& left,
  const RecordXctAccess& right) {
  if (left.owner_lock_id_ != right.owner_lock_id_) {
    return left.owner_lock_id_ < right.owner_lock_id_;
  } else {
    return left.ordinal_ < right.ordinal_;
  }
}

}  // namespace xct
}  // namespace foedus
#endif  // FOEDUS_XCT_XCT_ACCESS_HPP_