fix #1386: PerformVectorizedRead optimization (#1434)

* fix #1386 part 2: pass update boolean from scan plan to PerformRead correctly.

* fix #1386 part 1: Perform predicate evaluation before recording reads with the transaction manager.

* Rename new function RecordReads to PerformReads per PR feedback.

Author: mbutrovich

src/codegen/operator/table_scan_translator.cpp

@@ -105,6 +105,8 @@ class TableScanTranslator::ScanConsumer : public codegen::ScanCallback {
                               llvm::Value *tid_end,
                               Vector &selection_vector) const;
 
+  void PerformReads(CodeGen &codegen, Vector &selection_vector) const;
+
   // Filter all the rows whose TIDs are in the range [tid_start, tid_end] and
   // store their TIDs in the output TID selection vector
   void FilterRowsByPredicate(CodeGen &codegen,
@@ -290,14 +292,17 @@ void TableScanTranslator::ScanConsumer::ProcessTuples(
                           selection_vector_);
   }
 
-  // 3. Setup the (filtered) row batch and setup attribute accessors
+  // 3. Record reads for all of the tuple that are visible and pass predicate
+  PerformReads(codegen, selection_vector_);
+
+  // 4. Setup the (filtered) row batch and setup attribute accessors
   RowBatch batch{ctx_.GetCompilationContext(), tile_group_id_, tid_start,
                  tid_end, selection_vector_, true};
 
   std::vector<TableScanTranslator::AttributeAccess> attribute_accesses;
   SetupRowBatch(batch, tile_group_access, attribute_accesses);
 
-  // 4. Push the batch into the pipeline
+  // 5. Push the batch into the pipeline
   ctx_.Consume(batch);
 }
 
@@ -333,9 +338,9 @@ void TableScanTranslator::ScanConsumer::FilterRowsByVisibility(
   llvm::Value *txn = ec.GetTransactionPtr(ctx_.GetCompilationContext());
   llvm::Value *raw_sel_vec = selection_vector.GetVectorPtr();
 
-  // Invoke TransactionRuntime::PerformRead(...)
+  // Invoke TransactionRuntime::PerformVisibilityCheck(...)
   llvm::Value *out_idx =
-      codegen.Call(TransactionRuntimeProxy::PerformVectorizedRead,
+      codegen.Call(TransactionRuntimeProxy::PerformVisibilityCheck,
                    {txn, tile_group_ptr_, tid_start, tid_end, raw_sel_vec});
   selection_vector.SetNumElements(out_idx);
 }
@@ -379,5 +384,21 @@ void TableScanTranslator::ScanConsumer::FilterRowsByPredicate(
   });
 }
 
+void TableScanTranslator::ScanConsumer::PerformReads(
+    CodeGen &codegen, Vector &selection_vector) const {
+  ExecutionConsumer &ec = ctx_.GetCompilationContext().GetExecutionConsumer();
+  llvm::Value *txn = ec.GetTransactionPtr(ctx_.GetCompilationContext());
+  llvm::Value *raw_sel_vec = selection_vector.GetVectorPtr();
+
+  llvm::Value *is_for_update = codegen.ConstBool(plan_.IsForUpdate());
+  llvm::Value *end_idx = selection_vector.GetNumElements();
+
+  // Invoke TransactionRuntime::PerformVectorizedRead(...)
+  llvm::Value *out_idx =
+      codegen.Call(TransactionRuntimeProxy::PerformVectorizedRead,
+                   {txn, tile_group_ptr_, raw_sel_vec, end_idx, is_for_update});
+  selection_vector.SetNumElements(out_idx);
+}
+
 }  // namespace codegen
 }  // namespace peloton

src/codegen/proxy/transaction_runtime_proxy.cpp

@@ -22,6 +22,7 @@ namespace peloton {
 namespace codegen {
 
 DEFINE_METHOD(peloton::codegen, TransactionRuntime, PerformVectorizedRead);
+DEFINE_METHOD(peloton::codegen, TransactionRuntime, PerformVisibilityCheck);
 
 }  // namespace codegen
 }  // namespace peloton

