jdk-sandbox: comparison src/hotspot/share/runtime/biasedLocking.cpp

equal deleted inserted replaced

-:513e0b467a92
+:8d15b1369c7a
 #include "oops/oop.inline.hpp"
 #include "runtime/atomic.hpp"
 #include "runtime/basicLock.hpp"
 #include "runtime/biasedLocking.hpp"
 #include "runtime/task.hpp"
+#include "runtime/threadSMR.hpp"
 #include "runtime/vframe.hpp"
 #include "runtime/vmThread.hpp"
 #include "runtime/vm_operations.hpp"
 #include "trace/tracing.hpp"
 // Handle case where the thread toward which the object was biased has exited
 bool thread_is_alive = false;
 if (requesting_thread == biased_thread) {
 thread_is_alive = true;
 } else {
-for (JavaThread* cur_thread = Threads::first(); cur_thread != NULL; cur_thread = cur_thread->next()) {
+ThreadsListHandle tlh;
-if (cur_thread == biased_thread) {
+thread_is_alive = tlh.includes(biased_thread);
-thread_is_alive = true;
-break;
-}
-}
 }
 if (!thread_is_alive) {
 if (allow_rebias) {
 obj->set_mark(biased_prototype);
 } else {
 Klass* k_o = o->klass();
 Klass* klass = k_o;
-if (bulk_rebias) {
+{
-// Use the epoch in the klass of the object to implicitly revoke
+JavaThreadIteratorWithHandle jtiwh;
-// all biases of objects of this data type and force them to be
-// reacquired. However, we also need to walk the stacks of all
+if (bulk_rebias) {
-// threads and update the headers of lightweight locked objects
+// Use the epoch in the klass of the object to implicitly revoke
-// with biases to have the current epoch.
+// all biases of objects of this data type and force them to be
+// reacquired. However, we also need to walk the stacks of all
-// If the prototype header doesn't have the bias pattern, don't
+// threads and update the headers of lightweight locked objects
-// try to update the epoch -- assume another VM operation came in
+// with biases to have the current epoch.
-// and reset the header to the unbiased state, which will
-// implicitly cause all existing biases to be revoked
+// If the prototype header doesn't have the bias pattern, don't
-if (klass->prototype_header()->has_bias_pattern()) {
+// try to update the epoch -- assume another VM operation came in
-int prev_epoch = klass->prototype_header()->bias_epoch();
+// and reset the header to the unbiased state, which will
-klass->set_prototype_header(klass->prototype_header()->incr_bias_epoch());
+// implicitly cause all existing biases to be revoked
-int cur_epoch = klass->prototype_header()->bias_epoch();
+if (klass->prototype_header()->has_bias_pattern()) {
+int prev_epoch = klass->prototype_header()->bias_epoch();
-// Now walk all threads' stacks and adjust epochs of any biased
+klass->set_prototype_header(klass->prototype_header()->incr_bias_epoch());
-// and locked objects of this data type we encounter
+int cur_epoch = klass->prototype_header()->bias_epoch();
-for (JavaThread* thr = Threads::first(); thr != NULL; thr = thr->next()) {
+// Now walk all threads' stacks and adjust epochs of any biased
+// and locked objects of this data type we encounter
+for (; JavaThread *thr = jtiwh.next(); ) {
+GrowableArray<MonitorInfo*>* cached_monitor_info = get_or_compute_monitor_info(thr);
+for (int i = 0; i < cached_monitor_info->length(); i++) {
+MonitorInfo* mon_info = cached_monitor_info->at(i);
+oop owner = mon_info->owner();
+markOop mark = owner->mark();
+if ((owner->klass() == k_o) && mark->has_bias_pattern()) {
+// We might have encountered this object already in the case of recursive locking
+assert(mark->bias_epoch() == prev_epoch || mark->bias_epoch() == cur_epoch, "error in bias epoch adjustment");
+owner->set_mark(mark->set_bias_epoch(cur_epoch));
+}
+}
+}
+}
+// At this point we're done. All we have to do is potentially
+// adjust the header of the given object to revoke its bias.
+revoke_bias(o, attempt_rebias_of_object && klass->prototype_header()->has_bias_pattern(), true, requesting_thread, NULL);
+} else {
+if (log_is_enabled(Info, biasedlocking)) {
+ResourceMark rm;
+log_info(biasedlocking)("* Disabling biased locking for type %s", klass->external_name());
+}
+// Disable biased locking for this data type. Not only will this
+// cause future instances to not be biased, but existing biased
+// instances will notice that this implicitly caused their biases
+// to be revoked.
+klass->set_prototype_header(markOopDesc::prototype());
+// Now walk all threads' stacks and forcibly revoke the biases of
+// any locked and biased objects of this data type we encounter.
+for (; JavaThread *thr = jtiwh.next(); ) {
 GrowableArray<MonitorInfo*>* cached_monitor_info = get_or_compute_monitor_info(thr);
 for (int i = 0; i < cached_monitor_info->length(); i++) {
 MonitorInfo* mon_info = cached_monitor_info->at(i);
 oop owner = mon_info->owner();
 markOop mark = owner->mark();
 if ((owner->klass() == k_o) && mark->has_bias_pattern()) {
-// We might have encountered this object already in the case of recursive locking
+revoke_bias(owner, false, true, requesting_thread, NULL);
-assert(mark->bias_epoch() == prev_epoch || mark->bias_epoch() == cur_epoch, "error in bias epoch adjustment");
-owner->set_mark(mark->set_bias_epoch(cur_epoch));
 }
 }
 }
-}
+// Must force the bias of the passed object to be forcibly revoked
-// At this point we're done. All we have to do is potentially
+// as well to ensure guarantees to callers
-// adjust the header of the given object to revoke its bias.
+revoke_bias(o, false, true, requesting_thread, NULL);
-revoke_bias(o, attempt_rebias_of_object && klass->prototype_header()->has_bias_pattern(), true, requesting_thread, NULL);
+}
-} else {
+} // ThreadsListHandle is destroyed here.
-if (log_is_enabled(Info, biasedlocking)) {
-ResourceMark rm;
-log_info(biasedlocking)("* Disabling biased locking for type %s", klass->external_name());
-}
-// Disable biased locking for this data type. Not only will this
-// cause future instances to not be biased, but existing biased
-// instances will notice that this implicitly caused their biases
-// to be revoked.
-klass->set_prototype_header(markOopDesc::prototype());
-// Now walk all threads' stacks and forcibly revoke the biases of
-// any locked and biased objects of this data type we encounter.
-for (JavaThread* thr = Threads::first(); thr != NULL; thr = thr->next()) {
-GrowableArray<MonitorInfo*>* cached_monitor_info = get_or_compute_monitor_info(thr);
-for (int i = 0; i < cached_monitor_info->length(); i++) {
-MonitorInfo* mon_info = cached_monitor_info->at(i);
-oop owner = mon_info->owner();
-markOop mark = owner->mark();
-if ((owner->klass() == k_o) && mark->has_bias_pattern()) {
-revoke_bias(owner, false, true, requesting_thread, NULL);
-}
-}
-}
-// Must force the bias of the passed object to be forcibly revoked
-// as well to ensure guarantees to callers
-revoke_bias(o, false, true, requesting_thread, NULL);
-}
 log_info(biasedlocking)("* Ending bulk revocation");
 BiasedLocking::Condition status_code = BiasedLocking::BIAS_REVOKED;
 }
 static void clean_up_cached_monitor_info() {
 // Walk the thread list clearing out the cached monitors
-for (JavaThread* thr = Threads::first(); thr != NULL; thr = thr->next()) {
+for (JavaThreadIteratorWithHandle jtiwh; JavaThread *thr = jtiwh.next(); ) {
 thr->set_cached_monitor_info(NULL);
 }
 }
 _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()) {
+for (JavaThreadIteratorWithHandle jtiwh; JavaThread *thread = jtiwh.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) {

changeset 48105	8d15b1369c7a
parent 47764	029d5efaaa6c
child 49449	ef5d5d343e2a