Register debugger for interesting instrumentation events only
This avoids the overhead of notifying events (like method entry/exit, field
read/write, ...) from the interpreter when they are not requested on the JDWP
side. It also avoids burning JDWP ids for objects and classes before we find
out we do not need to report the event.
When we register a JDWP event (like a breakpoint), we add the debugger as
a listener for the corresponding instrumentation event (like kDexPcChanged).
On the other hand, when a JDWP event is cleared, we remove the debugger as a
listener for the corresponding instrumentation event. To control we add/remove
the debugger as listener only once per instrumentation event, we use reference
counting.
Like deoptimization, we can update instrumentation listeners only when when all
mutator threads are suspended. To add or remove the debugger as listener, we
extend the support of deoptimization requests to a more general support dealing
with instrumentation requests.
We add kRegisterForEvent and kUnregisterForEvent request kinds, respectively to
add or remove the debugger as a listener for a given instrumentation event.
Note: we will rename the related classes, methods, ... to avoid pollution in
the code review.
This CL also fixes Instrumentation::IsActive to take field read/write events
into account.
Bug: 14401699
Bug: 14826953
Change-Id: Ic896469e82a8589de419ebea4b9dc3116925f3ab
diff --git a/runtime/debugger.cc b/runtime/debugger.cc
index 22a0e22..858fa01 100644
--- a/runtime/debugger.cc
+++ b/runtime/debugger.cc
@@ -228,6 +228,15 @@
size_t Dbg::full_deoptimization_event_count_ = 0;
size_t Dbg::delayed_full_undeoptimization_count_ = 0;
+// Instrumentation event reference counters.
+size_t Dbg::dex_pc_change_event_ref_count_ = 0;
+size_t Dbg::method_enter_event_ref_count_ = 0;
+size_t Dbg::method_exit_event_ref_count_ = 0;
+size_t Dbg::field_read_event_ref_count_ = 0;
+size_t Dbg::field_write_event_ref_count_ = 0;
+size_t Dbg::exception_catch_event_ref_count_ = 0;
+uint32_t Dbg::instrumentation_events_ = 0;
+
// Breakpoints.
static std::vector<Breakpoint> gBreakpoints GUARDED_BY(Locks::breakpoint_lock_);
@@ -641,14 +650,6 @@
return gDisposed;
}
-// All the instrumentation events the debugger is registered for.
-static constexpr uint32_t kListenerEvents = instrumentation::Instrumentation::kMethodEntered |
- instrumentation::Instrumentation::kMethodExited |
- instrumentation::Instrumentation::kDexPcMoved |
- instrumentation::Instrumentation::kFieldRead |
- instrumentation::Instrumentation::kFieldWritten |
- instrumentation::Instrumentation::kExceptionCaught;
-
void Dbg::GoActive() {
// Enable all debugging features, including scans for breakpoints.
// This is a no-op if we're already active.
@@ -668,6 +669,12 @@
CHECK_EQ(deoptimization_requests_.size(), 0U);
CHECK_EQ(full_deoptimization_event_count_, 0U);
CHECK_EQ(delayed_full_undeoptimization_count_, 0U);
+ CHECK_EQ(dex_pc_change_event_ref_count_, 0U);
+ CHECK_EQ(method_enter_event_ref_count_, 0U);
+ CHECK_EQ(method_exit_event_ref_count_, 0U);
+ CHECK_EQ(field_read_event_ref_count_, 0U);
+ CHECK_EQ(field_write_event_ref_count_, 0U);
+ CHECK_EQ(exception_catch_event_ref_count_, 0U);
}
Runtime* runtime = Runtime::Current();
@@ -676,7 +683,7 @@
ThreadState old_state = self->SetStateUnsafe(kRunnable);
CHECK_NE(old_state, kRunnable);
runtime->GetInstrumentation()->EnableDeoptimization();
- runtime->GetInstrumentation()->AddListener(&gDebugInstrumentationListener, kListenerEvents);
+ instrumentation_events_ = 0;
gDebuggerActive = true;
CHECK_EQ(self->SetStateUnsafe(old_state), kRunnable);
runtime->GetThreadList()->ResumeAll();
@@ -708,7 +715,11 @@
full_deoptimization_event_count_ = 0U;
delayed_full_undeoptimization_count_ = 0U;
}
- runtime->GetInstrumentation()->RemoveListener(&gDebugInstrumentationListener, kListenerEvents);
+ if (instrumentation_events_ != 0) {
+ runtime->GetInstrumentation()->RemoveListener(&gDebugInstrumentationListener,
+ instrumentation_events_);
+ instrumentation_events_ = 0;
+ }
runtime->GetInstrumentation()->DisableDeoptimization();
gDebuggerActive = false;
}
@@ -2664,6 +2675,25 @@
}
}
+size_t* Dbg::GetReferenceCounterForEvent(uint32_t instrumentation_event) {
+ switch (instrumentation_event) {
+ case instrumentation::Instrumentation::kMethodEntered:
+ return &method_enter_event_ref_count_;
+ case instrumentation::Instrumentation::kMethodExited:
+ return &method_exit_event_ref_count_;
+ case instrumentation::Instrumentation::kDexPcMoved:
+ return &dex_pc_change_event_ref_count_;
+ case instrumentation::Instrumentation::kFieldRead:
+ return &field_read_event_ref_count_;
+ case instrumentation::Instrumentation::kFieldWritten:
+ return &field_write_event_ref_count_;
+ case instrumentation::Instrumentation::kExceptionCaught:
+ return &exception_catch_event_ref_count_;
+ default:
+ return nullptr;
+ }
+}
+
// Process request while all mutator threads are suspended.
void Dbg::ProcessDeoptimizationRequest(const DeoptimizationRequest& request) {
instrumentation::Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation();
@@ -2671,6 +2701,19 @@
case DeoptimizationRequest::kNothing:
LOG(WARNING) << "Ignoring empty deoptimization request.";
break;
+ case DeoptimizationRequest::kRegisterForEvent:
+ VLOG(jdwp) << StringPrintf("Add debugger as listener for instrumentation event 0x%x",
+ request.instrumentation_event);
+ instrumentation->AddListener(&gDebugInstrumentationListener, request.instrumentation_event);
+ instrumentation_events_ |= request.instrumentation_event;
+ break;
+ case DeoptimizationRequest::kUnregisterForEvent:
+ VLOG(jdwp) << StringPrintf("Remove debugger as listener for instrumentation event 0x%x",
+ request.instrumentation_event);
+ instrumentation->RemoveListener(&gDebugInstrumentationListener,
+ request.instrumentation_event);
+ instrumentation_events_ &= ~request.instrumentation_event;
+ break;
case DeoptimizationRequest::kFullDeoptimization:
VLOG(jdwp) << "Deoptimize the world ...";
instrumentation->DeoptimizeEverything();
@@ -2729,6 +2772,32 @@
void Dbg::RequestDeoptimizationLocked(const DeoptimizationRequest& req) {
switch (req.kind) {
+ case DeoptimizationRequest::kRegisterForEvent: {
+ DCHECK_NE(req.instrumentation_event, 0u);
+ size_t* counter = GetReferenceCounterForEvent(req.instrumentation_event);
+ CHECK(counter != nullptr) << StringPrintf("No counter for instrumentation event 0x%x",
+ req.instrumentation_event);
+ if (*counter == 0) {
+ VLOG(jdwp) << StringPrintf("Queue request #%d to start listening to instrumentation event 0x%x",
+ deoptimization_requests_.size(), req.instrumentation_event);
+ deoptimization_requests_.push_back(req);
+ }
+ *counter = *counter + 1;
+ break;
+ }
+ case DeoptimizationRequest::kUnregisterForEvent: {
+ DCHECK_NE(req.instrumentation_event, 0u);
+ size_t* counter = GetReferenceCounterForEvent(req.instrumentation_event);
+ CHECK(counter != nullptr) << StringPrintf("No counter for instrumentation event 0x%x",
+ req.instrumentation_event);
+ *counter = *counter - 1;
+ if (*counter == 0) {
+ VLOG(jdwp) << StringPrintf("Queue request #%d to stop listening to instrumentation event 0x%x",
+ deoptimization_requests_.size(), req.instrumentation_event);
+ deoptimization_requests_.push_back(req);
+ }
+ break;
+ }
case DeoptimizationRequest::kFullDeoptimization: {
DCHECK(req.method == nullptr);
if (full_deoptimization_event_count_ == 0) {
@@ -2741,7 +2810,6 @@
}
case DeoptimizationRequest::kFullUndeoptimization: {
DCHECK(req.method == nullptr);
- DCHECK_GT(full_deoptimization_event_count_, 0U);
--full_deoptimization_event_count_;
if (full_deoptimization_event_count_ == 0) {
VLOG(jdwp) << "Queue request #" << deoptimization_requests_.size()