From 3a73ffb70151dbc99fa41f300a237f8c29783e0e Mon Sep 17 00:00:00 2001
From: Alex Light <allight@google.com>
Date: Mon, 25 Jan 2021 14:11:05 +0000
Subject: Revert^4 "Partial Load Store Elimination"

This reverts commit 791df7a161ecfa28eb69862a4bc285282463b960.
This unreverts commit fc1ce4e8be0d977e3d41699f5ec746d68f63c024.
This unreverts commit b8686ce4c93eba7192ed7ef89e7ffd9f3aa6cd07.

We incorrectly failed to include PredicatedInstanceFieldGet in a few
conditions, including a DCHECK. This caused tests to fail under the
read-barrier-table-lookup configuration.

Reason for revert: Fixed 2 incorrect checks

Bug: 67037140
Test: ./art/test/testrunner/run_build_test_target.py -j70 art-gtest-read-barrier-table-lookup

Change-Id: I32b01b29fb32077fb5074e7c77a0226bd1fcaab4
---
 compiler/optimizing/execution_subgraph.h | 44 ++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

(limited to 'compiler/optimizing/execution_subgraph.h')

diff --git a/compiler/optimizing/execution_subgraph.h b/compiler/optimizing/execution_subgraph.h
index dac938ed62..7fabbaead1 100644
--- a/compiler/optimizing/execution_subgraph.h
+++ b/compiler/optimizing/execution_subgraph.h
@@ -27,6 +27,7 @@
 #include "base/bit_vector-inl.h"
 #include "base/globals.h"
 #include "base/iteration_range.h"
+#include "base/mutex.h"
 #include "base/scoped_arena_allocator.h"
 #include "base/scoped_arena_containers.h"
 #include "base/stl_util.h"
@@ -35,6 +36,18 @@
 
 namespace art {
 
+// Helper for transforming blocks to block_ids.
+class BlockToBlockIdTransformer {
+ public:
+  BlockToBlockIdTransformer(BlockToBlockIdTransformer&&) = default;
+  BlockToBlockIdTransformer(const BlockToBlockIdTransformer&) = default;
+  BlockToBlockIdTransformer() {}
+
+  inline uint32_t operator()(const HBasicBlock* b) const {
+    return b->GetBlockId();
+  }
+};
+
 // Helper for transforming block ids to blocks.
 class BlockIdToBlockTransformer {
  public:
@@ -61,6 +74,20 @@ class BlockIdToBlockTransformer {
   const HGraph* const graph_;
 };
 
+class BlockIdFilterThunk {
+ public:
+  explicit BlockIdFilterThunk(const BitVector& i) : inner_(i) {}
+  BlockIdFilterThunk(BlockIdFilterThunk&& other) noexcept = default;
+  BlockIdFilterThunk(const BlockIdFilterThunk&) = default;
+
+  bool operator()(const HBasicBlock* b) const {
+    return inner_.IsBitSet(b->GetBlockId());
+  }
+
+ private:
+  const BitVector& inner_;
+};
+
 // A representation of a particular section of the graph. The graph is split
 // into an excluded and included area and is used to track escapes.
 //
@@ -80,10 +107,18 @@ class BlockIdToBlockTransformer {
 // cohort-exit block to reach any cohort-entry block. This means we can use the
 // boundary between the cohort and the rest of the graph to insert
 // materialization blocks for partial LSE.
+//
+// TODO We really should expand this to take into account where the object
+// allocation takes place directly. Currently we always act as though it were
+// allocated in the entry block. This is a massively simplifying assumption but
+// means we can't partially remove objects that are repeatedly allocated in a
+// loop.
 class ExecutionSubgraph : public ArenaObject<kArenaAllocLSA> {
  public:
   using BitVecBlockRange =
       IterationRange<TransformIterator<BitVector::IndexIterator, BlockIdToBlockTransformer>>;
+  using FilteredBitVecBlockRange = IterationRange<
+      FilterIterator<ArenaVector<HBasicBlock*>::const_iterator, BlockIdFilterThunk>>;
 
   // A set of connected blocks which are connected and removed from the
   // ExecutionSubgraph. See above comment for explanation.
@@ -110,6 +145,15 @@ class ExecutionSubgraph : public ArenaObject<kArenaAllocLSA> {
       return BlockIterRange(entry_blocks_);
     }
 
+    FilteredBitVecBlockRange EntryBlocksReversePostOrder() const {
+      return Filter(MakeIterationRange(graph_->GetReversePostOrder()),
+                    BlockIdFilterThunk(entry_blocks_));
+    }
+
+    bool IsEntryBlock(const HBasicBlock* blk) const {
+      return entry_blocks_.IsBitSet(blk->GetBlockId());
+    }
+
     // Blocks that have successors outside of the cohort. The successors of
     // these blocks will need to have PHI's to restore state.
     BitVecBlockRange ExitBlocks() const {
-- 
cgit v1.2.3-59-g8ed1b