Merge pull request #1253 from zhaoguoquan94/lockfreearray

pervazea · web-flow · commit b7aa3041ba81 · 2018-04-08T09:18:56.000-04:00
Lockfreearray
diff --git a/src/catalog/manager.cpp b/src/catalog/manager.cpp
@@ -36,51 +36,39 @@ Manager &Manager::GetInstance() {
 
 void Manager::AddTileGroup(const oid_t oid,
                            std::shared_ptr<storage::TileGroup> location) {
-
   // add/update the catalog reference to the tile group
-  tile_group_locator_.Update(oid, location);
+  tile_group_locator_[oid] = location;
 }
 
 void Manager::DropTileGroup(const oid_t oid) {
-  
   // drop the catalog reference to the tile group
-  tile_group_locator_.Erase(oid, empty_tile_group_);
+  tile_group_locator_[oid] = empty_tile_group_;
 }
 
 std::shared_ptr<storage::TileGroup> Manager::GetTileGroup(const oid_t oid) {
-  std::shared_ptr<storage::TileGroup> location;
-  
-  location = tile_group_locator_.Find(oid);
-
-  return location;
+  auto iter = tile_group_locator_.find(oid);
+  if (iter == tile_group_locator_.end()) {
+    return empty_tile_group_;
+  }
+  return iter->second;
 }
 
 // used for logging test
-void Manager::ClearTileGroup() {
-
-  tile_group_locator_.Clear(empty_tile_group_);
-}
-
-
-void Manager::AddIndirectionArray(const oid_t oid,
-                                  std::shared_ptr<storage::IndirectionArray> location) {
+void Manager::ClearTileGroup() { tile_group_locator_.clear(); }
 
+void Manager::AddIndirectionArray(
+    const oid_t oid, std::shared_ptr<storage::IndirectionArray> location) {
   // add/update the catalog reference to the indirection array
-  indirection_array_locator_.Update(oid, location);
+  auto ret = indirection_array_locator_[oid] = location;
 }
 
 void Manager::DropIndirectionArray(const oid_t oid) {
-  
   // drop the catalog reference to the tile group
-  indirection_array_locator_.Erase(oid, empty_indirection_array_);
+  indirection_array_locator_[oid] = empty_indirection_array_;
 }
 
-
 // used for logging test
-void Manager::ClearIndirectionArray() {
-
-  indirection_array_locator_.Clear(empty_indirection_array_);
-}
+void Manager::ClearIndirectionArray() { indirection_array_locator_.clear(); }
 
 }  // namespace catalog
 }  // namespace peloton
