Merge branch 'master' into catalog_update

Author: apavlo

src/codegen/code_context.cpp

@@ -224,7 +224,7 @@ CodeContext::CodeContext()
   int64_type_ = llvm::Type::getInt64Ty(*context_);
   double_type_ = llvm::Type::getDoubleTy(*context_);
   void_type_ = llvm::Type::getVoidTy(*context_);
-  void_ptr_type_ = llvm::Type::getVoidTy(*context_)->getPointerTo();
+  void_ptr_type_ = llvm::Type::getInt8PtrTy(*context_);
   char_ptr_type_ = llvm::Type::getInt8PtrTy(*context_);
 }
 

src/codegen/function_builder.cpp

@@ -131,10 +131,12 @@ FunctionBuilder::FunctionBuilder(
           cc,
           ConstructFunction(cc, name, FunctionDeclaration::Visibility::External,
                             ret_type, args)) {}
-                            
+
 FunctionBuilder::~FunctionBuilder() {
   if (!finished_) {
-    throw Exception{"Missing call to FunctionBuilder::ReturnAndFinish()"};
+    LOG_ERROR(
+        "Missing call to FunctionBuilder::ReturnAndFinish() for function '%s'",
+        func_->getName().data());
   }
 }
 

src/codegen/lang/vectorized_loop.cpp

