Revert LockFreeArray changes

Author: poojanilangekar

cmake/Dependencies.cmake

@@ -26,8 +26,6 @@ find_package(TBB REQUIRED)
 include_directories(SYSTEM ${TBB_INCLUDE_DIRS})
 list(APPEND Peloton_LINKER_LIBS ${TBB_LIBRARIES})
 
-#add_executable(TBB_Sample TBB_Sample.cpp)
-
 # ---[ Cap'nProto
 include("cmake/External/capnproto.cmake")
 include_directories(SYSTEM ${CAPNP_INCLUDE_DIRS})

src/common/container/lock_free_array.cpp

@@ -31,46 +31,41 @@ class IndirectionArray;
 
 LOCK_FREE_ARRAY_TEMPLATE_ARGUMENTS
 LOCK_FREE_ARRAY_TYPE::LockFreeArray(){
-  new_lock_free_array.clear();
+  lock_free_array.reset(new lock_free_array_t());
 }
 
 LOCK_FREE_ARRAY_TEMPLATE_ARGUMENTS
 LOCK_FREE_ARRAY_TYPE::~LockFreeArray(){
-  new_lock_free_array.clear();
 }
 
 LOCK_FREE_ARRAY_TEMPLATE_ARGUMENTS
 bool LOCK_FREE_ARRAY_TYPE::Update(const std::size_t &offset, ValueType value){
   PL_ASSERT(offset <= LOCK_FREE_ARRAY_MAX_SIZE);
   LOG_TRACE("Update at %lu", lock_free_array_offset.load());
-  if (new_lock_free_array.size() < offset + 1) {
-    new_lock_free_array.resize(LOCK_FREE_ARRAY_MAX_SIZE);
-  }
-  new_lock_free_array.at(offset) = value;
+  lock_free_array->at(offset) =  value;
   return true;
 }
 
 LOCK_FREE_ARRAY_TEMPLATE_ARGUMENTS
 bool LOCK_FREE_ARRAY_TYPE::Append(ValueType value){
   LOG_TRACE("Appended at %lu", lock_free_array_offset.load());
-  new_lock_free_array.push_back(value);
+  lock_free_array->at(lock_free_array_offset++) = value;
   return true;
 }
 
 LOCK_FREE_ARRAY_TEMPLATE_ARGUMENTS
 bool LOCK_FREE_ARRAY_TYPE::Erase(const std::size_t &offset, const ValueType& invalid_value){
   PL_ASSERT(offset <= LOCK_FREE_ARRAY_MAX_SIZE);
   LOG_TRACE("Erase at %lu", offset);
-  new_lock_free_array.at(offset) = invalid_value;
+  lock_free_array->at(offset) =  invalid_value;
   return true;
 }
 
 LOCK_FREE_ARRAY_TEMPLATE_ARGUMENTS
 ValueType LOCK_FREE_ARRAY_TYPE::Find(const std::size_t &offset) const{
   PL_ASSERT(offset <= LOCK_FREE_ARRAY_MAX_SIZE);
   LOG_TRACE("Find at %lu", offset);
-//  auto value = lock_free_array->at(offset);
-  auto value = new_lock_free_array.at(offset);
+  auto value = lock_free_array->at(offset);
   return value;
 }
 
@@ -82,11 +77,11 @@ ValueType LOCK_FREE_ARRAY_TYPE::FindValid(const std::size_t &offset,
 
   std::size_t valid_array_itr = 0;
   std::size_t array_itr;
-  auto new_lock_free_array_offset = new_lock_free_array.size();
+
   for(array_itr = 0;
-      array_itr < new_lock_free_array_offset;
+      array_itr < lock_free_array_offset;
       array_itr++){
-    auto value = new_lock_free_array.at(array_itr);
+    auto value = lock_free_array->at(array_itr);
     if (value != invalid_value) {
       // Check offset
       if(valid_array_itr == offset) {
@@ -103,26 +98,22 @@ ValueType LOCK_FREE_ARRAY_TYPE::FindValid(const std::size_t &offset,
 
 LOCK_FREE_ARRAY_TEMPLATE_ARGUMENTS
 size_t LOCK_FREE_ARRAY_TYPE::GetSize() const{
-  return new_lock_free_array.size();
-//  return lock_free_array_offset;
+  return lock_free_array_offset;
 }
 
 LOCK_FREE_ARRAY_TEMPLATE_ARGUMENTS
 bool LOCK_FREE_ARRAY_TYPE::IsEmpty() const{
-  return new_lock_free_array.empty();
-//  return lock_free_array->empty();
+  return lock_free_array->empty();
 }
 
 LOCK_FREE_ARRAY_TEMPLATE_ARGUMENTS
 void LOCK_FREE_ARRAY_TYPE::Clear(const ValueType& invalid_value) {
 
   // Set invalid value for all elements and reset lock_free_array_offset
-
   for(std::size_t array_itr = 0;
-      array_itr < new_lock_free_array.size();
+      array_itr < lock_free_array_offset;
       array_itr++){
-//    lock_free_array->at(array_itr) = invalid_value;
-    new_lock_free_array.at(array_itr) = invalid_value;
+    lock_free_array->at(array_itr) = invalid_value;
   }
 
   // Reset sentinel
@@ -136,9 +127,9 @@ bool LOCK_FREE_ARRAY_TYPE::Contains(const ValueType& value) {
   bool exists = false;
 
   for(std::size_t array_itr = 0;
-      array_itr < new_lock_free_array.size();
+      array_itr < lock_free_array_offset;
       array_itr++){
-    auto array_value = new_lock_free_array.at(array_itr);
+    auto array_value = lock_free_array->at(array_itr);
     // Check array value
     if(array_value == value) {
       exists = true;

src/include/common/container/lock_free_array.h

@@ -12,17 +12,14 @@
 
 
 #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 {
 
 #define LOCK_FREE_ARRAY_MAX_SIZE 1024 * 1024
@@ -75,10 +72,7 @@ class LockFreeArray {
   std::atomic<std::size_t> lock_free_array_offset {0};
 
   // lock free array
-//  std::unique_ptr<lock_free_array_t> lock_free_array;
-  typedef tbb::concurrent_vector<ValueType, tbb::zero_allocator<ValueType>> TBBLockFreeArray;
-  TBBLockFreeArray new_lock_free_array;
-
+  std::unique_ptr<lock_free_array_t> lock_free_array;
 };
 
 }  // namespace peloton