TileGroupHeader refactor (#1423)

* TileGroupHeader refactor to get rid of hardcoded pointer arithmetic and casts.

* Don't repeatedly look up the SpinLatch field.

* clang-format.

* Don't replace the SpinLatch on resetting of tuple.

* Fix in TileGroupHeader assignment operator.

* Update Field Descriptions based on refactor.

Author: mbutrovich

src/concurrency/timestamp_ordering_transaction_manager.cpp

@@ -27,60 +27,36 @@
 namespace peloton {
 namespace concurrency {
 
-common::synchronization::SpinLatch *
-TimestampOrderingTransactionManager::GetSpinLatchField(
-    const storage::TileGroupHeader *const tile_group_header,
-    const oid_t &tuple_id) {
-  return (
-      common::synchronization::SpinLatch
-          *)(tile_group_header->GetReservedFieldRef(tuple_id) + LOCK_OFFSET);
-}
-
-cid_t TimestampOrderingTransactionManager::GetLastReaderCommitId(
-    const storage::TileGroupHeader *const tile_group_header,
-    const oid_t &tuple_id) {
-  return *(cid_t *)(tile_group_header->GetReservedFieldRef(tuple_id) +
-                    LAST_READER_OFFSET);
-}
-
 bool TimestampOrderingTransactionManager::SetLastReaderCommitId(
     const storage::TileGroupHeader *const tile_group_header,
     const oid_t &tuple_id, const cid_t &current_cid, const bool is_owner) {
   // get the pointer to the last_reader_cid field.
-  cid_t *ts_ptr = (cid_t *)(tile_group_header->GetReservedFieldRef(tuple_id) +
-                            LAST_READER_OFFSET);
+  cid_t read_ts = tile_group_header->GetLastReaderCommitId(tuple_id);
+
+  auto latch = tile_group_header->GetSpinLatch(tuple_id);
 
-  GetSpinLatchField(tile_group_header, tuple_id)->Lock();
+  latch->Lock();
 
   txn_id_t tuple_txn_id = tile_group_header->GetTransactionId(tuple_id);
 
   if (is_owner == false && tuple_txn_id != INITIAL_TXN_ID) {
     // if the write lock has already been acquired by some concurrent
     // transactions,
     // then return without setting the last_reader_cid.
-    GetSpinLatchField(tile_group_header, tuple_id)->Unlock();
+    latch->Unlock();
     return false;
   } else {
     // if current_cid is larger than the current value of last_reader_cid field,
     // then set last_reader_cid to current_cid.
-    if (*ts_ptr < current_cid) {
-      *ts_ptr = current_cid;
+    if (read_ts < current_cid) {
+      tile_group_header->SetLastReaderCommitId(tuple_id, current_cid);
     }
 
-    GetSpinLatchField(tile_group_header, tuple_id)->Unlock();
+    latch->Unlock();
     return true;
   }
 }
 
-void TimestampOrderingTransactionManager::InitTupleReserved(
-    const storage::TileGroupHeader *const tile_group_header,
-    const oid_t tuple_id) {
-  auto reserved_area = tile_group_header->GetReservedFieldRef(tuple_id);
-
-  new ((reserved_area + LOCK_OFFSET)) common::synchronization::SpinLatch();
-  *(cid_t *)(reserved_area + LAST_READER_OFFSET) = 0;
-}
-
 TimestampOrderingTransactionManager &
 TimestampOrderingTransactionManager::GetInstance(
     const ProtocolType protocol, const IsolationLevelType isolation,
@@ -138,25 +114,26 @@ bool TimestampOrderingTransactionManager::AcquireOwnership(
   // to acquire the ownership,
   // we must guarantee that no transaction that has read
   // the tuple has a larger timestamp than the current transaction.
-  GetSpinLatchField(tile_group_header, tuple_id)->Lock();
+  auto latch = tile_group_header->GetSpinLatch(tuple_id);
+  latch->Lock();
   // change timestamp
-  cid_t last_reader_cid = GetLastReaderCommitId(tile_group_header, tuple_id);
+  cid_t last_reader_cid = tile_group_header->GetLastReaderCommitId(tuple_id);
 
   // must compare last_reader_cid with a transaction's commit_id
   // (rather than read_id).
   // consider a transaction that is executed under snapshot isolation.
   // in this case, commit_id is not equal to read_id.
   if (last_reader_cid > current_txn->GetCommitId()) {
-    GetSpinLatchField(tile_group_header, tuple_id)->Unlock();
+    tile_group_header->GetSpinLatch(tuple_id)->Unlock();
 
     return false;
   } else {
     if (tile_group_header->SetAtomicTransactionId(tuple_id, txn_id) == false) {
-      GetSpinLatchField(tile_group_header, tuple_id)->Unlock();
+      latch->Unlock();
 
       return false;
     } else {
-      GetSpinLatchField(tile_group_header, tuple_id)->Unlock();
+      latch->Unlock();
 
       return true;
     }
@@ -328,9 +305,9 @@ bool TimestampOrderingTransactionManager::PerformRead(TransactionContext *const
 
       // if we have already owned the version.
       PELOTON_ASSERT(IsOwner(current_txn, tile_group_header, tuple_id) == true);
-      PELOTON_ASSERT(GetLastReaderCommitId(tile_group_header, tuple_id) ==
+      PELOTON_ASSERT(tile_group_header->GetLastReaderCommitId(tuple_id) ==
                          current_txn->GetCommitId() ||
-                     GetLastReaderCommitId(tile_group_header, tuple_id) == 0);
+                     tile_group_header->GetLastReaderCommitId(tuple_id) == 0);
       return true;
 
     } else {
@@ -352,9 +329,9 @@ bool TimestampOrderingTransactionManager::PerformRead(TransactionContext *const
       } else {
         // if the current transaction has already owned this tuple,
         // then perform read directly.
-        PELOTON_ASSERT(GetLastReaderCommitId(tile_group_header, tuple_id) ==
+        PELOTON_ASSERT(tile_group_header->GetLastReaderCommitId(tuple_id) ==
                            current_txn->GetCommitId() ||
-                       GetLastReaderCommitId(tile_group_header, tuple_id) == 0);
+                       tile_group_header->GetLastReaderCommitId(tuple_id) == 0);
 
         // this version must already be in the read/write set.
         // so no need to update read set.
@@ -391,8 +368,6 @@ void TimestampOrderingTransactionManager::PerformInsert(
   // Add the new tuple into the insert set
   current_txn->RecordInsert(location);
 
-  InitTupleReserved(tile_group_header, tuple_id);
-
   // Write down the head pointer's address in tile group header
   tile_group_header->SetIndirection(tuple_id, index_entry_ptr);
 }
@@ -446,8 +421,6 @@ void TimestampOrderingTransactionManager::PerformUpdate(
   // newer version to older version.
   COMPILER_MEMORY_FENCE;
 
-  InitTupleReserved(new_tile_group_header, new_location.offset);
-
   // we must be updating the latest version.
   // Set the header information for the new version
   ItemPointer *index_entry_ptr =
@@ -520,9 +493,8 @@ void TimestampOrderingTransactionManager::PerformDelete(
 
   auto transaction_id = current_txn->GetTransactionId();
 
-  PELOTON_ASSERT(
-      GetLastReaderCommitId(tile_group_header, old_location.offset) ==
-      current_txn->GetCommitId());
+  PELOTON_ASSERT(tile_group_header->GetLastReaderCommitId(
+                     old_location.offset) == current_txn->GetCommitId());
 
   // if we can perform delete, then we must have already locked the older
   // version.
@@ -554,8 +526,6 @@ void TimestampOrderingTransactionManager::PerformDelete(
   // newer version to older version.
   COMPILER_MEMORY_FENCE;
 
-  InitTupleReserved(new_tile_group_header, new_location.offset);
-
   // we must be deleting the latest version.
   // Set the header information for the new version
   ItemPointer *index_entry_ptr =

src/gc/transaction_level_gc_manager.cpp

@@ -36,13 +36,12 @@ bool TransactionLevelGCManager::ResetTuple(const ItemPointer &location) {
 
   // Reset the header
   tile_group_header->SetTransactionId(location.offset, INVALID_TXN_ID);
+  tile_group_header->SetLastReaderCommitId(location.offset, INVALID_CID);
   tile_group_header->SetBeginCommitId(location.offset, MAX_CID);
   tile_group_header->SetEndCommitId(location.offset, MAX_CID);
-  tile_group_header->SetPrevItemPointer(location.offset, INVALID_ITEMPOINTER);
   tile_group_header->SetNextItemPointer(location.offset, INVALID_ITEMPOINTER);
-
-  PELOTON_MEMSET(tile_group_header->GetReservedFieldRef(location.offset), 0,
-                 storage::TileGroupHeader::GetReservedSize());
+  tile_group_header->SetPrevItemPointer(location.offset, INVALID_ITEMPOINTER);
+  tile_group_header->SetIndirection(location.offset, nullptr);
 
   // Reclaim the varlen pool
   CheckAndReclaimVarlenColumns(tile_group, location.offset);

src/include/concurrency/timestamp_ordering_transaction_manager.h

@@ -238,41 +238,7 @@ class TimestampOrderingTransactionManager : public TransactionManager {
    */
   virtual ResultType AbortTransaction(TransactionContext *const current_txn);
 
-
-private:
-  static const int LOCK_OFFSET = 0;
-  static const int LAST_READER_OFFSET = (LOCK_OFFSET + 8);
-
-  /**
-   * @brief      Gets the spin latch field.
-   * 
-   * Timestamp ordering requires a spinlock field for protecting the atomic access
-   * to txn_id field and last_reader_cid field.
-   *
-   * @param[in]  tile_group_header  The tile group header
-   * @param[in]  tuple_id           The tuple identifier
-   *
-   * @return     The spin latch field.
-   */
-  common::synchronization::SpinLatch *GetSpinLatchField(
-      const storage::TileGroupHeader *const tile_group_header,
-      const oid_t &tuple_id);
-
-  /**
-   * @brief      Gets the last reader commit identifier.
-   * 
-   * In timestamp ordering, the last_reader_cid records the timestamp of the last
-   * transaction that reads the tuple.
-   *
-   * @param[in]  tile_group_header  The tile group header
-   * @param[in]  tuple_id           The tuple identifier
-   *
-   * @return     The last reader commit identifier.
-   */
-  cid_t GetLastReaderCommitId(
-      const storage::TileGroupHeader *const tile_group_header,
-      const oid_t &tuple_id);
-
+ private:
   /**
    * @brief      Sets the last reader commit identifier.
    *
@@ -285,19 +251,7 @@ class TimestampOrderingTransactionManager : public TransactionManager {
    */
   bool SetLastReaderCommitId(
       const storage::TileGroupHeader *const tile_group_header,
-      const oid_t &tuple_id, 
-      const cid_t &current_cid, 
-      const bool is_owner);
-
-  /**
-   * Initialize reserved area of a tuple.
-   *
-   * @param[in]  tile_group_header  The tile group header
-   * @param[in]  tuple_id           The tuple identifier
-   */
-  void InitTupleReserved(
-      const storage::TileGroupHeader *const tile_group_header,
-      const oid_t tuple_id);
+      const oid_t &tuple_id, const cid_t &current_cid, const bool is_owner);
 };
 }
 }