Lock_free_array refactor, documentation, and added more tests.

Refactor of RecordDelete to reduce lookups.

Author: mbutrovich

src/common/container/lock_free_array.cpp

@@ -10,12 +10,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include <memory>
-
 #include "common/container/lock_free_array.h"
+#include "common/internal_types.h"
 #include "common/logger.h"
 #include "common/macros.h"
-#include "common/internal_types.h"
 
 namespace peloton {
 
@@ -38,26 +36,23 @@ template <typename ValueType>
 LOCK_FREE_ARRAY_TYPE::~LockFreeArray() { lock_free_array.clear(); }
 
 template <typename ValueType>
-bool LOCK_FREE_ARRAY_TYPE::Update(const std::size_t &offset, ValueType value) {
+void LOCK_FREE_ARRAY_TYPE::Update(const std::size_t &offset, const ValueType &value) {
   LOG_TRACE("Update at %lu", offset);
-  PELOTON_ASSERT(lock_free_array.size() >= offset + 1);
+  PELOTON_ASSERT(lock_free_array.size() > offset);
   lock_free_array.at(offset) = value;
-  return true;
 }
 
 template <typename ValueType>
-bool LOCK_FREE_ARRAY_TYPE::Append(ValueType value) {
+void LOCK_FREE_ARRAY_TYPE::Append(const ValueType &value) {
   LOG_TRACE("Appended value.");
   lock_free_array.push_back(value);
-  return true;
 }
 
 template <typename ValueType>
-bool LOCK_FREE_ARRAY_TYPE::Erase(const std::size_t &offset,
+void LOCK_FREE_ARRAY_TYPE::Erase(const std::size_t &offset,
                                  const ValueType &invalid_value) {
   LOG_TRACE("Erase at %lu", offset);
   lock_free_array.at(offset) = invalid_value;
-  return true;
 }
 
 template <typename ValueType>
@@ -88,10 +83,14 @@ template <typename ValueType>
 bool LOCK_FREE_ARRAY_TYPE::IsEmpty() const { return lock_free_array.empty(); }
 
 template <typename ValueType>
-void LOCK_FREE_ARRAY_TYPE::Clear() { lock_free_array.clear(); }
+void LOCK_FREE_ARRAY_TYPE::Clear() {
+  // Intel docs: To free internal arrays, call shrink_to_fit() after clear().
+  lock_free_array.clear();
+  lock_free_array.shrink_to_fit();
+}
 
 template <typename ValueType>
-bool LOCK_FREE_ARRAY_TYPE::Contains(const ValueType &value) {
+bool LOCK_FREE_ARRAY_TYPE::Contains(const ValueType &value) const {
   bool exists = false;
 
   for (std::size_t array_itr = 0; array_itr < lock_free_array.size();

src/concurrency/transaction_context.cpp

@@ -122,11 +122,11 @@ void TransactionContext::RecordInsert(const ItemPointer &location) {
 void TransactionContext::RecordDelete(const ItemPointer &location) {
   PELOTON_ASSERT(rw_set_.count(location) == 0 ||
       (rw_set_[location] != RWType::DELETE && rw_set_[location] != RWType::INS_DEL));
-  if (rw_set_[location] == RWType::INSERT) {
-    rw_set_[location] = RWType::INS_DEL;
+  auto rw_set_it = rw_set_.find(location);
+  if (rw_set_it != rw_set_.end() && rw_set_it->second == RWType::INSERT) {
+    rw_set_it->second = RWType::INS_DEL;
   }
   else {
-    // READ, READ_OWN, UPDATE
     rw_set_[location] = RWType::DELETE;
   }
 }

src/include/common/container/lock_free_array.h

@@ -12,13 +12,6 @@
 
 #pragma once
 #include "tbb/concurrent_vector.h"
-#include "tbb/tbb_allocator.h"
-#include <cstdlib>
-#include <cstring>
-#include <cstdio>
-#include <array>
-#include <atomic>
-#include <memory>
 
 namespace peloton {
 
@@ -35,33 +28,74 @@ class LockFreeArray {
   LockFreeArray();
   ~LockFreeArray();
 
-  // Update a item
-  bool Update(const std::size_t &offset, ValueType value);
-
-  // Append an item
-  bool Append(ValueType value);
-
-  // Get a item
+  /**
+   * Assigns the provided value to the provided offset.
+   *
+   * @param offset  Element offset to update
+   * @param value   Value to be assigned
+   */
+  void Update(const std::size_t &offset, const ValueType &value);
+
+  /**
+   * Appends an element to the end of the array
+   *
+   * @param value   Value to be appended
+   */
+  void Append(const ValueType &value);
+
+  /**
+   * Returns the element at the offset
+   *
+   * @returns   Element at offset
+   */
   ValueType Find(const std::size_t &offset) const;
 
-  // Get a valid item
+  /**
+   * Returns the element at the offset, or invalid_value if
+   * the element does not exist.
+   *
+   * @param offset          Element offset to access
+   * @param invalid_value   Sentinel value to return if element
+   *                        does not exist or offset out of range
+   * @returns               Element at offset or invalid_value
+   */
   ValueType FindValid(const std::size_t &offset,
                       const ValueType &invalid_value) const;
 
-  // Delete key from the lock_free_array
-  bool Erase(const std::size_t &offset, const ValueType &invalid_value);
-
-  // Returns item count in the lock_free_array
+  /**
+   * Assigns the provided invalid_value to the provided offset.
+   *
+   * @param offset          Element offset to update
+   * @param invalid_value   Invalid value to be assigned
+   */
+  void Erase(const std::size_t &offset, const ValueType &invalid_value);
+
+  /**
+   *
+   * @return Number of elements in the underlying structure
+   */
   size_t GetSize() const;
 
-  // Checks if the lock_free_array is empty
+  /**
+   *
+   * @return True if empty, false otherwise
+   */
   bool IsEmpty() const;
 
-  // Clear all elements and reset them to default value
+  /**
+   * Resets the underlying data structure to have 0 elements
+   */
   void Clear();
 
-  // Exists ?
-  bool Contains(const ValueType &value);
+  /**
+   *
+   * Check the lock-free array for the provided value.
+   * O(n) time complexity.
+   *
+   * @param value  value to search for
+   * @return       True if element present, false otherwise
+   */
+  bool Contains(const ValueType &value) const;
 
  private:
   // lock free array

test/common/lock_free_array_test.cpp

@@ -34,8 +34,7 @@ TEST_F(LockFreeArrayTests, BasicTest) {
 
     size_t const element_count = 3;
     for (size_t element = 0; element < element_count; ++element ) {
-      auto status = array.Append(element);
-      EXPECT_TRUE(status);
+      array.Append(element);
     }
 
     auto array_size = array.GetSize();
@@ -55,8 +54,7 @@ TEST_F(LockFreeArrayTests, SharedPointerTest1) {
     size_t const element_count = 3;
     for (size_t element = 0; element < element_count; ++element ) {
       std::shared_ptr<oid_t> entry(new oid_t);
-      auto status = array.Append(entry);
-      EXPECT_TRUE(status);
+      array.Append(entry);
     }
 
     auto array_size = array.GetSize();
@@ -77,17 +75,15 @@ TEST_F(LockFreeArrayTests, SharedPointerTest2) {
       size_t const element_count = 10000;
       for (size_t element = 0; element < element_count; ++element ) {
         std::shared_ptr<oid_t> entry(new oid_t);
-        auto status = array.Append(entry);
-        EXPECT_TRUE(status);
+        array.Append(entry);
       }
     });
 
 
     size_t const element_count = 10000;
     for (size_t element = 0; element < element_count; ++element ) {
       std::shared_ptr<oid_t> entry(new oid_t);
-      auto status = array.Append(entry);
-      EXPECT_TRUE(status);
+      array.Append(entry);
     }
     t0.join();
 
@@ -99,5 +95,108 @@ TEST_F(LockFreeArrayTests, SharedPointerTest2) {
   }
 }
 
+TEST_F(LockFreeArrayTests, FindValidAndEraseTest) {
+
+  typedef uint32_t  value_type;
+
+  {
+    LockFreeArray<value_type> array;
+
+    value_type invalid_value = 6288;
+
+    size_t const element_count = 3;
+    for (size_t element = 0; element < element_count; ++element ) {
+      array.Append(element);
+    }
+
+    // in range, valid
+    EXPECT_EQ(2, array.FindValid(2, invalid_value));
+
+    // out of range
+    EXPECT_EQ(invalid_value, array.FindValid(6, invalid_value));
+
+    array.Erase(2, invalid_value);
+
+    // in range, erased
+    EXPECT_EQ(invalid_value, array.FindValid(2, invalid_value));
+  }
+
+}
+
+TEST_F(LockFreeArrayTests, ClearAndIsEmptyTest) {
+
+  typedef uint32_t  value_type;
+
+  {
+    LockFreeArray<value_type> array;
+
+    EXPECT_TRUE(array.IsEmpty());
+
+    size_t const element_count = 3;
+    for (size_t element = 0; element < element_count; ++element ) {
+      array.Append(element);
+    }
+
+    EXPECT_TRUE(array.Contains(2));
+
+    EXPECT_FALSE(array.IsEmpty());
+
+    array.Clear();
+
+    EXPECT_TRUE(array.IsEmpty());
+
+
+    EXPECT_FALSE(array.Contains(2));
+
+  }
+
+}
+
+TEST_F(LockFreeArrayTests, ContainsTest) {
+
+  typedef uint32_t  value_type;
+
+  {
+    LockFreeArray<value_type> array;
+
+    EXPECT_FALSE(array.Contains(2));
+
+    size_t const element_count = 3;
+    for (size_t element = 0; element < element_count; ++element ) {
+      array.Append(element);
+    }
+
+    EXPECT_TRUE(array.Contains(2));
+
+    array.Clear();
+
+    EXPECT_FALSE(array.Contains(2));
+
+  }
+
+}
+
+TEST_F(LockFreeArrayTests, UpdateTest) {
+
+  typedef uint32_t  value_type;
+
+  {
+    LockFreeArray<value_type> array;
+
+    size_t const element_count = 3;
+    for (size_t element = 0; element < element_count; ++element ) {
+      array.Append(element);
+    }
+
+    EXPECT_EQ(2, array.Find(2));
+
+    array.Update(2, 6288);
+
+    EXPECT_EQ(6288, array.Find(2));
+
+  }
+
+}
+
 }  // namespace test
 }  // namespace peloton