@@ -33,7 +33,9 @@ VectorizedLoop::VectorizedLoop(CodeGen &codegen, llvm::Value *num_elements,
 }
 
 VectorizedLoop::~VectorizedLoop() {
-  PELOTON_ASSERT(ended_ && "You didn't call lang::VectorizedLoop::LoopEnd()!");
+  if (!ended_) {
+    LOG_ERROR("You didn't call lang::VectorizedLoop::LoopEnd()!");
+  }
 }
 
 VectorizedLoop::Range VectorizedLoop::GetCurrentRange() const {

src/codegen/operator/table_scan_translator.cpp

@@ -216,7 +216,7 @@ void TableScanTranslator::ProduceParallel() const {
                                                   codegen.Int64Type()};
 
   // Parallel production
-  auto producer = [this, &codegen, &table](
+  auto producer = [this, &codegen](
       ConsumerContext &ctx, const std::vector<llvm::Value *> params) {
     PELOTON_ASSERT(params.size() == 2);
     llvm::Value *tilegroup_start = params[0];

src/codegen/transaction_runtime.cpp

@@ -56,7 +56,7 @@ uint32_t TransactionRuntime::PerformVectorizedRead(
     ItemPointer location{tile_group_idx, selection_vector[idx]};
 
     // Perform the read
-    bool can_read = txn_manager.PerformRead(&txn, location);
+    bool can_read = txn_manager.PerformRead(&txn, location, tile_group_header, false);
 
     // Update the selection vector and output position
     selection_vector[out_idx] = selection_vector[idx];

src/codegen/util/sorter.cpp

@@ -268,7 +268,7 @@ void Sorter::SortParallel(
           return !(cmp_func_(*l.first, *r.first) < 0);
         };
     for (auto &work : merge_work) {
-      work_pool.SubmitTask([&work, &latch, &heap_cmp, &comp] {
+      work_pool.SubmitTask([&work, &latch, &heap_cmp] {
         std::priority_queue<MergeWork::InputRange,
                             std::vector<MergeWork::InputRange>,
                             decltype(heap_cmp)> heap(heap_cmp,

src/concurrency/timestamp_ordering_transaction_manager.cpp

@@ -170,9 +170,10 @@ void TimestampOrderingTransactionManager::YieldOwnership(
   tile_group_header->SetTransactionId(tuple_id, INITIAL_TXN_ID);
 }
 
-bool TimestampOrderingTransactionManager::PerformRead(
-    TransactionContext *const current_txn, const ItemPointer &read_location,
-    bool acquire_ownership) {
+bool TimestampOrderingTransactionManager::PerformRead(TransactionContext *const current_txn,
+                                                      const ItemPointer &read_location,
+                                                      storage::TileGroupHeader *tile_group_header,
+                                                      bool acquire_ownership) {
   ItemPointer location = read_location;
 
   //////////////////////////////////////////////////////////
@@ -189,24 +190,18 @@ bool TimestampOrderingTransactionManager::PerformRead(
 
   // TODO: what if we want to read a version that we write?
   else if (current_txn->GetIsolationLevel() == IsolationLevelType::SNAPSHOT) {
-    oid_t tile_group_id = location.block;
     oid_t tuple_id = location.offset;
 
     LOG_TRACE("PerformRead (%u, %u)\n", location.block, location.offset);
-    auto &manager = catalog::Manager::GetInstance();
-    auto tile_group_header = manager.GetTileGroup(tile_group_id)->GetHeader();
 
     // Check if it's select for update before we check the ownership
     // and modify the last reader cid
     if (acquire_ownership == true) {
       // get the latest version of this tuple.
       location = *(tile_group_header->GetIndirection(location.offset));
 
-      tile_group_id = location.block;
       tuple_id = location.offset;
 
-      tile_group_header = manager.GetTileGroup(tile_group_id)->GetHeader();
-
       if (IsOwner(current_txn, tile_group_header, tuple_id) == false) {
         // Acquire ownership if we haven't
         if (IsOwnable(current_txn, tile_group_header, tuple_id) == false) {
@@ -225,27 +220,11 @@ bool TimestampOrderingTransactionManager::PerformRead(
 
       // if we have already owned the version.
       PELOTON_ASSERT(IsOwner(current_txn, tile_group_header, tuple_id) == true);
-
-      // Increment table read op stats
-      if (static_cast<StatsType>(settings::SettingsManager::GetInt(
-              settings::SettingId::stats_mode)) != StatsType::INVALID) {
-        stats::BackendStatsContext::GetInstance()->IncrementTableReads(
-            location.block);
-      }
-
       return true;
 
     } else {
       // if it's not select for update, then update read set and return true.
-
       current_txn->RecordRead(location);
-
-      // Increment table read op stats
-      if (static_cast<StatsType>(settings::SettingsManager::GetInt(
-              settings::SettingId::stats_mode)) != StatsType::INVALID) {
-        stats::BackendStatsContext::GetInstance()->IncrementTableReads(
-            location.block);
-      }
       return true;
     }
 
@@ -256,12 +235,9 @@ bool TimestampOrderingTransactionManager::PerformRead(
   //////////////////////////////////////////////////////////
   else if (current_txn->GetIsolationLevel() ==
            IsolationLevelType::READ_COMMITTED) {
-    oid_t tile_group_id = location.block;
     oid_t tuple_id = location.offset;
 
     LOG_TRACE("PerformRead (%u, %u)\n", location.block, location.offset);
-    auto &manager = catalog::Manager::GetInstance();
-    auto tile_group_header = manager.GetTileGroup(tile_group_id)->GetHeader();
 
     // Check if it's select for update before we check the ownership.
     if (acquire_ownership == true) {
@@ -283,26 +259,13 @@ bool TimestampOrderingTransactionManager::PerformRead(
       }
       // if we have already owned the version.
       PELOTON_ASSERT(IsOwner(current_txn, tile_group_header, tuple_id) == true);
-      // Increment table read op stats
-      if (static_cast<StatsType>(settings::SettingsManager::GetInt(
-              settings::SettingId::stats_mode)) != StatsType::INVALID) {
-        stats::BackendStatsContext::GetInstance()->IncrementTableReads(
-            location.block);
-      }
       return true;
 
     } else {
       // a transaction can never read an uncommitted version.
       if (IsOwner(current_txn, tile_group_header, tuple_id) == false) {
         if (IsOwned(current_txn, tile_group_header, tuple_id) == false) {
           current_txn->RecordRead(location);
-
-          // Increment table read op stats
-          if (static_cast<StatsType>(settings::SettingsManager::GetInt(
-                  settings::SettingId::stats_mode)) != StatsType::INVALID) {
-            stats::BackendStatsContext::GetInstance()->IncrementTableReads(
-                location.block);
-          }
           return true;
 
         } else {
@@ -315,14 +278,6 @@ bool TimestampOrderingTransactionManager::PerformRead(
       } else {
         // this version must already be in the read/write set.
         // so no need to update read set.
-        // current_txn->RecordRead(location);
-
-        // Increment table read op stats
-        if (static_cast<StatsType>(settings::SettingsManager::GetInt(
-                settings::SettingId::stats_mode)) != StatsType::INVALID) {
-          stats::BackendStatsContext::GetInstance()->IncrementTableReads(
-              location.block);
-        }
         return true;
       }
     }
@@ -338,13 +293,9 @@ bool TimestampOrderingTransactionManager::PerformRead(
                    current_txn->GetIsolationLevel() ==
                        IsolationLevelType::REPEATABLE_READS);
 
-    oid_t tile_group_id = location.block;
     oid_t tuple_id = location.offset;
 
     LOG_TRACE("PerformRead (%u, %u)\n", location.block, location.offset);
-    auto &manager = catalog::Manager::GetInstance();
-    auto tile_group_header = manager.GetTileGroup(tile_group_id)->GetHeader();
-
     // Check if it's select for update before we check the ownership
     // and modify the last reader cid.
     if (acquire_ownership == true) {
@@ -379,12 +330,6 @@ bool TimestampOrderingTransactionManager::PerformRead(
       PELOTON_ASSERT(GetLastReaderCommitId(tile_group_header, tuple_id) ==
                          current_txn->GetCommitId() ||
                      GetLastReaderCommitId(tile_group_header, tuple_id) == 0);
-      // Increment table read op stats
-      if (static_cast<StatsType>(settings::SettingsManager::GetInt(
-              settings::SettingId::stats_mode)) != StatsType::INVALID) {
-        stats::BackendStatsContext::GetInstance()->IncrementTableReads(
-            location.block);
-      }
       return true;
 
     } else {
@@ -395,13 +340,6 @@ bool TimestampOrderingTransactionManager::PerformRead(
                                   current_txn->GetCommitId(), false) == true) {
           // update read set.
           current_txn->RecordRead(location);
-
-          // Increment table read op stats
-          if (static_cast<StatsType>(settings::SettingsManager::GetInt(
-                  settings::SettingId::stats_mode)) != StatsType::INVALID) {
-            stats::BackendStatsContext::GetInstance()->IncrementTableReads(
-                location.block);
-          }
           return true;
         } else {
           // if the tuple has been owned by some concurrent transactions,
@@ -419,14 +357,6 @@ bool TimestampOrderingTransactionManager::PerformRead(
 
         // this version must already be in the read/write set.
         // so no need to update read set.
-        // current_txn->RecordRead(location);
-
-        // Increment table read op stats
-        if (static_cast<StatsType>(settings::SettingsManager::GetInt(
-                settings::SettingId::stats_mode)) != StatsType::INVALID) {
-          stats::BackendStatsContext::GetInstance()->IncrementTableReads(
-              location.block);
-        }
         return true;
       }
     }
@@ -464,13 +394,6 @@ void TimestampOrderingTransactionManager::PerformInsert(
 
   // Write down the head pointer's address in tile group header
   tile_group_header->SetIndirection(tuple_id, index_entry_ptr);
-
-  // Increment table insert op stats
-  if (static_cast<StatsType>(settings::SettingsManager::GetInt(
-          settings::SettingId::stats_mode)) != StatsType::INVALID) {
-    stats::BackendStatsContext::GetInstance()->IncrementTableInserts(
-        location.block);
-  }
 }
 
 void TimestampOrderingTransactionManager::PerformUpdate(
@@ -548,13 +471,6 @@ void TimestampOrderingTransactionManager::PerformUpdate(
 
   // Add the old tuple into the update set
   current_txn->RecordUpdate(old_location);
-
-  // Increment table update op stats
-  if (static_cast<StatsType>(settings::SettingsManager::GetInt(
-          settings::SettingId::stats_mode)) != StatsType::INVALID) {
-    stats::BackendStatsContext::GetInstance()->IncrementTableUpdates(
-        new_location.block);
-  }
 }
 
 void TimestampOrderingTransactionManager::PerformUpdate(
@@ -581,13 +497,6 @@ void TimestampOrderingTransactionManager::PerformUpdate(
   // transaction
   // is updating a version that is installed by itself.
   // in this case, nothing needs to be performed.
-
-  // Increment table update op stats
-  if (static_cast<StatsType>(settings::SettingsManager::GetInt(
-          settings::SettingId::stats_mode)) != StatsType::INVALID) {
-    stats::BackendStatsContext::GetInstance()->IncrementTableUpdates(
-        location.block);
-  }
 }
 
 void TimestampOrderingTransactionManager::PerformDelete(
@@ -669,13 +578,6 @@ void TimestampOrderingTransactionManager::PerformDelete(
   }
 
   current_txn->RecordDelete(old_location);
-
-  // Increment table delete op stats
-  if (static_cast<StatsType>(settings::SettingsManager::GetInt(
-          settings::SettingId::stats_mode)) != StatsType::INVALID) {
-    stats::BackendStatsContext::GetInstance()->IncrementTableDeletes(
-        old_location.block);
-  }
 }
 
 void TimestampOrderingTransactionManager::PerformDelete(
@@ -703,13 +605,6 @@ void TimestampOrderingTransactionManager::PerformDelete(
     // if this version is newly inserted.
     current_txn->RecordDelete(location);
   }
-
-  // Increment table delete op stats
-  if (static_cast<StatsType>(settings::SettingsManager::GetInt(
-          settings::SettingId::stats_mode)) != StatsType::INVALID) {
-    stats::BackendStatsContext::GetInstance()->IncrementTableDeletes(
-        location.block);
-  }
 }
 
 ResultType TimestampOrderingTransactionManager::CommitTransaction(
@@ -752,20 +647,6 @@ ResultType TimestampOrderingTransactionManager::CommitTransaction(
     gc_object_set->emplace_back(database_oid, table_oid, index_oid);
   }
 
-  oid_t database_id = 0;
-  if (static_cast<StatsType>(settings::SettingsManager::GetInt(
-          settings::SettingId::stats_mode)) != StatsType::INVALID) {
-    for (const auto &tuple_entry : rw_set) {
-      // Call the GetConstIterator() function to explicitly lock the cuckoohash
-      // and initilaize the iterator
-      const auto tile_group_id = tuple_entry.first.block;
-      database_id = manager.GetTileGroup(tile_group_id)->GetDatabaseId();
-      if (database_id != CATALOG_DATABASE_OID) {
-        break;
-      }
-    }
-  }
-
   // install everything.
   // 1. install a new version for update operations;
   // 2. install an empty version for delete operations;
@@ -896,13 +777,6 @@ ResultType TimestampOrderingTransactionManager::CommitTransaction(
 
   EndTransaction(current_txn);
 
-  // Increment # txns committed metric
-  if (static_cast<StatsType>(settings::SettingsManager::GetInt(
-          settings::SettingId::stats_mode)) != StatsType::INVALID) {
-    stats::BackendStatsContext::GetInstance()->IncrementTxnCommitted(
-        database_id);
-  }
-
   return result;
 }
 
@@ -930,20 +804,6 @@ ResultType TimestampOrderingTransactionManager::AbortTransaction(
     gc_object_set->emplace_back(database_oid, table_oid, index_oid);
   }
 
-  oid_t database_id = 0;
-  if (static_cast<StatsType>(settings::SettingsManager::GetInt(
-          settings::SettingId::stats_mode)) != StatsType::INVALID) {
-    for (const auto &tuple_entry : rw_set) {
-      // Call the GetConstIterator() function to explicitly lock the cuckoohash
-      // and initilaize the iterator
-      const auto tile_group_id = tuple_entry.first.block;
-      database_id = manager.GetTileGroup(tile_group_id)->GetDatabaseId();
-      if (database_id != CATALOG_DATABASE_OID) {
-        break;
-      }
-    }
-  }
-
   // Iterate through each item pointer in the read write set
   // TODO (Pooja): This might be inefficient since we will have to get the
   // tile_group_header for each entry. Check if this needs to be consolidated
@@ -1085,12 +945,6 @@ ResultType TimestampOrderingTransactionManager::AbortTransaction(
   current_txn->SetResult(ResultType::ABORTED);
   EndTransaction(current_txn);
 
-  // Increment # txns aborted metric
-  if (static_cast<StatsType>(settings::SettingsManager::GetInt(
-          settings::SettingId::stats_mode)) != StatsType::INVALID) {
-    stats::BackendStatsContext::GetInstance()->IncrementTxnAborted(database_id);
-  }
-
   return ResultType::ABORTED;
 }