commit a669df3cb61b88c9dadd161962a9b4ecb7ce8a03
author Santiago Aboy Solanes <solanes@google.com> Mon Oct 31 11:27:24 2022 +0000
committer Santiago Aboy Solanes <solanes@google.com> Wed Nov 02 08:06:51 2022 +0000
tree f3c8069a3b07f267ef29bb81eb9c82a2b1c6de3c
parent 8f8a8a45835c4306a446a9bbb6cfb0e833924b0b

Don't inline methods whose basic blocks end with a throw

If the basic block will end up throwing, it is commonly not in the
critical path. If we throw, we incur in a performance cost anyway
so we can skip inlining those methods. Additionally, methods
before a throw are sometimes construct information which is
something we are not interested in inlining.

Note that this CL doesn't stop inlining for methods that eventually
always end with a throw. See the 2243- test for an example
(testEndsWithThrowButNotDirectly). We could perform a more detailed
analysis but that analysis will increase compile time so it is left
as a further optimization if needed.

Locally in a Pixel 5 with AOSP, code size improved:
 * AGSA: 15.3 MB (~4.6%)
 * System Server: 1.9 MB (~3.74%)
 * SysemUIGoogle: 0.88MB (~3.05%)

Bug: 252884414
Bug: 256052088
Bug: 255984757
Bug: 227283224
Test: art/test/testrunner/testrunner.py --host --64 --optimizing -b
Change-Id: Id0b7894c0d63591e3b354520a47252bf8b91f44f

compiler/optimizing/inliner.cc

diff --git a/compiler/optimizing/inliner.cc b/compiler/optimizing/inliner.cc
index 0dc4256..fe398b0 100644
--- a/compiler/optimizing/inliner.cc
+++ b/compiler/optimizing/inliner.cc
@@ -1469,9 +1469,9 @@
   return true;
 }
 
-// Returns whether our resource limits allow inlining this method.
-bool HInliner::IsInliningBudgetAvailable(ArtMethod* method,
-                                         const CodeItemDataAccessor& accessor) const {
+bool HInliner::IsInliningEncouraged(const HInvoke* invoke_instruction,
+                                    ArtMethod* method,
+                                    const CodeItemDataAccessor& accessor) const {
   if (CountRecursiveCallsOf(method) > kMaximumNumberOfRecursiveCalls) {
     LOG_FAIL(stats_, MethodCompilationStat::kNotInlinedRecursiveBudget)
         << "Method "
@@ -1491,6 +1491,13 @@
     return false;
   }
 
+  if (invoke_instruction->GetBlock()->GetLastInstruction()->IsThrow()) {
+    LOG_FAIL(stats_, MethodCompilationStat::kNotInlinedEndsWithThrow)
+        << "Method " << method->PrettyMethod()
+        << " is not inlined because its block ends with a throw";
+    return false;
+  }
+
   return true;
 }
 
@@ -1557,7 +1564,7 @@
     return false;
   }
 
-  if (!IsInliningBudgetAvailable(method, accessor)) {
+  if (!IsInliningEncouraged(invoke_instruction, method, accessor)) {
     return false;
   }
 

compiler/optimizing/inliner.h

diff --git a/compiler/optimizing/inliner.h b/compiler/optimizing/inliner.h
index 581f524..0c36a8a 100644
--- a/compiler/optimizing/inliner.h
+++ b/compiler/optimizing/inliner.h
@@ -133,12 +133,14 @@
                            const CodeItemDataAccessor& accessor) const
     REQUIRES_SHARED(Locks::mutator_lock_);
 
-  // Returns whether the inlining budget allows inlining method.
+  // Returns whether inlining is encouraged.
   //
   // For example, this checks whether the function has grown too large and
   // inlining should be prevented.
-  bool IsInliningBudgetAvailable(art::ArtMethod* method, const CodeItemDataAccessor& accessor) const
-    REQUIRES_SHARED(Locks::mutator_lock_);
+  bool IsInliningEncouraged(const HInvoke* invoke_instruction,
+                            art::ArtMethod* method,
+                            const CodeItemDataAccessor& accessor) const
+      REQUIRES_SHARED(Locks::mutator_lock_);
 
   // Inspects the body of a method (callee_graph) and returns whether it can be
   // inlined.

compiler/optimizing/optimizing_compiler_stats.h

diff --git a/compiler/optimizing/optimizing_compiler_stats.h b/compiler/optimizing/optimizing_compiler_stats.h
index 24a28e3..96dfdac 100644
--- a/compiler/optimizing/optimizing_compiler_stats.h
+++ b/compiler/optimizing/optimizing_compiler_stats.h
@@ -102,6 +102,7 @@
   kNotInlinedNotCompilable,
   kNotInlinedNotVerified,
   kNotInlinedCodeItem,
+  kNotInlinedEndsWithThrow,
   kNotInlinedWont,
   kNotInlinedRecursiveBudget,
   kNotInlinedPolymorphicRecursiveBudget,