149 Handle ThreadService::get_current_contended_monitor(JavaThread* thread) {
150 assert(thread != NULL, "should be non-NULL");
151 assert(Threads_lock->owned_by_self(), "must grab Threads_lock or be at safepoint");
152
153 ObjectMonitor *wait_obj = thread->current_waiting_monitor();
154
155 oop obj = NULL;
156 if (wait_obj != NULL) {
157 // thread is doing an Object.wait() call
158 obj = (oop) wait_obj->object();
159 assert(obj != NULL, "Object.wait() should have an object");
160 } else {
161 ObjectMonitor *enter_obj = thread->current_pending_monitor();
162 if (enter_obj != NULL) {
163 // thread is trying to enter() or raw_enter() an ObjectMonitor.
164 obj = (oop) enter_obj->object();
165 }
166 // If obj == NULL, then ObjectMonitor is raw which doesn't count.
167 }
168
169 Handle h(obj);
170 return h;
171 }
172
173 bool ThreadService::set_thread_monitoring_contention(bool flag) {
174 MutexLocker m(Management_lock);
175
176 bool prev = _thread_monitoring_contention_enabled;
177 _thread_monitoring_contention_enabled = flag;
178
179 return prev;
180 }
181
182 bool ThreadService::set_thread_cpu_time_enabled(bool flag) {
183 MutexLocker m(Management_lock);
184
185 bool prev = _thread_cpu_time_enabled;
186 _thread_cpu_time_enabled = flag;
187
188 return prev;
572 }
573 if (maxDepth > 0 && count == maxDepth) {
574 // Skip frames if more than maxDepth
575 break;
576 }
577 }
578 }
579
580 if (_with_locked_monitors) {
581 // Iterate inflated monitors and find monitors locked by this thread
582 // not found in the stack
583 InflatedMonitorsClosure imc(_thread, this);
584 ObjectSynchronizer::monitors_iterate(&imc);
585 }
586 }
587
588
589 bool ThreadStackTrace::is_owned_monitor_on_stack(oop object) {
590 assert(SafepointSynchronize::is_at_safepoint(), "all threads are stopped");
591
592 bool found = false;
593 int num_frames = get_stack_depth();
594 for (int depth = 0; depth < num_frames; depth++) {
595 StackFrameInfo* frame = stack_frame_at(depth);
596 int len = frame->num_locked_monitors();
597 GrowableArray<oop>* locked_monitors = frame->locked_monitors();
598 for (int j = 0; j < len; j++) {
599 oop monitor = locked_monitors->at(j);
600 assert(monitor != NULL, "must be a Java object");
601 if (monitor == object) {
602 found = true;
603 break;
604 }
605 }
606 }
607 return found;
608 }
609
610 Handle ThreadStackTrace::allocate_fill_stack_trace_element_array(TRAPS) {
611 Klass* k = SystemDictionary::StackTraceElement_klass();
612 assert(k != NULL, "must be loaded in 1.4+");
613 instanceKlassHandle ik(THREAD, k);
614
615 // Allocate an array of java/lang/StackTraceElement object
616 objArrayOop ste = oopFactory::new_objArray(ik(), _depth, CHECK_NH);
617 objArrayHandle backtrace(THREAD, ste);
618 for (int j = 0; j < _depth; j++) {
619 StackFrameInfo* frame = _frames->at(j);
|
149 Handle ThreadService::get_current_contended_monitor(JavaThread* thread) {
150 assert(thread != NULL, "should be non-NULL");
151 assert(Threads_lock->owned_by_self(), "must grab Threads_lock or be at safepoint");
152
153 ObjectMonitor *wait_obj = thread->current_waiting_monitor();
154
155 oop obj = NULL;
156 if (wait_obj != NULL) {
157 // thread is doing an Object.wait() call
158 obj = (oop) wait_obj->object();
159 assert(obj != NULL, "Object.wait() should have an object");
160 } else {
161 ObjectMonitor *enter_obj = thread->current_pending_monitor();
162 if (enter_obj != NULL) {
163 // thread is trying to enter() or raw_enter() an ObjectMonitor.
164 obj = (oop) enter_obj->object();
165 }
166 // If obj == NULL, then ObjectMonitor is raw which doesn't count.
167 }
168
169 obj = oopDesc::bs()->write_barrier(obj);
170 Handle h(obj);
171 return h;
172 }
173
174 bool ThreadService::set_thread_monitoring_contention(bool flag) {
175 MutexLocker m(Management_lock);
176
177 bool prev = _thread_monitoring_contention_enabled;
178 _thread_monitoring_contention_enabled = flag;
179
180 return prev;
181 }
182
183 bool ThreadService::set_thread_cpu_time_enabled(bool flag) {
184 MutexLocker m(Management_lock);
185
186 bool prev = _thread_cpu_time_enabled;
187 _thread_cpu_time_enabled = flag;
188
189 return prev;
573 }
574 if (maxDepth > 0 && count == maxDepth) {
575 // Skip frames if more than maxDepth
576 break;
577 }
578 }
579 }
580
581 if (_with_locked_monitors) {
582 // Iterate inflated monitors and find monitors locked by this thread
583 // not found in the stack
584 InflatedMonitorsClosure imc(_thread, this);
585 ObjectSynchronizer::monitors_iterate(&imc);
586 }
587 }
588
589
590 bool ThreadStackTrace::is_owned_monitor_on_stack(oop object) {
591 assert(SafepointSynchronize::is_at_safepoint(), "all threads are stopped");
592
593 object = oopDesc::bs()->write_barrier(object);
594
595 bool found = false;
596 int num_frames = get_stack_depth();
597 for (int depth = 0; depth < num_frames; depth++) {
598 StackFrameInfo* frame = stack_frame_at(depth);
599 int len = frame->num_locked_monitors();
600 GrowableArray<oop>* locked_monitors = frame->locked_monitors();
601 for (int j = 0; j < len; j++) {
602 oop monitor = locked_monitors->at(j);
603 monitor = oopDesc::bs()->write_barrier(monitor);
604 assert(monitor != NULL, "must be a Java object");
605 if (monitor == object) {
606 found = true;
607 break;
608 }
609 }
610 }
611 return found;
612 }
613
614 Handle ThreadStackTrace::allocate_fill_stack_trace_element_array(TRAPS) {
615 Klass* k = SystemDictionary::StackTraceElement_klass();
616 assert(k != NULL, "must be loaded in 1.4+");
617 instanceKlassHandle ik(THREAD, k);
618
619 // Allocate an array of java/lang/StackTraceElement object
620 objArrayOop ste = oopFactory::new_objArray(ik(), _depth, CHECK_NH);
621 objArrayHandle backtrace(THREAD, ste);
622 for (int j = 0; j < _depth; j++) {
623 StackFrameInfo* frame = _frames->at(j);
|