Split the allocation path into 'instrumented' and 'uninstrumented'

ones.

The instrumented path is equivalent to the existing allocation path
that checks for three instrumentation mechanisms (the debugger
allocation tracking, the runtime allocation stats collection, and
valgrind) for every allocation. The uinstrumented path does not
perform these checks. We use the uninstrumented path by default and
enable the instrumented path only when any of the three mechanisms is
enabled. The uninstrumented version of Heap::AllocObject() is inlined.

This change improves the Ritz MemAllocTest by ~4% on Nexus 4 and ~3%
on Host/x86.

Bug: 9986565
Change-Id: I3e68dfff6789d77bbdcea98457b694e1b5fcef5f

1 files changed, 14 insertions, 0 deletions

diff --git a/runtime/mirror/array.h b/runtime/mirror/array.h
index db6132d..570dcaa 100644
--- a/runtime/mirror/array.h
+++ b/runtime/mirror/array.h
@@ -27,10 +27,24 @@ class MANAGED Array : public Object {
   // A convenience for code that doesn't know the component size,
   // and doesn't want to have to work it out itself.
   static Array* Alloc(Thread* self, Class* array_class, int32_t component_count)
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+    return AllocInstrumented(self, array_class, component_count);
+  }
+  static Array* AllocUninstrumented(Thread* self, Class* array_class, int32_t component_count)
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  static Array* AllocInstrumented(Thread* self, Class* array_class, int32_t component_count)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   static Array* Alloc(Thread* self, Class* array_class, int32_t component_count,
                       size_t component_size)
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+    return AllocInstrumented(self, array_class, component_count, component_size);
+  }
+  static Array* AllocUninstrumented(Thread* self, Class* array_class, int32_t component_count,
+                                    size_t component_size)
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  static Array* AllocInstrumented(Thread* self, Class* array_class, int32_t component_count,
+                                  size_t component_size)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   static Array* CreateMultiArray(Thread* self, Class* element_class, IntArray* dimensions)