summaryrefslogtreecommitdiff
path: root/openjdkjvmti/alloc_manager.h
diff options
context:
space:
mode:
author Alex Light <allight@google.com> 2019-11-19 01:12:25 +0000
committer Treehugger Robot <treehugger-gerrit@google.com> 2019-11-19 17:15:48 +0000
commit986914bfd60c1cace9726e9029598d72cbf279e1 (patch)
tree556e5549254e4d5b280a63451fa8673ab36fba7b /openjdkjvmti/alloc_manager.h
parent5697faba0e910374da285f5f848d2aaf7ee6ffec (diff)
Revert^4 "Initial support for adding virtuals with structural redefinition"
This reverts commit 2f8c1ac61b0c611d67badea70261c851ed19b82a. If there were pending tasks to jit compile a method which is made obsolete the JIT would CHECK fail, since the newly obsolete method is marked DontCompile. This didn't happen with non-structural redefinition since in that case the 'valid' ArtMethod always remains the same. To fix this we just have the JitTask check if the method it's compiling is compilable and fail if it's not. Reason for revert: Fixed JIT check failure. Test: ./test.py --host Bug: 134162467 Bug: 144168550 Bug: 144729319 Change-Id: Ib867b2de13bb4c2978b4538a5851c647caf0e1cc
Diffstat (limited to 'openjdkjvmti/alloc_manager.h')
-rw-r--r--openjdkjvmti/alloc_manager.h114
1 files changed, 114 insertions, 0 deletions
diff --git a/openjdkjvmti/alloc_manager.h b/openjdkjvmti/alloc_manager.h
new file mode 100644
index 0000000000..c89d9a633a
--- /dev/null
+++ b/openjdkjvmti/alloc_manager.h
@@ -0,0 +1,114 @@
+/* Copyright (C) 2019 The Android Open Source Project
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This file implements interfaces from the file jvmti.h. This implementation
+ * is licensed under the same terms as the file jvmti.h. The
+ * copyright and license information for the file jvmti.h follows.
+ *
+ * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#ifndef ART_OPENJDKJVMTI_ALLOC_MANAGER_H_
+#define ART_OPENJDKJVMTI_ALLOC_MANAGER_H_
+
+#include <jvmti.h>
+
+#include <atomic>
+
+#include "base/locks.h"
+#include "base/mutex.h"
+#include "gc/allocation_listener.h"
+
+namespace art {
+template <typename T> class MutableHandle;
+template <typename T> class ObjPtr;
+class Thread;
+namespace mirror {
+class Class;
+class Object;
+} // namespace mirror
+} // namespace art
+
+namespace openjdkjvmti {
+
+class AllocationManager;
+
+class JvmtiAllocationListener : public art::gc::AllocationListener {
+ public:
+ explicit JvmtiAllocationListener(AllocationManager* manager) : manager_(manager) {}
+ void ObjectAllocated(art::Thread* self,
+ art::ObjPtr<art::mirror::Object>* obj,
+ size_t cnt) override REQUIRES_SHARED(art::Locks::mutator_lock_);
+ bool HasPreAlloc() const override REQUIRES_SHARED(art::Locks::mutator_lock_);
+ void PreObjectAllocated(art::Thread* self,
+ art::MutableHandle<art::mirror::Class> type,
+ size_t* byte_count) override REQUIRES_SHARED(art::Locks::mutator_lock_);
+
+ private:
+ AllocationManager* manager_;
+};
+
+class AllocationManager {
+ public:
+ class AllocationCallback {
+ public:
+ virtual ~AllocationCallback() {}
+ virtual void ObjectAllocated(art::Thread* self,
+ art::ObjPtr<art::mirror::Object>* obj,
+ size_t byte_count) REQUIRES_SHARED(art::Locks::mutator_lock_) = 0;
+ };
+
+ AllocationManager();
+
+ void SetAllocListener(AllocationCallback* callback);
+ void RemoveAllocListener();
+
+ static AllocationManager* Get();
+
+ void PauseAllocations(art::Thread* self) REQUIRES_SHARED(art::Locks::mutator_lock_);
+ void ResumeAllocations(art::Thread* self) REQUIRES_SHARED(art::Locks::mutator_lock_);
+
+ void EnableAllocationCallback(art::Thread* self) REQUIRES_SHARED(art::Locks::mutator_lock_);
+ void DisableAllocationCallback(art::Thread* self) REQUIRES_SHARED(art::Locks::mutator_lock_);
+
+ private:
+ template<typename T>
+ void PauseForAllocation(art::Thread* self, T msg) REQUIRES_SHARED(art::Locks::mutator_lock_);
+ void IncrListenerInstall(art::Thread* self) REQUIRES_SHARED(art::Locks::mutator_lock_);
+ void DecrListenerInstall(art::Thread* self) REQUIRES_SHARED(art::Locks::mutator_lock_);
+
+ AllocationCallback* callback_ = nullptr;
+ uint32_t listener_refcount_ GUARDED_BY(alloc_listener_mutex_) = 0;
+ std::atomic<art::Thread*> allocations_paused_thread_ = nullptr;
+ std::atomic<bool> callback_enabled_ = false;
+ std::unique_ptr<JvmtiAllocationListener> alloc_listener_ = nullptr;
+ art::Mutex alloc_listener_mutex_ ACQUIRED_AFTER(art::Locks::user_code_suspension_lock_);
+ art::ConditionVariable alloc_pause_cv_;
+
+ friend class JvmtiAllocationListener;
+};
+
+} // namespace openjdkjvmti
+
+#endif // ART_OPENJDKJVMTI_ALLOC_MANAGER_H_