219 lines
9.6 KiB
C++
219 lines
9.6 KiB
C++
|
|
/* 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.
|
|
*/
|
|
|
|
#include "alloc_manager.h"
|
|
|
|
#include <atomic>
|
|
#include <sstream>
|
|
|
|
#include "base/logging.h"
|
|
#include "gc/allocation_listener.h"
|
|
#include "gc/heap.h"
|
|
#include "handle.h"
|
|
#include "mirror/class-inl.h"
|
|
#include "runtime.h"
|
|
#include "runtime_globals.h"
|
|
#include "scoped_thread_state_change-inl.h"
|
|
#include "scoped_thread_state_change.h"
|
|
#include "thread-current-inl.h"
|
|
#include "thread_list.h"
|
|
#include "thread_pool.h"
|
|
|
|
namespace openjdkjvmti {
|
|
|
|
template<typename T>
|
|
void AllocationManager::PauseForAllocation(art::Thread* self, T msg) {
|
|
// The suspension can pause us for arbitrary times. We need to do it to sleep unfortunately. So we
|
|
// do test, suspend, test again, sleep, repeat.
|
|
std::string cause;
|
|
const bool is_logging = VLOG_IS_ON(plugin);
|
|
while (true) {
|
|
// We always return when there is no pause and we are runnable.
|
|
art::Thread* pausing_thread = allocations_paused_thread_.load(std::memory_order_seq_cst);
|
|
if (LIKELY(pausing_thread == nullptr || pausing_thread == self)) {
|
|
return;
|
|
}
|
|
if (UNLIKELY(is_logging && cause.empty())) {
|
|
cause = msg();
|
|
}
|
|
art::ScopedThreadSuspension sts(self, art::ThreadState::kSuspended);
|
|
art::MutexLock mu(self, alloc_listener_mutex_);
|
|
pausing_thread = allocations_paused_thread_.load(std::memory_order_seq_cst);
|
|
CHECK_NE(pausing_thread, self) << "We should always be setting pausing_thread = self!"
|
|
<< " How did this happen? " << *self;
|
|
if (pausing_thread != nullptr) {
|
|
VLOG(plugin) << "Suspending " << *self << " due to " << cause << ". Allocation pause "
|
|
<< "initiated by " << *pausing_thread;
|
|
alloc_pause_cv_.Wait(self);
|
|
}
|
|
}
|
|
}
|
|
|
|
extern AllocationManager* gAllocManager;
|
|
AllocationManager* AllocationManager::Get() {
|
|
return gAllocManager;
|
|
}
|
|
|
|
void JvmtiAllocationListener::ObjectAllocated(art::Thread* self,
|
|
art::ObjPtr<art::mirror::Object>* obj,
|
|
size_t cnt) {
|
|
auto cb = manager_->callback_;
|
|
if (cb != nullptr && manager_->callback_enabled_.load(std::memory_order_seq_cst)) {
|
|
cb->ObjectAllocated(self, obj, cnt);
|
|
}
|
|
}
|
|
|
|
bool JvmtiAllocationListener::HasPreAlloc() const {
|
|
return manager_->allocations_paused_ever_.load(std::memory_order_seq_cst);
|
|
}
|
|
|
|
void JvmtiAllocationListener::PreObjectAllocated(art::Thread* self,
|
|
art::MutableHandle<art::mirror::Class> type,
|
|
size_t* byte_count) {
|
|
manager_->PauseForAllocation(self, [&]() REQUIRES_SHARED(art::Locks::mutator_lock_) {
|
|
std::ostringstream oss;
|
|
oss << "allocating " << *byte_count << " bytes of type " << type->PrettyClass();
|
|
return oss.str();
|
|
});
|
|
if (!type->IsVariableSize()) {
|
|
*byte_count =
|
|
std::max(art::RoundUp(static_cast<size_t>(type->GetObjectSize()), art::kObjectAlignment),
|
|
*byte_count);
|
|
}
|
|
}
|
|
|
|
AllocationManager::AllocationManager()
|
|
: alloc_listener_(nullptr),
|
|
alloc_listener_mutex_("JVMTI Alloc listener",
|
|
art::LockLevel::kPostUserCodeSuspensionTopLevelLock),
|
|
alloc_pause_cv_("JVMTI Allocation Pause Condvar", alloc_listener_mutex_) {
|
|
alloc_listener_.reset(new JvmtiAllocationListener(this));
|
|
}
|
|
|
|
void AllocationManager::DisableAllocationCallback(art::Thread* self) {
|
|
callback_enabled_.store(false);
|
|
DecrListenerInstall(self);
|
|
}
|
|
|
|
void AllocationManager::EnableAllocationCallback(art::Thread* self) {
|
|
IncrListenerInstall(self);
|
|
callback_enabled_.store(true);
|
|
}
|
|
|
|
void AllocationManager::SetAllocListener(AllocationCallback* callback) {
|
|
CHECK(callback_ == nullptr) << "Already setup!";
|
|
callback_ = callback;
|
|
alloc_listener_.reset(new JvmtiAllocationListener(this));
|
|
}
|
|
|
|
void AllocationManager::RemoveAllocListener() {
|
|
callback_enabled_.store(false, std::memory_order_seq_cst);
|
|
callback_ = nullptr;
|
|
}
|
|
|
|
void AllocationManager::DecrListenerInstall(art::Thread* self) {
|
|
art::ScopedThreadSuspension sts(self, art::ThreadState::kSuspended);
|
|
art::MutexLock mu(self, alloc_listener_mutex_);
|
|
// We don't need any particular memory-order here since we're under the lock, they aren't
|
|
// changing.
|
|
if (--listener_refcount_ == 0) {
|
|
art::Runtime::Current()->GetHeap()->RemoveAllocationListener();
|
|
}
|
|
}
|
|
|
|
void AllocationManager::IncrListenerInstall(art::Thread* self) {
|
|
art::ScopedThreadSuspension sts(self, art::ThreadState::kSuspended);
|
|
art::MutexLock mu(self, alloc_listener_mutex_);
|
|
// We don't need any particular memory-order here since we're under the lock, they aren't
|
|
// changing.
|
|
if (listener_refcount_++ == 0) {
|
|
art::Runtime::Current()->GetHeap()->SetAllocationListener(alloc_listener_.get());
|
|
}
|
|
}
|
|
|
|
void AllocationManager::PauseAllocations(art::Thread* self) {
|
|
art::Thread* null_thr = nullptr;
|
|
// Unfortunately once we've paused allocations once we have to leave the listener and
|
|
// PreObjectAlloc event enabled forever. This is to avoid an instance of the ABA problem. We need
|
|
// to make sure that every thread gets a chance to see the PreObjectAlloc event at least once or
|
|
// else it could miss the fact that the object its allocating had its size changed.
|
|
//
|
|
// Consider the following 2 threads. T1 is allocating an object of class K. It is suspended (by
|
|
// user code) somewhere in the AllocObjectWithAllocator function, perhaps while doing a GC to
|
|
// attempt to clear space. With that thread suspended on thread T2 we decide to structurally
|
|
// redefine 'K', changing its size. To do this we insert this PreObjectAlloc event to check and
|
|
// update the size of the class being allocated. This is done successfully. Now imagine if T2
|
|
// removed the listener event then T1 subsequently resumes. T1 would see there is no
|
|
// PreObjectAlloc event and so allocate using the old object size. This leads to it not allocating
|
|
// enough. To prevent this we simply force every allocation after our first pause to go through
|
|
// the PreObjectAlloc event.
|
|
//
|
|
// TODO Technically we could do better than this. We just need to be able to require that all
|
|
// threads within allocation functions go through the PreObjectAlloc at least once after we turn
|
|
// it on. This is easier said than done though since we don't want to place a marker on threads
|
|
// (allocation is just too common) and we can't just have every thread go through the event since
|
|
// there are some threads that never or almost never allocate. We would also need to ensure that
|
|
// this thread doesn't pause waiting for all threads to pass the barrier since the other threads
|
|
// might be suspended. We could accomplish this by storing callbacks on each thread that would do
|
|
// the work. Honestly though this is a debug feature and it doesn't slow things down very much so
|
|
// simply leaving it on forever is simpler and safer.
|
|
bool expected = false;
|
|
if (allocations_paused_ever_.compare_exchange_strong(expected, true, std::memory_order_seq_cst)) {
|
|
IncrListenerInstall(self);
|
|
}
|
|
do {
|
|
PauseForAllocation(self, []() { return "request to pause allocations on other threads"; });
|
|
} while (!allocations_paused_thread_.compare_exchange_strong(
|
|
null_thr, self, std::memory_order_seq_cst));
|
|
// Make sure everything else can see this and isn't in the middle of final allocation.
|
|
// Force every thread to either be suspended or pass through a barrier.
|
|
art::ScopedThreadSuspension sts(self, art::ThreadState::kSuspended);
|
|
art::Barrier barrier(0);
|
|
art::FunctionClosure fc([&](art::Thread* thr ATTRIBUTE_UNUSED) {
|
|
barrier.Pass(art::Thread::Current());
|
|
});
|
|
size_t requested = art::Runtime::Current()->GetThreadList()->RunCheckpoint(&fc);
|
|
barrier.Increment(self, requested);
|
|
}
|
|
|
|
void AllocationManager::ResumeAllocations(art::Thread* self) {
|
|
CHECK_EQ(allocations_paused_thread_.load(), self) << "not paused! ";
|
|
// See above for why we don't decr the install count.
|
|
CHECK(allocations_paused_ever_.load(std::memory_order_seq_cst));
|
|
art::ScopedThreadSuspension sts(self, art::ThreadState::kSuspended);
|
|
art::MutexLock mu(self, alloc_listener_mutex_);
|
|
allocations_paused_thread_.store(nullptr, std::memory_order_seq_cst);
|
|
alloc_pause_cv_.Broadcast(self);
|
|
}
|
|
|
|
} // namespace openjdkjvmti
|