src/codegen/transaction_runtime.cpp

@@ -22,10 +22,7 @@
 namespace peloton {
 namespace codegen {
 
-// Perform a read operation for all tuples in the tile group in the given range
-// TODO: Right now, we split this check into two loops: a visibility check and
-//       the actual reading. Can this be merged?
-uint32_t TransactionRuntime::PerformVectorizedRead(
+uint32_t TransactionRuntime::PerformVisibilityCheck(
     concurrency::TransactionContext &txn, storage::TileGroup &tile_group,
     uint32_t tid_start, uint32_t tid_end, uint32_t *selection_vector) {
   // Get the transaction manager
@@ -45,24 +42,34 @@ uint32_t TransactionRuntime::PerformVectorizedRead(
     selection_vector[out_idx] = i;
     out_idx += (visibility == VisibilityType::OK);
   }
+  return out_idx;
+}
+
+uint32_t TransactionRuntime::PerformVectorizedRead(
+    concurrency::TransactionContext &txn, storage::TileGroup &tile_group,
+    uint32_t *selection_vector, uint32_t end_idx, bool is_for_update) {
+  // Get the transaction manager
+  auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance();
+
+  // Get the tile group header
+  auto tile_group_header = tile_group.GetHeader();
 
   uint32_t tile_group_idx = tile_group.GetTileGroupId();
 
   // Perform a read operation for every visible tuple we found
-  uint32_t end_idx = out_idx;
-  out_idx = 0;
+  uint32_t out_idx = 0;
   for (uint32_t idx = 0; idx < end_idx; idx++) {
     // Construct the item location
     ItemPointer location{tile_group_idx, selection_vector[idx]};
 
     // Perform the read
-    bool can_read = txn_manager.PerformRead(&txn, location, tile_group_header, false);
+    bool can_read = txn_manager.PerformRead(&txn, location, tile_group_header,
+                                            is_for_update);
 
     // Update the selection vector and output position
     selection_vector[out_idx] = selection_vector[idx];
     out_idx += static_cast<uint32_t>(can_read);
   }
-
   return out_idx;
 }
 

src/include/codegen/proxy/transaction_runtime_proxy.h

@@ -18,9 +18,8 @@ namespace peloton {
 namespace codegen {
 
 PROXY(TransactionRuntime) {
-  /// We only need to proxy PerformVectorizedRead()
-  /// in codegen::TransactionRuntime.
   DECLARE_METHOD(PerformVectorizedRead);
+  DECLARE_METHOD(PerformVisibilityCheck);
 };
 
 }  // namespace codegen

src/include/codegen/transaction_runtime.h

@@ -42,12 +42,19 @@ namespace codegen {
 //===----------------------------------------------------------------------===//
 class TransactionRuntime {
  public:
+  // Perform a visibility check for all tuples in the given tile group with IDs
+  // in the range [tid_start, tid_end) in the context of the given transaction
+  static uint32_t PerformVisibilityCheck(concurrency::TransactionContext &txn,
+                                         storage::TileGroup &tile_group,
+                                         uint32_t tid_start, uint32_t tid_end,
+                                         uint32_t *selection_vector);
+
   // Perform a read operation for all tuples in the given tile group with IDs
   // in the range [tid_start, tid_end) in the context of the given transaction
   static uint32_t PerformVectorizedRead(concurrency::TransactionContext &txn,
                                         storage::TileGroup &tile_group,
-                                        uint32_t tid_start, uint32_t tid_end,
-                                        uint32_t *selection_vector);
+                                        uint32_t *selection_vector,
+                                        uint32_t end_idx, bool is_for_update);
   // Check Ownership
   static bool IsOwner(concurrency::TransactionContext &txn,
                       storage::TileGroupHeader *tile_group_header,