mirror::ArtMethod* method;
uint32_t dex_pc;
Breakpoint(mirror::ArtMethod* method, uint32_t dex_pc) : method(method), dex_pc(dex_pc) {}
+
+ void VisitRoots(RootCallback* callback, void* arg) {
+ if (method != nullptr) {
+ callback(reinterpret_cast<mirror::Object**>(&method), arg, 0, kRootDebugger);
+ }
+ }
};
static std::ostream& operator<<(std::ostream& os, const Breakpoint& rhs)
// Breakpoints.
static std::vector<Breakpoint> gBreakpoints GUARDED_BY(Locks::breakpoint_lock_);
+void DebugInvokeReq::VisitRoots(RootCallback* callback, void* arg, uint32_t tid,
+ RootType root_type) {
+ if (receiver != nullptr) {
+ callback(&receiver, arg, tid, root_type);
+ }
+ if (thread != nullptr) {
+ callback(&thread, arg, tid, root_type);
+ }
+ if (klass != nullptr) {
+ callback(reinterpret_cast<mirror::Object**>(&klass), arg, tid, root_type);
+ }
+ if (method != nullptr) {
+ callback(reinterpret_cast<mirror::Object**>(&method), arg, tid, root_type);
+ }
+}
+
+void SingleStepControl::VisitRoots(RootCallback* callback, void* arg, uint32_t tid,
+ RootType root_type) {
+ if (method != nullptr) {
+ callback(reinterpret_cast<mirror::Object**>(&method), arg, tid, root_type);
+ }
+}
+
static bool IsBreakpoint(const mirror::ArtMethod* m, uint32_t dex_pc)
LOCKS_EXCLUDED(Locks::breakpoint_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
}
}
+void Dbg::VisitRoots(RootCallback* callback, void* arg) {
+ MutexLock mu(Thread::Current(), *Locks::breakpoint_lock_);
+ for (Breakpoint& bp : gBreakpoints) {
+ bp.VisitRoots(callback, arg);
+ }
+}
+
void Dbg::StopJdwp() {
// Prevent the JDWP thread from processing JDWP incoming packets after we close the connection.
Disposed();
}
}
-void Dbg::UpdateObjectPointers(IsMarkedCallback* visitor, void* arg) {
+void Dbg::UpdateObjectPointers(IsMarkedCallback* callback, void* arg) {
if (recent_allocation_records_ != nullptr) {
MutexLock mu(Thread::Current(), *alloc_tracker_lock_);
size_t i = HeadIndex();
while (count--) {
AllocRecord* record = &recent_allocation_records_[i];
DCHECK(record != nullptr);
- record->UpdateObjectPointers(visitor, arg);
+ record->UpdateObjectPointers(callback, arg);
i = (i + 1) & (alloc_record_max_ - 1);
}
}
if (gRegistry != nullptr) {
- gRegistry->UpdateObjectPointers(visitor, arg);
+ gRegistry->UpdateObjectPointers(callback, arg);
}
}
Mutex lock DEFAULT_MUTEX_ACQUIRED_AFTER;
ConditionVariable cond GUARDED_BY(lock);
+ void VisitRoots(RootCallback* callback, void* arg, uint32_t tid, RootType root_type)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
private:
DISALLOW_COPY_AND_ASSIGN(DebugInvokeReq);
};
// single-step depth.
int stack_depth;
+ void VisitRoots(RootCallback* callback, void* arg, uint32_t tid, RootType root_type)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
private:
DISALLOW_COPY_AND_ASSIGN(SingleStepControl);
};
static void DdmSendChunkV(uint32_t type, const iovec* iov, int iov_count)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ static void VisitRoots(RootCallback* callback, void* arg)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
/*
* Recent allocation tracking support.
*/
void operator()(mirror::Object* obj, MemberOffset offset, bool /* is_static */) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ DCHECK(obj != nullptr);
mirror::HeapReference<mirror::Object>* ref_ptr = obj->GetFieldObjectReferenceAddr(offset);
if (target_space_->HasAddress(ref_ptr->AsMirrorPtr())) {
*contains_reference_to_target_space_ = true;
#ifndef ART_RUNTIME_GC_COLLECTOR_SEMI_SPACE_INL_H_
#define ART_RUNTIME_GC_COLLECTOR_SEMI_SPACE_INL_H_
+#include "semi_space.h"
+
+#include "gc/accounting/heap_bitmap.h"
+#include "mirror/object-inl.h"
+
namespace art {
namespace gc {
namespace collector {
return reinterpret_cast<mirror::Object*>(lock_word.ForwardingAddress());
}
+// Used to mark and copy objects. Any newly-marked objects who are in the from space get moved to
+// the to-space and have their forward address updated. Objects which have been newly marked are
+// pushed on the mark stack.
+template<bool kPoisonReferences>
+inline void SemiSpace::MarkObject(
+ mirror::ObjectReference<kPoisonReferences, mirror::Object>* obj_ptr) {
+ mirror::Object* obj = obj_ptr->AsMirrorPtr();
+ if (obj == nullptr) {
+ return;
+ }
+ if (kUseBrooksPointer) {
+ // Verify all the objects have the correct forward pointer installed.
+ obj->AssertSelfBrooksPointer();
+ }
+ if (!immune_region_.ContainsObject(obj)) {
+ if (from_space_->HasAddress(obj)) {
+ mirror::Object* forward_address = GetForwardingAddressInFromSpace(obj);
+ // If the object has already been moved, return the new forward address.
+ if (forward_address == nullptr) {
+ forward_address = MarkNonForwardedObject(obj);
+ DCHECK(forward_address != nullptr);
+ // Make sure to only update the forwarding address AFTER you copy the object so that the
+ // monitor word doesn't get stomped over.
+ obj->SetLockWord(LockWord::FromForwardingAddress(
+ reinterpret_cast<size_t>(forward_address)));
+ // Push the object onto the mark stack for later processing.
+ MarkStackPush(forward_address);
+ }
+ obj_ptr->Assign(forward_address);
+ } else {
+ accounting::SpaceBitmap* object_bitmap =
+ heap_->GetMarkBitmap()->GetContinuousSpaceBitmap(obj);
+ if (LIKELY(object_bitmap != nullptr)) {
+ if (generational_) {
+ // If a bump pointer space only collection, we should not
+ // reach here as we don't/won't mark the objects in the
+ // non-moving space (except for the promoted objects.) Note
+ // the non-moving space is added to the immune space.
+ DCHECK(whole_heap_collection_);
+ }
+ if (!object_bitmap->Set(obj)) {
+ // This object was not previously marked.
+ MarkStackPush(obj);
+ }
+ } else {
+ CHECK(!to_space_->HasAddress(obj)) << "Marking " << obj << " in to_space_";
+ if (MarkLargeObject(obj)) {
+ MarkStackPush(obj);
+ }
+ }
+ }
+ }
+}
+
} // namespace collector
} // namespace gc
} // namespace art
* limitations under the License.
*/
-#include "semi_space.h"
+#include "semi_space-inl.h"
#include <functional>
#include <numeric>
#include "mirror/object_array.h"
#include "mirror/object_array-inl.h"
#include "runtime.h"
-#include "semi_space-inl.h"
+#include "stack.h"
#include "thread-inl.h"
#include "thread_list.h"
#include "verifier/method_verifier.h"
mirror::Object* ref = obj->GetFieldObject<mirror::Object>(offset, false);
if (from_space_->HasAddress(ref)) {
Runtime::Current()->GetHeap()->DumpObject(LOG(INFO), obj);
+ LOG(FATAL) << ref << " found in from space";
}
}
private:
return forward_address;
}
-// Used to mark and copy objects. Any newly-marked objects who are in the from space get moved to
-// the to-space and have their forward address updated. Objects which have been newly marked are
-// pushed on the mark stack.
-void SemiSpace::MarkObject(mirror::HeapReference<Object>* obj_ptr) {
- Object* obj = obj_ptr->AsMirrorPtr();
- if (obj == nullptr) {
- return;
- }
- if (kUseBrooksPointer) {
- // Verify all the objects have the correct forward pointer installed.
- obj->AssertSelfBrooksPointer();
- }
- if (!immune_region_.ContainsObject(obj)) {
- if (from_space_->HasAddress(obj)) {
- mirror::Object* forward_address = GetForwardingAddressInFromSpace(obj);
- // If the object has already been moved, return the new forward address.
- if (forward_address == nullptr) {
- forward_address = MarkNonForwardedObject(obj);
- DCHECK(forward_address != nullptr);
- // Make sure to only update the forwarding address AFTER you copy the object so that the
- // monitor word doesn't get stomped over.
- obj->SetLockWord(LockWord::FromForwardingAddress(
- reinterpret_cast<size_t>(forward_address)));
- // Push the object onto the mark stack for later processing.
- MarkStackPush(forward_address);
- }
- obj_ptr->Assign(forward_address);
- } else {
- accounting::SpaceBitmap* object_bitmap =
- heap_->GetMarkBitmap()->GetContinuousSpaceBitmap(obj);
- if (LIKELY(object_bitmap != nullptr)) {
- if (generational_) {
- // If a bump pointer space only collection, we should not
- // reach here as we don't/won't mark the objects in the
- // non-moving space (except for the promoted objects.) Note
- // the non-moving space is added to the immune space.
- DCHECK(whole_heap_collection_);
- }
- if (!object_bitmap->Set(obj)) {
- // This object was not previously marked.
- MarkStackPush(obj);
- }
- } else {
- CHECK(!to_space_->HasAddress(obj)) << "Marking object in to_space_";
- if (MarkLargeObject(obj)) {
- MarkStackPush(obj);
- }
- }
- }
- }
-}
-
void SemiSpace::ProcessMarkStackCallback(void* arg) {
reinterpret_cast<SemiSpace*>(arg)->ProcessMarkStack();
}
mirror::Object* SemiSpace::MarkObjectCallback(mirror::Object* root, void* arg) {
- auto ref = mirror::HeapReference<mirror::Object>::FromMirrorPtr(root);
+ auto ref = StackReference<mirror::Object>::FromMirrorPtr(root);
reinterpret_cast<SemiSpace*>(arg)->MarkObject(&ref);
return ref.AsMirrorPtr();
}
void SemiSpace::MarkRootCallback(Object** root, void* arg, uint32_t /*thread_id*/,
RootType /*root_type*/) {
- auto ref = mirror::HeapReference<mirror::Object>::FromMirrorPtr(*root);
+ auto ref = StackReference<mirror::Object>::FromMirrorPtr(*root);
reinterpret_cast<SemiSpace*>(arg)->MarkObject(&ref);
if (*root != ref.AsMirrorPtr()) {
*root = ref.AsMirrorPtr();
void FindDefaultMarkBitmap();
// Returns the new address of the object.
- void MarkObject(mirror::HeapReference<mirror::Object>* obj_ptr)
+ template<bool kPoisonReferences>
+ void MarkObject(mirror::ObjectReference<kPoisonReferences, mirror::Object>* obj_ptr)
EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// marked, put it on the appropriate list in the heap for later processing.
void Heap::DelayReferenceReferent(mirror::Class* klass, mirror::Reference* ref,
IsMarkedCallback is_marked_callback, void* arg) {
- DCHECK_EQ(klass, ref->GetClass());
+ // klass can be the class of the old object if the visitor already updated the class of ref.
+ DCHECK(klass->IsReferenceClass());
mirror::Object* referent = ref->GetReferent();
if (referent != nullptr) {
mirror::Object* forward_address = is_marked_callback(referent, arg);
o->VisitReferences<true>(*this);
}
- // For MarkSweep::VisitObjectReferences.
+ // For Object::VisitReferences.
void operator()(mirror::Object* obj, MemberOffset offset, bool /* is_static */) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
mirror::Object* ref = obj->GetFieldObject<mirror::Object>(offset, false);
this->operator()(ref, mirror::Reference::ReferentOffset(), false);
}
- void operator()(mirror::Object* obj, MemberOffset offset, bool /* static */) const
+ void operator()(mirror::Object* obj, MemberOffset offset, bool /*is_static*/) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
this->operator()(obj, obj->GetFieldObject<mirror::Object>(offset, false), offset);
}
return instrumentation->InstallStubsForClass(klass);
}
+Instrumentation::Instrumentation()
+ : instrumentation_stubs_installed_(false), entry_exit_stubs_installed_(false),
+ interpreter_stubs_installed_(false),
+ interpret_only_(false), forced_interpret_only_(false),
+ have_method_entry_listeners_(false), have_method_exit_listeners_(false),
+ have_method_unwind_listeners_(false), have_dex_pc_listeners_(false),
+ have_exception_caught_listeners_(false),
+ deoptimized_methods_lock_("deoptimized methods lock"),
+ deoptimization_enabled_(false),
+ interpreter_handler_table_(kMainHandlerTable),
+ quick_alloc_entry_points_instrumentation_counter_(0) {
+}
+
bool Instrumentation::InstallStubsForClass(mirror::Class* klass) {
for (size_t i = 0, e = klass->NumDirectMethods(); i < e; i++) {
InstallStubsForMethod(klass->GetDirectMethod(i));
entry_exit_stubs_installed_ = false;
runtime->GetClassLinker()->VisitClasses(InstallStubsClassVisitor, this);
// Restore stack only if there is no method currently deoptimized.
- if (deoptimized_methods_.empty()) {
+ bool empty;
+ {
+ ReaderMutexLock mu(self, deoptimized_methods_lock_);
+ empty = deoptimized_methods_.empty(); // Avoid lock violation.
+ }
+ if (empty) {
instrumentation_stubs_installed_ = false;
MutexLock mu(self, *Locks::thread_list_lock_);
Runtime::Current()->GetThreadList()->ForEach(InstrumentationRestoreStack, this);
CHECK(!method->IsProxyMethod());
CHECK(!method->IsAbstract());
- std::pair<std::set<mirror::ArtMethod*>::iterator, bool> pair = deoptimized_methods_.insert(method);
+ Thread* self = Thread::Current();
+ std::pair<std::set<mirror::ArtMethod*>::iterator, bool> pair;
+ {
+ WriterMutexLock mu(self, deoptimized_methods_lock_);
+ pair = deoptimized_methods_.insert(method);
+ }
bool already_deoptimized = !pair.second;
CHECK(!already_deoptimized) << "Method " << PrettyMethod(method) << " is already deoptimized";
// Install instrumentation exit stub and instrumentation frames. We may already have installed
// these previously so it will only cover the newly created frames.
instrumentation_stubs_installed_ = true;
- MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
+ MutexLock mu(self, *Locks::thread_list_lock_);
Runtime::Current()->GetThreadList()->ForEach(InstrumentationInstallStack, this);
}
}
CHECK(!method->IsProxyMethod());
CHECK(!method->IsAbstract());
- auto it = deoptimized_methods_.find(method);
- CHECK(it != deoptimized_methods_.end()) << "Method " << PrettyMethod(method) << " is not deoptimized";
- deoptimized_methods_.erase(it);
+ Thread* self = Thread::Current();
+ bool empty;
+ {
+ WriterMutexLock mu(self, deoptimized_methods_lock_);
+ auto it = deoptimized_methods_.find(method);
+ CHECK(it != deoptimized_methods_.end()) << "Method " << PrettyMethod(method)
+ << " is not deoptimized";
+ deoptimized_methods_.erase(it);
+ empty = deoptimized_methods_.empty();
+ }
// Restore code and possibly stack only if we did not deoptimize everything.
if (!interpreter_stubs_installed_) {
}
// If there is no deoptimized method left, we can restore the stack of each thread.
- if (deoptimized_methods_.empty()) {
- MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
+ if (empty) {
+ MutexLock mu(self, *Locks::thread_list_lock_);
Runtime::Current()->GetThreadList()->ForEach(InstrumentationRestoreStack, this);
instrumentation_stubs_installed_ = false;
}
}
bool Instrumentation::IsDeoptimized(mirror::ArtMethod* method) const {
+ ReaderMutexLock mu(Thread::Current(), deoptimized_methods_lock_);
DCHECK(method != nullptr);
- return deoptimized_methods_.count(method);
+ return deoptimized_methods_.find(method) != deoptimized_methods_.end();
}
void Instrumentation::EnableDeoptimization() {
+ ReaderMutexLock mu(Thread::Current(), deoptimized_methods_lock_);
CHECK(deoptimized_methods_.empty());
CHECK_EQ(deoptimization_enabled_, false);
deoptimization_enabled_ = true;
UndeoptimizeEverything();
}
// Undeoptimized selected methods.
- while (!deoptimized_methods_.empty()) {
- auto it_begin = deoptimized_methods_.begin();
- Undeoptimize(*it_begin);
+ while (true) {
+ mirror::ArtMethod* method;
+ {
+ ReaderMutexLock mu(Thread::Current(), deoptimized_methods_lock_);
+ if (deoptimized_methods_.empty()) {
+ break;
+ }
+ method = *deoptimized_methods_.begin();
+ }
+ Undeoptimize(method);
}
- CHECK(deoptimized_methods_.empty());
deoptimization_enabled_ = false;
}
}
}
+void Instrumentation::VisitRoots(RootCallback* callback, void* arg) {
+ WriterMutexLock mu(Thread::Current(), deoptimized_methods_lock_);
+ if (deoptimized_methods_.empty()) {
+ return;
+ }
+ std::set<mirror::ArtMethod*> new_deoptimized_methods;
+ for (mirror::ArtMethod* method : deoptimized_methods_) {
+ DCHECK(method != nullptr);
+ callback(reinterpret_cast<mirror::Object**>(&method), arg, 0, kRootVMInternal);
+ new_deoptimized_methods.insert(method);
+ }
+ deoptimized_methods_ = new_deoptimized_methods;
+}
+
std::string InstrumentationStackFrame::Dump() const {
std::ostringstream os;
os << "Frame " << frame_id_ << " " << PrettyMethod(method_) << ":"
#include "atomic.h"
#include "base/macros.h"
#include "base/mutex.h"
+#include "object_callbacks.h"
#include <stdint.h>
#include <set>
kExceptionCaught = 16
};
- Instrumentation() :
- instrumentation_stubs_installed_(false), entry_exit_stubs_installed_(false),
- interpreter_stubs_installed_(false),
- interpret_only_(false), forced_interpret_only_(false),
- have_method_entry_listeners_(false), have_method_exit_listeners_(false),
- have_method_unwind_listeners_(false), have_dex_pc_listeners_(false),
- have_exception_caught_listeners_(false),
- deoptimization_enabled_(false),
- interpreter_handler_table_(kMainHandlerTable),
- quick_alloc_entry_points_instrumentation_counter_(0) {}
+ Instrumentation();
// Add a listener to be notified of the masked together sent of instrumentation events. This
// suspend the runtime to install stubs. You are expected to hold the mutator lock as a proxy
LOCKS_EXCLUDED(Locks::thread_list_lock_, Locks::classlinker_classes_lock_);
// Deoptimization.
- void EnableDeoptimization() EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_);
- void DisableDeoptimization() EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_);
+ void EnableDeoptimization() EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_)
+ LOCKS_EXCLUDED(deoptimized_methods_lock_);
+ void DisableDeoptimization() EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_)
+ LOCKS_EXCLUDED(deoptimized_methods_lock_);
bool ShouldNotifyMethodEnterExitEvents() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Executes everything with interpreter.
// method (except a class initializer) set to the resolution trampoline will be deoptimized only
// once its declaring class is initialized.
void Deoptimize(mirror::ArtMethod* method)
- LOCKS_EXCLUDED(Locks::thread_list_lock_)
+ LOCKS_EXCLUDED(Locks::thread_list_lock_, deoptimized_methods_lock_)
EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_);
// Undeoptimze the method by restoring its entrypoints. Nevertheless, a static method
LOCKS_EXCLUDED(Locks::thread_list_lock_)
EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_);
- bool IsDeoptimized(mirror::ArtMethod* method) const;
+ bool IsDeoptimized(mirror::ArtMethod* method) const LOCKS_EXCLUDED(deoptimized_methods_lock_);
// Enable method tracing by installing instrumentation entry/exit stubs.
void EnableMethodTracing()
void InstallStubsForMethod(mirror::ArtMethod* method)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ void VisitRoots(RootCallback* callback, void* arg) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
+ LOCKS_EXCLUDED(deoptimized_methods_lock_);
+
private:
// Does the job of installing or removing instrumentation code within methods.
void ConfigureStubs(bool require_entry_exit_stubs, bool require_interpreter)
EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_)
- LOCKS_EXCLUDED(Locks::thread_list_lock_, Locks::classlinker_classes_lock_);
+ LOCKS_EXCLUDED(Locks::thread_list_lock_, Locks::classlinker_classes_lock_,
+ deoptimized_methods_lock_);
void UpdateInterpreterHandlerTable() {
interpreter_handler_table_ = IsActive() ? kAlternativeHandlerTable : kMainHandlerTable;
// The set of methods being deoptimized (by the debugger) which must be executed with interpreter
// only.
- // TODO we need to visit these methods as roots.
- std::set<mirror::ArtMethod*> deoptimized_methods_;
+ mutable ReaderWriterMutex deoptimized_methods_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
+ std::set<mirror::ArtMethod*> deoptimized_methods_ GUARDED_BY(deoptimized_methods_lock_);
bool deoptimization_enabled_;
// Current interpreter handler table. This is updated each time the thread state flags are
void Runtime::VisitConstantRoots(RootCallback* callback, void* arg) {
// Visit the classes held as static in mirror classes, these can be visited concurrently and only
- // need to be visited once since they never change.
+ // need to be visited once per GC since they never change.
mirror::ArtField::VisitRoots(callback, arg);
mirror::ArtMethod::VisitRoots(callback, arg);
mirror::Class::VisitRoots(callback, arg);
void Runtime::VisitConcurrentRoots(RootCallback* callback, void* arg, VisitRootFlags flags) {
intern_table_->VisitRoots(callback, arg, flags);
class_linker_->VisitRoots(callback, arg, flags);
+ Dbg::VisitRoots(callback, arg);
if ((flags & kVisitRootFlagNewRoots) == 0) {
// Guaranteed to have no new roots in the constant roots.
VisitConstantRoots(callback, arg);
if (preinitialization_transaction != nullptr) {
preinitialization_transaction->VisitRoots(callback, arg);
}
+ instrumentation_.VisitRoots(callback, arg);
}
void Runtime::VisitNonConcurrentRoots(RootCallback* callback, void* arg) {
jni_env_->locals.VisitRoots(visitor, arg, thread_id, kRootJNILocal);
jni_env_->monitors.VisitRoots(visitor, arg, thread_id, kRootJNIMonitor);
SirtVisitRoots(visitor, arg, thread_id);
+ if (debug_invoke_req_ != nullptr) {
+ debug_invoke_req_->VisitRoots(visitor, arg, thread_id, kRootDebugger);
+ }
+ if (single_step_control_ != nullptr) {
+ single_step_control_->VisitRoots(visitor, arg, thread_id, kRootDebugger);
+ }
// Visit roots on this thread's stack
Context* context = GetLongJumpContext();
RootCallbackVisitor visitorToCallback(visitor, arg, thread_id);
OSDN Git Service