diff --git a/src/common/container/lock_free_array.cpp b/src/common/container/lock_free_array.cpp
@@ -19,72 +19,68 @@
 
 namespace peloton {
 
-namespace index{
+namespace index {
 class Index;
 }
 
-namespace storage{
+namespace storage {
 class TileGroup;
 class Database;
 class IndirectionArray;
 }
 
-LOCK_FREE_ARRAY_TEMPLATE_ARGUMENTS
-LOCK_FREE_ARRAY_TYPE::LockFreeArray(){
-  lock_free_array.reset(new lock_free_array_t());
+template <typename ValueType>
+LOCK_FREE_ARRAY_TYPE::LockFreeArray() {
+  lock_free_array.reserve(kLockfreeArrayInitSize);
 }
 
-LOCK_FREE_ARRAY_TEMPLATE_ARGUMENTS
-LOCK_FREE_ARRAY_TYPE::~LockFreeArray(){
-}
+template <typename ValueType>
+LOCK_FREE_ARRAY_TYPE::~LockFreeArray() { lock_free_array.clear(); }
 
-LOCK_FREE_ARRAY_TEMPLATE_ARGUMENTS
-bool LOCK_FREE_ARRAY_TYPE::Update(const std::size_t &offset, ValueType value){
-  PELOTON_ASSERT(offset <= LOCK_FREE_ARRAY_MAX_SIZE);
-  LOG_TRACE("Update at %lu", lock_free_array_offset.load());
-  lock_free_array->at(offset) =  value;
+template <typename ValueType>
+bool LOCK_FREE_ARRAY_TYPE::Update(const std::size_t &offset, ValueType value) {
+  LOG_TRACE("Update at %lu", offset);
+  PELOTON_ASSERT(lock_free_array.size() >= offset + 1);
+  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());
-  lock_free_array->at(lock_free_array_offset++) = value;
+template <typename ValueType>
+bool LOCK_FREE_ARRAY_TYPE::Append(ValueType value) {
+  LOG_TRACE("Appended value.");
+  lock_free_array.push_back(value);
   return true;
 }
 
-LOCK_FREE_ARRAY_TEMPLATE_ARGUMENTS
-bool LOCK_FREE_ARRAY_TYPE::Erase(const std::size_t &offset, const ValueType& invalid_value){
-  PELOTON_ASSERT(offset <= LOCK_FREE_ARRAY_MAX_SIZE);
+template <typename ValueType>
+bool 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;
+  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{
-  PELOTON_ASSERT(offset <= LOCK_FREE_ARRAY_MAX_SIZE);
+template <typename ValueType>
+ValueType LOCK_FREE_ARRAY_TYPE::Find(const std::size_t &offset) const {
   LOG_TRACE("Find at %lu", offset);
-  auto value = lock_free_array->at(offset);
+  PELOTON_ASSERT(lock_free_array.size() > offset);
+  auto value = lock_free_array.at(offset);
   return value;
 }
 
-LOCK_FREE_ARRAY_TEMPLATE_ARGUMENTS
-ValueType LOCK_FREE_ARRAY_TYPE::FindValid(const std::size_t &offset,
-                                          const ValueType& invalid_value) const {
-  PELOTON_ASSERT(offset <= LOCK_FREE_ARRAY_MAX_SIZE);
+template <typename ValueType>
+ValueType LOCK_FREE_ARRAY_TYPE::FindValid(
+    const std::size_t &offset, const ValueType &invalid_value) const {
   LOG_TRACE("Find Valid at %lu", offset);
 
   std::size_t valid_array_itr = 0;
   std::size_t array_itr;
-
-  for(array_itr = 0;
-      array_itr < lock_free_array_offset;
-      array_itr++){
-    auto value = lock_free_array->at(array_itr);
+  auto lock_free_array_offset = lock_free_array.size();
+  for (array_itr = 0; array_itr < lock_free_array_offset; array_itr++) {
+    auto value = lock_free_array.at(array_itr);
     if (value != invalid_value) {
       // Check offset
-      if(valid_array_itr == offset) {
+      if (valid_array_itr == offset) {
         return value;
       }
 
@@ -96,42 +92,24 @@ ValueType LOCK_FREE_ARRAY_TYPE::FindValid(const std::size_t &offset,
   return invalid_value;
 }
 
-LOCK_FREE_ARRAY_TEMPLATE_ARGUMENTS
-size_t LOCK_FREE_ARRAY_TYPE::GetSize() const{
-  return lock_free_array_offset;
-}
+template <typename ValueType>
+size_t LOCK_FREE_ARRAY_TYPE::GetSize() const { return lock_free_array.size(); }
 
-LOCK_FREE_ARRAY_TEMPLATE_ARGUMENTS
-bool LOCK_FREE_ARRAY_TYPE::IsEmpty() const{
-  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 < lock_free_array_offset;
-      array_itr++){
-    lock_free_array->at(array_itr) = invalid_value;
-  }
+template <typename ValueType>
+bool LOCK_FREE_ARRAY_TYPE::IsEmpty() const { return lock_free_array.empty(); }
 
-  // Reset sentinel
-  lock_free_array_offset = 0;
-
-}
-
-LOCK_FREE_ARRAY_TEMPLATE_ARGUMENTS
-bool LOCK_FREE_ARRAY_TYPE::Contains(const ValueType& value) {
+template <typename ValueType>
+void LOCK_FREE_ARRAY_TYPE::Clear() { lock_free_array.clear(); }
 
+template <typename ValueType>
+bool LOCK_FREE_ARRAY_TYPE::Contains(const ValueType &value) {
   bool exists = false;
 
-  for(std::size_t array_itr = 0;
-      array_itr < lock_free_array_offset;
-      array_itr++){
-    auto array_value = lock_free_array->at(array_itr);
+  for (std::size_t array_itr = 0; array_itr < lock_free_array.size();
+       array_itr++) {
+    auto array_value = lock_free_array.at(array_itr);
     // Check array value
-    if(array_value == value) {
+    if (array_value == value) {
       exists = true;
       break;
     }
@@ -145,12 +123,6 @@ template class LockFreeArray<std::shared_ptr<oid_t>>;
 
 template class LockFreeArray<std::shared_ptr<index::Index>>;
 
-template class LockFreeArray<std::shared_ptr<storage::TileGroup>>;
-
-template class LockFreeArray<std::shared_ptr<storage::Database>>;
-
-template class LockFreeArray<std::shared_ptr<storage::IndirectionArray>>;
-
 template class LockFreeArray<oid_t>;
 
 }  // namespace peloton
diff --git a/src/include/catalog/manager.h b/src/include/catalog/manager.h
@@ -18,11 +18,12 @@
 #include <vector>
 #include <unordered_map>
 #include <memory>
+#include "common/internal_types.h"
 
 #include "common/macros.h"
 #include "common/internal_types.h"
 #include "common/container/lock_free_array.h"
-
+#include "tbb/concurrent_unordered_map.h"
 namespace peloton {
 
 namespace storage {
@@ -64,7 +65,6 @@ class Manager {
 
   void ClearTileGroup(void);
 
-
   //===--------------------------------------------------------------------===//
   // INDIRECTION ARRAY ALLOCATION
   //===--------------------------------------------------------------------===//
@@ -94,17 +94,18 @@ class Manager {
   //===--------------------------------------------------------------------===//
   std::atomic<oid_t> tile_group_oid_ = ATOMIC_VAR_INIT(START_OID);
 
-  LockFreeArray<std::shared_ptr<storage::TileGroup>> tile_group_locator_;
-
+  tbb::concurrent_unordered_map<oid_t, std::shared_ptr<storage::TileGroup>>
+      tile_group_locator_;
   static std::shared_ptr<storage::TileGroup> empty_tile_group_;
 
   //===--------------------------------------------------------------------===//
   // Data members for indirection array allocation
   //===--------------------------------------------------------------------===//
   std::atomic<oid_t> indirection_array_oid_ = ATOMIC_VAR_INIT(START_OID);
 
-  LockFreeArray<std::shared_ptr<storage::IndirectionArray>> indirection_array_locator_;
-
+  tbb::concurrent_unordered_map<oid_t,
+                                std::shared_ptr<storage::IndirectionArray>>
+      indirection_array_locator_;
   static std::shared_ptr<storage::IndirectionArray> empty_indirection_array_;
 };
 
diff --git a/src/include/common/container/lock_free_array.h b/src/include/common/container/lock_free_array.h
@@ -10,9 +10,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-
 #pragma once
-
+#include "tbb/concurrent_vector.h"
+#include "tbb/tbb_allocator.h"
 #include <cstdlib>
 #include <cstring>
 #include <cstdio>
@@ -22,18 +22,16 @@
 
 namespace peloton {
 
-#define LOCK_FREE_ARRAY_MAX_SIZE 1024 * 1024
+static const size_t kLockfreeArrayInitSize = 256;
 
 // LOCK_FREE_ARRAY_TEMPLATE_ARGUMENTS
-#define LOCK_FREE_ARRAY_TEMPLATE_ARGUMENTS template <typename ValueType>
 
 // LOCK_FREE_ARRAY_TYPE
 #define LOCK_FREE_ARRAY_TYPE LockFreeArray<ValueType>
 
-LOCK_FREE_ARRAY_TEMPLATE_ARGUMENTS
+template <typename ValueType>
 class LockFreeArray {
  public:
-
   LockFreeArray();
   ~LockFreeArray();
 
@@ -47,10 +45,11 @@ class LockFreeArray {
   ValueType Find(const std::size_t &offset) const;
 
   // Get a valid item
-  ValueType FindValid(const std::size_t &offset, const ValueType& invalid_value) const;
+  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);
+  bool Erase(const std::size_t &offset, const ValueType &invalid_value);
 
   // Returns item count in the lock_free_array
   size_t GetSize() const;
@@ -59,20 +58,15 @@ class LockFreeArray {
   bool IsEmpty() const;
 
   // Clear all elements and reset them to default value
-  void Clear(const ValueType& invalid_value);
+  void Clear();
 
   // Exists ?
-  bool Contains(const ValueType& value);
+  bool Contains(const ValueType &value);
 
  private:
-
-  // lock free array type
-  typedef std::array<ValueType, LOCK_FREE_ARRAY_MAX_SIZE> lock_free_array_t;
-
-  std::atomic<std::size_t> lock_free_array_offset {0};
-
   // lock free array
-  std::unique_ptr<lock_free_array_t> lock_free_array;
+  tbb::concurrent_vector<ValueType, tbb::zero_allocator<ValueType>>
+      lock_free_array;
 };
 
 }  // namespace peloton
diff --git a/src/storage/data_table.cpp b/src/storage/data_table.cpp
@@ -1029,7 +1029,7 @@ void DataTable::DropTileGroups() {
   }
 
   // Clear array
-  tile_groups_.Clear(invalid_tile_group_id);
+  tile_groups_.Clear();
 
   tile_group_count_ = 0;
 }
@@ -1100,7 +1100,7 @@ void DataTable::DropIndexWithOid(const oid_t &index_oid) {
 void DataTable::DropIndexes() {
   // TODO: iterate over all indexes, and actually drop them
 
-  indexes_.Clear(nullptr);
+  indexes_.Clear();
 
   indexes_columns_.clear();
 }

Original file line number	Diff line number	Diff line change
`@@ -1029,7 +1029,7 @@ void DataTable::DropTileGroups() {`
`1029`	`1029`	`}`
`1030`	`1030`
`1031`	`1031`	`// Clear array`
`1032`		`- tile_groups_.Clear(invalid_tile_group_id);`
	`1032`	`+ tile_groups_.Clear();`
`1033`	`1033`
`1034`	`1034`	`tile_group_count_ = 0;`
`1035`	`1035`	`}`
`@@ -1100,7 +1100,7 @@ void DataTable::DropIndexWithOid(const oid_t &index_oid) {`
`1100`	`1100`	`void DataTable::DropIndexes() {`
`1101`	`1101`	`// TODO: iterate over all indexes, and actually drop them`
`1102`	`1102`
`1103`		`- indexes_.Clear(nullptr);`
	`1103`	`+ indexes_.Clear();`
`1104`	`1104`
`1105`	`1105`	`indexes_columns_.clear();`
`1106`	`1106`	`}`