void VM_EnterInterpOnlyMode::doit() { // Set up the current stack depth for later tracking _state->invalidate_cur_stack_depth(); _state->enter_interp_only_mode(); JavaThread *thread = _state->get_thread(); if (thread->has_last_Java_frame()) { // If running in fullspeed mode, single stepping is implemented // as follows: first, the interpreter does not dispatch to // compiled code for threads that have single stepping enabled; // second, we deoptimize all methods on the thread's stack when // interpreted-only mode is enabled the first time for a given // thread (nothing to do if no Java frames yet). int num_marked = 0; ResourceMark resMark; RegisterMap rm(thread, false); for (vframe* vf = thread->last_java_vframe(&rm); vf; vf = vf->sender()) { if (can_be_deoptimized(vf)) { ((compiledVFrame*) vf)->code()->mark_for_deoptimization(); ++num_marked; } } if (num_marked > 0) { VM_Deoptimize op; VMThread::execute(&op); } } }
void InterfaceSupport::walk_stack() { JavaThread* thread = JavaThread::current(); walk_stack_counter++; if (!thread->has_last_Java_frame()) return; ResourceMark rm(thread); RegisterMap reg_map(thread); walk_stack_from(thread->last_java_vframe(®_map)); }
void doit() { ResourceMark rmark; // _thread != Thread::current() RegisterMap rm(_thread, false); javaVFrame* vf = _thread->last_java_vframe(&rm); assert(vf != NULL, "must have last java frame"); methodOop method = vf->method(); _method_id = method->jmethod_id(); _bci = vf->bci(); }
void BiasedLocking::preserve_marks() { if (!UseBiasedLocking) return; assert(SafepointSynchronize::is_at_safepoint(), "must only be called while at safepoint"); assert(_preserved_oop_stack == NULL, "double initialization"); assert(_preserved_mark_stack == NULL, "double initialization"); // In order to reduce the number of mark words preserved during GC // due to the presence of biased locking, we reinitialize most mark // words to the class's prototype during GC -- even those which have // a currently valid bias owner. One important situation where we // must not clobber a bias is when a biased object is currently // locked. To handle this case we iterate over the currently-locked // monitors in a prepass and, if they are biased, preserve their // mark words here. This should be a relatively small set of objects // especially compared to the number of objects in the heap. _preserved_mark_stack = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<markOop>(10, true); _preserved_oop_stack = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<Handle>(10, true); ResourceMark rm; Thread* cur = Thread::current(); for (JavaThread* thread = Threads::first(); thread != NULL; thread = thread->next()) { if (thread->has_last_Java_frame()) { RegisterMap rm(thread); for (javaVFrame* vf = thread->last_java_vframe(&rm); vf != NULL; vf = vf->java_sender()) { GrowableArray<MonitorInfo*> *monitors = vf->monitors(); if (monitors != NULL) { int len = monitors->length(); // Walk monitors youngest to oldest for (int i = len - 1; i >= 0; i--) { MonitorInfo* mon_info = monitors->at(i); if (mon_info->owner_is_scalar_replaced()) continue; oop owner = mon_info->owner(); if (owner != NULL) { markOop mark = owner->mark(); if (mark->has_bias_pattern()) { _preserved_oop_stack->push(Handle(cur, owner)); _preserved_mark_stack->push(mark); } } } } } } } }
void doit() { ResourceMark rmark; // _thread != Thread::current() RegisterMap rm(_thread, false); // There can be a race condition between a VM_Operation reaching a safepoint // and the target thread exiting from Java execution. // We must recheck the last Java frame still exists. if (!_thread->is_exiting() && _thread->has_last_Java_frame()) { javaVFrame* vf = _thread->last_java_vframe(&rm); assert(vf != NULL, "must have last java frame"); Method* method = vf->method(); _method_id = method->jmethod_id(); _bci = vf->bci(); } else { // Clear current location as the target thread has no Java frames anymore. _method_id = (jmethodID)NULL; _bci = 0; } }