ART: Add allocation callback
Bug: 31684277
Test: m test-art-host
Change-Id: I959f44e23ca5fe55ed678315708895faf0aadb04
diff --git a/runtime/gc/allocation_listener.h b/runtime/gc/allocation_listener.h
new file mode 100644
index 0000000..6fb74d3
--- /dev/null
+++ b/runtime/gc/allocation_listener.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ART_RUNTIME_GC_ALLOCATION_LISTENER_H_
+#define ART_RUNTIME_GC_ALLOCATION_LISTENER_H_
+
+#include <list>
+#include <memory>
+
+#include "base/macros.h"
+#include "base/mutex.h"
+#include "object_callbacks.h"
+#include "gc_root.h"
+
+namespace art {
+
+namespace mirror {
+ class Object;
+}
+
+class Thread;
+
+namespace gc {
+
+class AllocationListener {
+ public:
+ virtual ~AllocationListener() {}
+
+ virtual void ObjectAllocated(Thread* self, mirror::Object** obj, size_t byte_count)
+ REQUIRES_SHARED(Locks::mutator_lock_) = 0;
+};
+
+} // namespace gc
+} // namespace art
+
+#endif // ART_RUNTIME_GC_ALLOCATION_LISTENER_H_
diff --git a/runtime/gc/heap-inl.h b/runtime/gc/heap-inl.h
index 83789cc..00adefb 100644
--- a/runtime/gc/heap-inl.h
+++ b/runtime/gc/heap-inl.h
@@ -19,6 +19,7 @@
#include "heap.h"
+#include "allocation_listener.h"
#include "base/time_utils.h"
#include "gc/accounting/card_table-inl.h"
#include "gc/allocation_record.h"
@@ -184,6 +185,12 @@
DCHECK(allocation_records_ != nullptr);
allocation_records_->RecordAllocation(self, &obj, bytes_allocated);
}
+ AllocationListener* l = alloc_listener_.LoadSequentiallyConsistent();
+ if (l != nullptr) {
+ // Same as above. We assume that a listener that was once stored will never be deleted.
+ // Otherwise we'd have to perform this under a lock.
+ l->ObjectAllocated(self, &obj, bytes_allocated);
+ }
} else {
DCHECK(!IsAllocTrackingEnabled());
}
diff --git a/runtime/gc/heap.cc b/runtime/gc/heap.cc
index 01ad8d0..33f849a 100644
--- a/runtime/gc/heap.cc
+++ b/runtime/gc/heap.cc
@@ -21,6 +21,7 @@
#include <unwind.h> // For GC verification.
#include <vector>
+#include "allocation_listener.h"
#include "art_field-inl.h"
#include "base/allocator.h"
#include "base/arena_allocator.h"
@@ -1287,6 +1288,16 @@
}
}
+ALWAYS_INLINE
+static inline AllocationListener* GetAndOverwriteAllocationListener(
+ Atomic<AllocationListener*>* storage, AllocationListener* new_value) {
+ AllocationListener* old;
+ do {
+ old = storage->LoadSequentiallyConsistent();
+ } while (!storage->CompareExchangeStrongSequentiallyConsistent(old, new_value));
+ return old;
+}
+
Heap::~Heap() {
VLOG(heap) << "Starting ~Heap()";
STLDeleteElements(&garbage_collectors_);
@@ -1307,6 +1318,10 @@
<< " total=" << seen_backtrace_count_.LoadRelaxed() +
unique_backtrace_count_.LoadRelaxed();
}
+ // Delete any still registered allocation listener.
+ AllocationListener* l = GetAndOverwriteAllocationListener(&alloc_listener_, nullptr);
+ delete l;
+
VLOG(heap) << "Finished ~Heap()";
}
@@ -4223,5 +4238,22 @@
}
}
+void Heap::SetAllocationListener(AllocationListener* l) {
+ AllocationListener* old = GetAndOverwriteAllocationListener(&alloc_listener_, l);
+
+ if (old == nullptr) {
+ Runtime::Current()->GetInstrumentation()->InstrumentQuickAllocEntryPoints();
+ }
+}
+
+void Heap::RemoveAllocationListener() {
+ AllocationListener* old = GetAndOverwriteAllocationListener(&alloc_listener_, nullptr);
+
+ if (old != nullptr) {
+ Runtime::Current()->GetInstrumentation()->InstrumentQuickAllocEntryPoints();
+ }
+}
+
+
} // namespace gc
} // namespace art
diff --git a/runtime/gc/heap.h b/runtime/gc/heap.h
index 678edff..5e17a52 100644
--- a/runtime/gc/heap.h
+++ b/runtime/gc/heap.h
@@ -57,6 +57,7 @@
namespace gc {
+class AllocationListener;
class AllocRecordObjectMap;
class ReferenceProcessor;
class TaskProcessor;
@@ -784,6 +785,12 @@
HomogeneousSpaceCompactResult PerformHomogeneousSpaceCompact() REQUIRES(!*gc_complete_lock_);
bool SupportHomogeneousSpaceCompactAndCollectorTransitions() const;
+ // Install an allocation listener.
+ void SetAllocationListener(AllocationListener* l);
+ // Remove an allocation listener. Note: the listener must not be deleted, as for performance
+ // reasons, we assume it stays valid when we read it (so that we don't require a lock).
+ void RemoveAllocationListener();
+
private:
class ConcurrentGCTask;
class CollectorTransitionTask;
@@ -1352,6 +1359,9 @@
// Boot image spaces.
std::vector<space::ImageSpace*> boot_image_spaces_;
+ // An installed allocation listener.
+ Atomic<AllocationListener*> alloc_listener_;
+
friend class CollectorTransitionTask;
friend class collector::GarbageCollector;
friend class collector::MarkCompact;