< prev index next >

src/share/vm/runtime/biasedLocking.cpp

Print this page




  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "oops/klass.inline.hpp"
  27 #include "oops/markOop.hpp"
  28 #include "runtime/basicLock.hpp"
  29 #include "runtime/biasedLocking.hpp"
  30 #include "runtime/task.hpp"
  31 #include "runtime/vframe.hpp"
  32 #include "runtime/vmThread.hpp"
  33 #include "runtime/vm_operations.hpp"


  34 
  35 static bool _biased_locking_enabled = false;
  36 BiasedLockingCounters BiasedLocking::_counters;
  37 
  38 static GrowableArray<Handle>*  _preserved_oop_stack  = NULL;
  39 static GrowableArray<markOop>* _preserved_mark_stack = NULL;
  40 
  41 static void enable_biased_locking(Klass* k) {
  42   k->set_prototype_header(markOopDesc::biased_locking_prototype());
  43 }
  44 
  45 class VM_EnableBiasedLocking: public VM_Operation {
  46  private:
  47   bool _is_cheap_allocated;
  48  public:
  49   VM_EnableBiasedLocking(bool is_cheap_allocated) { _is_cheap_allocated = is_cheap_allocated; }
  50   VMOp_Type type() const          { return VMOp_EnableBiasedLocking; }
  51   Mode evaluation_mode() const    { return _is_cheap_allocated ? _async_safepoint : _safepoint; }
  52   bool is_cheap_allocated() const { return _is_cheap_allocated; }
  53 


 125       GrowableArray<MonitorInfo*> *monitors = vf->monitors();
 126       if (monitors != NULL) {
 127         int len = monitors->length();
 128         // Walk monitors youngest to oldest
 129         for (int i = len - 1; i >= 0; i--) {
 130           MonitorInfo* mon_info = monitors->at(i);
 131           if (mon_info->eliminated()) continue;
 132           oop owner = mon_info->owner();
 133           if (owner != NULL) {
 134             info->append(mon_info);
 135           }
 136         }
 137       }
 138     }
 139   }
 140 
 141   thread->set_cached_monitor_info(info);
 142   return info;
 143 }
 144 
 145 
 146 static BiasedLocking::Condition revoke_bias(oop obj, bool allow_rebias, bool is_bulk, JavaThread* requesting_thread) {

 147   markOop mark = obj->mark();
 148   if (!mark->has_bias_pattern()) {
 149     if (TraceBiasedLocking) {
 150       ResourceMark rm;
 151       tty->print_cr("  (Skipping revocation of object of type %s because it's no longer biased)",
 152                     obj->klass()->external_name());
 153     }
 154     return BiasedLocking::NOT_BIASED;
 155   }
 156 
 157   uint age = mark->age();
 158   markOop   biased_prototype = markOopDesc::biased_locking_prototype()->set_age(age);
 159   markOop unbiased_prototype = markOopDesc::prototype()->set_age(age);
 160 
 161   if (TraceBiasedLocking && (Verbose || !is_bulk)) {
 162     ResourceMark rm;
 163     tty->print_cr("Revoking bias of object " INTPTR_FORMAT " , mark " INTPTR_FORMAT " , type %s , prototype header " INTPTR_FORMAT " , allow rebias %d , requesting thread " INTPTR_FORMAT,
 164                   p2i((void *)obj), (intptr_t) mark, obj->klass()->external_name(), (intptr_t) obj->klass()->prototype_header(), (allow_rebias ? 1 : 0), (intptr_t) requesting_thread);
 165   }
 166 


 236     // Reset object header to point to displaced mark.
 237     // Must release storing the lock address for platforms without TSO
 238     // ordering (e.g. ppc).
 239     obj->release_set_mark(markOopDesc::encode(highest_lock));
 240     assert(!obj->mark()->has_bias_pattern(), "illegal mark state: stack lock used bias bit");
 241     if (TraceBiasedLocking && (Verbose || !is_bulk)) {
 242       tty->print_cr("  Revoked bias of currently-locked object");
 243     }
 244   } else {
 245     if (TraceBiasedLocking && (Verbose || !is_bulk)) {
 246       tty->print_cr("  Revoked bias of currently-unlocked object");
 247     }
 248     if (allow_rebias) {
 249       obj->set_mark(biased_prototype);
 250     } else {
 251       // Store the unlocked value into the object's header.
 252       obj->set_mark(unbiased_prototype);
 253     }
 254   }
 255 







 256   return BiasedLocking::BIAS_REVOKED;
 257 }
 258 
 259 
 260 enum HeuristicsResult {
 261   HR_NOT_BIASED    = 1,
 262   HR_SINGLE_REVOKE = 2,
 263   HR_BULK_REBIAS   = 3,
 264   HR_BULK_REVOKE   = 4
 265 };
 266 
 267 
 268 static HeuristicsResult update_heuristics(oop o, bool allow_rebias) {
 269   markOop mark = o->mark();
 270   if (!mark->has_bias_pattern()) {
 271     return HR_NOT_BIASED;
 272   }
 273 
 274   // Heuristics to attempt to throttle the number of revocations.
 275   // Stages:


 356 
 357       // Now walk all threads' stacks and adjust epochs of any biased
 358       // and locked objects of this data type we encounter
 359       for (JavaThread* thr = Threads::first(); thr != NULL; thr = thr->next()) {
 360         GrowableArray<MonitorInfo*>* cached_monitor_info = get_or_compute_monitor_info(thr);
 361         for (int i = 0; i < cached_monitor_info->length(); i++) {
 362           MonitorInfo* mon_info = cached_monitor_info->at(i);
 363           oop owner = mon_info->owner();
 364           markOop mark = owner->mark();
 365           if ((owner->klass() == k_o) && mark->has_bias_pattern()) {
 366             // We might have encountered this object already in the case of recursive locking
 367             assert(mark->bias_epoch() == prev_epoch || mark->bias_epoch() == cur_epoch, "error in bias epoch adjustment");
 368             owner->set_mark(mark->set_bias_epoch(cur_epoch));
 369           }
 370         }
 371       }
 372     }
 373 
 374     // At this point we're done. All we have to do is potentially
 375     // adjust the header of the given object to revoke its bias.
 376     revoke_bias(o, attempt_rebias_of_object && klass->prototype_header()->has_bias_pattern(), true, requesting_thread);
 377   } else {
 378     if (TraceBiasedLocking) {
 379       ResourceMark rm;
 380       tty->print_cr("* Disabling biased locking for type %s", klass->external_name());
 381     }
 382 
 383     // Disable biased locking for this data type. Not only will this
 384     // cause future instances to not be biased, but existing biased
 385     // instances will notice that this implicitly caused their biases
 386     // to be revoked.
 387     klass->set_prototype_header(markOopDesc::prototype());
 388 
 389     // Now walk all threads' stacks and forcibly revoke the biases of
 390     // any locked and biased objects of this data type we encounter.
 391     for (JavaThread* thr = Threads::first(); thr != NULL; thr = thr->next()) {
 392       GrowableArray<MonitorInfo*>* cached_monitor_info = get_or_compute_monitor_info(thr);
 393       for (int i = 0; i < cached_monitor_info->length(); i++) {
 394         MonitorInfo* mon_info = cached_monitor_info->at(i);
 395         oop owner = mon_info->owner();
 396         markOop mark = owner->mark();
 397         if ((owner->klass() == k_o) && mark->has_bias_pattern()) {
 398           revoke_bias(owner, false, true, requesting_thread);
 399         }
 400       }
 401     }
 402 
 403     // Must force the bias of the passed object to be forcibly revoked
 404     // as well to ensure guarantees to callers
 405     revoke_bias(o, false, true, requesting_thread);
 406   }
 407 
 408   if (TraceBiasedLocking) {
 409     tty->print_cr("* Ending bulk revocation");
 410   }
 411 
 412   BiasedLocking::Condition status_code = BiasedLocking::BIAS_REVOKED;
 413 
 414   if (attempt_rebias_of_object &&
 415       o->mark()->has_bias_pattern() &&
 416       klass->prototype_header()->has_bias_pattern()) {
 417     markOop new_mark = markOopDesc::encode(requesting_thread, o->mark()->age(),
 418                                            klass->prototype_header()->bias_epoch());
 419     o->set_mark(new_mark);
 420     status_code = BiasedLocking::BIAS_REVOKED_AND_REBIASED;
 421     if (TraceBiasedLocking) {
 422       tty->print_cr("  Rebiased object toward thread " INTPTR_FORMAT, (intptr_t) requesting_thread);
 423     }
 424   }
 425 


 428          "bug in bulk bias revocation");
 429 
 430   return status_code;
 431 }
 432 
 433 
 434 static void clean_up_cached_monitor_info() {
 435   // Walk the thread list clearing out the cached monitors
 436   for (JavaThread* thr = Threads::first(); thr != NULL; thr = thr->next()) {
 437     thr->set_cached_monitor_info(NULL);
 438   }
 439 }
 440 
 441 
 442 class VM_RevokeBias : public VM_Operation {
 443 protected:
 444   Handle* _obj;
 445   GrowableArray<Handle>* _objs;
 446   JavaThread* _requesting_thread;
 447   BiasedLocking::Condition _status_code;

 448 
 449 public:
 450   VM_RevokeBias(Handle* obj, JavaThread* requesting_thread)
 451     : _obj(obj)
 452     , _objs(NULL)
 453     , _requesting_thread(requesting_thread)
 454     , _status_code(BiasedLocking::NOT_BIASED) {}

 455 
 456   VM_RevokeBias(GrowableArray<Handle>* objs, JavaThread* requesting_thread)
 457     : _obj(NULL)
 458     , _objs(objs)
 459     , _requesting_thread(requesting_thread)
 460     , _status_code(BiasedLocking::NOT_BIASED) {}

 461 
 462   virtual VMOp_Type type() const { return VMOp_RevokeBias; }
 463 
 464   virtual bool doit_prologue() {
 465     // Verify that there is actual work to do since the callers just
 466     // give us locked object(s). If we don't find any biased objects
 467     // there is nothing to do and we avoid a safepoint.
 468     if (_obj != NULL) {
 469       markOop mark = (*_obj)()->mark();
 470       if (mark->has_bias_pattern()) {
 471         return true;
 472       }
 473     } else {
 474       for ( int i = 0 ; i < _objs->length(); i++ ) {
 475         markOop mark = (_objs->at(i))()->mark();
 476         if (mark->has_bias_pattern()) {
 477           return true;
 478         }
 479       }
 480     }
 481     return false;
 482   }
 483 
 484   virtual void doit() {
 485     if (_obj != NULL) {
 486       if (TraceBiasedLocking) {
 487         tty->print_cr("Revoking bias with potentially per-thread safepoint:");
 488       }
 489       _status_code = revoke_bias((*_obj)(), false, false, _requesting_thread);








 490       clean_up_cached_monitor_info();
 491       return;
 492     } else {
 493       if (TraceBiasedLocking) {
 494         tty->print_cr("Revoking bias with global safepoint:");
 495       }
 496       BiasedLocking::revoke_at_safepoint(_objs);
 497     }
 498   }
 499 
 500   BiasedLocking::Condition status_code() const {
 501     return _status_code;
 502   }




 503 };
 504 
 505 
 506 class VM_BulkRevokeBias : public VM_RevokeBias {
 507 private:
 508   bool _bulk_rebias;
 509   bool _attempt_rebias_of_object;
 510 
 511 public:
 512   VM_BulkRevokeBias(Handle* obj, JavaThread* requesting_thread,
 513                     bool bulk_rebias,
 514                     bool attempt_rebias_of_object)
 515     : VM_RevokeBias(obj, requesting_thread)
 516     , _bulk_rebias(bulk_rebias)
 517     , _attempt_rebias_of_object(attempt_rebias_of_object) {}
 518 
 519   virtual VMOp_Type type() const { return VMOp_BulkRevokeBias; }
 520   virtual bool doit_prologue()   { return true; }
 521 
 522   virtual void doit() {


 592   if (heuristics == HR_NOT_BIASED) {
 593     return NOT_BIASED;
 594   } else if (heuristics == HR_SINGLE_REVOKE) {
 595     Klass *k = obj->klass();
 596     markOop prototype_header = k->prototype_header();
 597     if (mark->biased_locker() == THREAD &&
 598         prototype_header->bias_epoch() == mark->bias_epoch()) {
 599       // A thread is trying to revoke the bias of an object biased
 600       // toward it, again likely due to an identity hash code
 601       // computation. We can again avoid a safepoint in this case
 602       // since we are only going to walk our own stack. There are no
 603       // races with revocations occurring in other threads because we
 604       // reach no safepoints in the revocation path.
 605       // Also check the epoch because even if threads match, another thread
 606       // can come in with a CAS to steal the bias of an object that has a
 607       // stale epoch.
 608       ResourceMark rm;
 609       if (TraceBiasedLocking) {
 610         tty->print_cr("Revoking bias by walking my own stack:");
 611       }
 612       BiasedLocking::Condition cond = revoke_bias(obj(), false, false, (JavaThread*) THREAD);

 613       ((JavaThread*) THREAD)->set_cached_monitor_info(NULL);
 614       assert(cond == BIAS_REVOKED, "why not?");




 615       return cond;
 616     } else {

 617       VM_RevokeBias revoke(&obj, (JavaThread*) THREAD);
 618       VMThread::execute(&revoke);







 619       return revoke.status_code();
 620     }
 621   }
 622 
 623   assert((heuristics == HR_BULK_REVOKE) ||
 624          (heuristics == HR_BULK_REBIAS), "?");

 625   VM_BulkRevokeBias bulk_revoke(&obj, (JavaThread*) THREAD,
 626                                 (heuristics == HR_BULK_REBIAS),
 627                                 attempt_rebias);
 628   VMThread::execute(&bulk_revoke);







 629   return bulk_revoke.status_code();
 630 }
 631 
 632 
 633 void BiasedLocking::revoke(GrowableArray<Handle>* objs) {
 634   assert(!SafepointSynchronize::is_at_safepoint(), "must not be called while at safepoint");
 635   if (objs->length() == 0) {
 636     return;
 637   }
 638   VM_RevokeBias revoke(objs, JavaThread::current());
 639   VMThread::execute(&revoke);
 640 }
 641 
 642 
 643 void BiasedLocking::revoke_at_safepoint(Handle h_obj) {
 644   assert(SafepointSynchronize::is_at_safepoint(), "must only be called while at safepoint");
 645   oop obj = h_obj();
 646   HeuristicsResult heuristics = update_heuristics(obj, false);
 647   if (heuristics == HR_SINGLE_REVOKE) {
 648     revoke_bias(obj, false, false, NULL);
 649   } else if ((heuristics == HR_BULK_REBIAS) ||
 650              (heuristics == HR_BULK_REVOKE)) {
 651     bulk_revoke_or_rebias_at_safepoint(obj, (heuristics == HR_BULK_REBIAS), false, NULL);
 652   }
 653   clean_up_cached_monitor_info();
 654 }
 655 
 656 
 657 void BiasedLocking::revoke_at_safepoint(GrowableArray<Handle>* objs) {
 658   assert(SafepointSynchronize::is_at_safepoint(), "must only be called while at safepoint");
 659   int len = objs->length();
 660   for (int i = 0; i < len; i++) {
 661     oop obj = (objs->at(i))();
 662     HeuristicsResult heuristics = update_heuristics(obj, false);
 663     if (heuristics == HR_SINGLE_REVOKE) {
 664       revoke_bias(obj, false, false, NULL);
 665     } else if ((heuristics == HR_BULK_REBIAS) ||
 666                (heuristics == HR_BULK_REVOKE)) {
 667       bulk_revoke_or_rebias_at_safepoint(obj, (heuristics == HR_BULK_REBIAS), false, NULL);
 668     }
 669   }
 670   clean_up_cached_monitor_info();
 671 }
 672 
 673 
 674 void BiasedLocking::preserve_marks() {
 675   if (!UseBiasedLocking)
 676     return;
 677 
 678   assert(SafepointSynchronize::is_at_safepoint(), "must only be called while at safepoint");
 679 
 680   assert(_preserved_oop_stack  == NULL, "double initialization");
 681   assert(_preserved_mark_stack == NULL, "double initialization");
 682 
 683   // In order to reduce the number of mark words preserved during GC
 684   // due to the presence of biased locking, we reinitialize most mark




  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "oops/klass.inline.hpp"
  27 #include "oops/markOop.hpp"
  28 #include "runtime/basicLock.hpp"
  29 #include "runtime/biasedLocking.hpp"
  30 #include "runtime/task.hpp"
  31 #include "runtime/vframe.hpp"
  32 #include "runtime/vmThread.hpp"
  33 #include "runtime/vm_operations.hpp"
  34 #include "jfr/support/jfrThreadId.hpp"
  35 #include "jfr/jfrEvents.hpp"
  36 
  37 static bool _biased_locking_enabled = false;
  38 BiasedLockingCounters BiasedLocking::_counters;
  39 
  40 static GrowableArray<Handle>*  _preserved_oop_stack  = NULL;
  41 static GrowableArray<markOop>* _preserved_mark_stack = NULL;
  42 
  43 static void enable_biased_locking(Klass* k) {
  44   k->set_prototype_header(markOopDesc::biased_locking_prototype());
  45 }
  46 
  47 class VM_EnableBiasedLocking: public VM_Operation {
  48  private:
  49   bool _is_cheap_allocated;
  50  public:
  51   VM_EnableBiasedLocking(bool is_cheap_allocated) { _is_cheap_allocated = is_cheap_allocated; }
  52   VMOp_Type type() const          { return VMOp_EnableBiasedLocking; }
  53   Mode evaluation_mode() const    { return _is_cheap_allocated ? _async_safepoint : _safepoint; }
  54   bool is_cheap_allocated() const { return _is_cheap_allocated; }
  55 


 127       GrowableArray<MonitorInfo*> *monitors = vf->monitors();
 128       if (monitors != NULL) {
 129         int len = monitors->length();
 130         // Walk monitors youngest to oldest
 131         for (int i = len - 1; i >= 0; i--) {
 132           MonitorInfo* mon_info = monitors->at(i);
 133           if (mon_info->eliminated()) continue;
 134           oop owner = mon_info->owner();
 135           if (owner != NULL) {
 136             info->append(mon_info);
 137           }
 138         }
 139       }
 140     }
 141   }
 142 
 143   thread->set_cached_monitor_info(info);
 144   return info;
 145 }
 146 
 147 // After the call, *biased_locker will be set to obj->mark()->biased_locker() if biased_locker != NULL,
 148 // AND it is a living thread. Otherwise it will not be updated, (i.e. the caller is responsible for initialization).
 149 static BiasedLocking::Condition revoke_bias(oop obj, bool allow_rebias, bool is_bulk, JavaThread* requesting_thread, JavaThread** biased_locker) {
 150   markOop mark = obj->mark();
 151   if (!mark->has_bias_pattern()) {
 152     if (TraceBiasedLocking) {
 153       ResourceMark rm;
 154       tty->print_cr("  (Skipping revocation of object of type %s because it's no longer biased)",
 155                     obj->klass()->external_name());
 156     }
 157     return BiasedLocking::NOT_BIASED;
 158   }
 159 
 160   uint age = mark->age();
 161   markOop   biased_prototype = markOopDesc::biased_locking_prototype()->set_age(age);
 162   markOop unbiased_prototype = markOopDesc::prototype()->set_age(age);
 163 
 164   if (TraceBiasedLocking && (Verbose || !is_bulk)) {
 165     ResourceMark rm;
 166     tty->print_cr("Revoking bias of object " INTPTR_FORMAT " , mark " INTPTR_FORMAT " , type %s , prototype header " INTPTR_FORMAT " , allow rebias %d , requesting thread " INTPTR_FORMAT,
 167                   p2i((void *)obj), (intptr_t) mark, obj->klass()->external_name(), (intptr_t) obj->klass()->prototype_header(), (allow_rebias ? 1 : 0), (intptr_t) requesting_thread);
 168   }
 169 


 239     // Reset object header to point to displaced mark.
 240     // Must release storing the lock address for platforms without TSO
 241     // ordering (e.g. ppc).
 242     obj->release_set_mark(markOopDesc::encode(highest_lock));
 243     assert(!obj->mark()->has_bias_pattern(), "illegal mark state: stack lock used bias bit");
 244     if (TraceBiasedLocking && (Verbose || !is_bulk)) {
 245       tty->print_cr("  Revoked bias of currently-locked object");
 246     }
 247   } else {
 248     if (TraceBiasedLocking && (Verbose || !is_bulk)) {
 249       tty->print_cr("  Revoked bias of currently-unlocked object");
 250     }
 251     if (allow_rebias) {
 252       obj->set_mark(biased_prototype);
 253     } else {
 254       // Store the unlocked value into the object's header.
 255       obj->set_mark(unbiased_prototype);
 256     }
 257   }
 258 
 259 #if INCLUDE_JFR
 260   // If requested, return information on which thread held the bias
 261   if (biased_locker != NULL) {
 262     *biased_locker = biased_thread;
 263   }
 264 #endif // INCLUDE_JFR
 265 
 266   return BiasedLocking::BIAS_REVOKED;
 267 }
 268 
 269 
 270 enum HeuristicsResult {
 271   HR_NOT_BIASED    = 1,
 272   HR_SINGLE_REVOKE = 2,
 273   HR_BULK_REBIAS   = 3,
 274   HR_BULK_REVOKE   = 4
 275 };
 276 
 277 
 278 static HeuristicsResult update_heuristics(oop o, bool allow_rebias) {
 279   markOop mark = o->mark();
 280   if (!mark->has_bias_pattern()) {
 281     return HR_NOT_BIASED;
 282   }
 283 
 284   // Heuristics to attempt to throttle the number of revocations.
 285   // Stages:


 366 
 367       // Now walk all threads' stacks and adjust epochs of any biased
 368       // and locked objects of this data type we encounter
 369       for (JavaThread* thr = Threads::first(); thr != NULL; thr = thr->next()) {
 370         GrowableArray<MonitorInfo*>* cached_monitor_info = get_or_compute_monitor_info(thr);
 371         for (int i = 0; i < cached_monitor_info->length(); i++) {
 372           MonitorInfo* mon_info = cached_monitor_info->at(i);
 373           oop owner = mon_info->owner();
 374           markOop mark = owner->mark();
 375           if ((owner->klass() == k_o) && mark->has_bias_pattern()) {
 376             // We might have encountered this object already in the case of recursive locking
 377             assert(mark->bias_epoch() == prev_epoch || mark->bias_epoch() == cur_epoch, "error in bias epoch adjustment");
 378             owner->set_mark(mark->set_bias_epoch(cur_epoch));
 379           }
 380         }
 381       }
 382     }
 383 
 384     // At this point we're done. All we have to do is potentially
 385     // adjust the header of the given object to revoke its bias.
 386     revoke_bias(o, attempt_rebias_of_object && klass->prototype_header()->has_bias_pattern(), true, requesting_thread, NULL);
 387   } else {
 388     if (TraceBiasedLocking) {
 389       ResourceMark rm;
 390       tty->print_cr("* Disabling biased locking for type %s", klass->external_name());
 391     }
 392 
 393     // Disable biased locking for this data type. Not only will this
 394     // cause future instances to not be biased, but existing biased
 395     // instances will notice that this implicitly caused their biases
 396     // to be revoked.
 397     klass->set_prototype_header(markOopDesc::prototype());
 398 
 399     // Now walk all threads' stacks and forcibly revoke the biases of
 400     // any locked and biased objects of this data type we encounter.
 401     for (JavaThread* thr = Threads::first(); thr != NULL; thr = thr->next()) {
 402       GrowableArray<MonitorInfo*>* cached_monitor_info = get_or_compute_monitor_info(thr);
 403       for (int i = 0; i < cached_monitor_info->length(); i++) {
 404         MonitorInfo* mon_info = cached_monitor_info->at(i);
 405         oop owner = mon_info->owner();
 406         markOop mark = owner->mark();
 407         if ((owner->klass() == k_o) && mark->has_bias_pattern()) {
 408           revoke_bias(owner, false, true, requesting_thread, NULL);
 409         }
 410       }
 411     }
 412 
 413     // Must force the bias of the passed object to be forcibly revoked
 414     // as well to ensure guarantees to callers
 415     revoke_bias(o, false, true, requesting_thread, NULL);
 416   }
 417 
 418   if (TraceBiasedLocking) {
 419     tty->print_cr("* Ending bulk revocation");
 420   }
 421 
 422   BiasedLocking::Condition status_code = BiasedLocking::BIAS_REVOKED;
 423 
 424   if (attempt_rebias_of_object &&
 425       o->mark()->has_bias_pattern() &&
 426       klass->prototype_header()->has_bias_pattern()) {
 427     markOop new_mark = markOopDesc::encode(requesting_thread, o->mark()->age(),
 428                                            klass->prototype_header()->bias_epoch());
 429     o->set_mark(new_mark);
 430     status_code = BiasedLocking::BIAS_REVOKED_AND_REBIASED;
 431     if (TraceBiasedLocking) {
 432       tty->print_cr("  Rebiased object toward thread " INTPTR_FORMAT, (intptr_t) requesting_thread);
 433     }
 434   }
 435 


 438          "bug in bulk bias revocation");
 439 
 440   return status_code;
 441 }
 442 
 443 
 444 static void clean_up_cached_monitor_info() {
 445   // Walk the thread list clearing out the cached monitors
 446   for (JavaThread* thr = Threads::first(); thr != NULL; thr = thr->next()) {
 447     thr->set_cached_monitor_info(NULL);
 448   }
 449 }
 450 
 451 
 452 class VM_RevokeBias : public VM_Operation {
 453 protected:
 454   Handle* _obj;
 455   GrowableArray<Handle>* _objs;
 456   JavaThread* _requesting_thread;
 457   BiasedLocking::Condition _status_code;
 458   traceid _biased_locker_id;
 459 
 460 public:
 461   VM_RevokeBias(Handle* obj, JavaThread* requesting_thread)
 462     : _obj(obj)
 463     , _objs(NULL)
 464     , _requesting_thread(requesting_thread)
 465     , _status_code(BiasedLocking::NOT_BIASED)
 466     , _biased_locker_id(0) {}
 467 
 468   VM_RevokeBias(GrowableArray<Handle>* objs, JavaThread* requesting_thread)
 469     : _obj(NULL)
 470     , _objs(objs)
 471     , _requesting_thread(requesting_thread)
 472     , _status_code(BiasedLocking::NOT_BIASED)
 473     , _biased_locker_id(0) {}
 474 
 475   virtual VMOp_Type type() const { return VMOp_RevokeBias; }
 476 
 477   virtual bool doit_prologue() {
 478     // Verify that there is actual work to do since the callers just
 479     // give us locked object(s). If we don't find any biased objects
 480     // there is nothing to do and we avoid a safepoint.
 481     if (_obj != NULL) {
 482       markOop mark = (*_obj)()->mark();
 483       if (mark->has_bias_pattern()) {
 484         return true;
 485       }
 486     } else {
 487       for ( int i = 0 ; i < _objs->length(); i++ ) {
 488         markOop mark = (_objs->at(i))()->mark();
 489         if (mark->has_bias_pattern()) {
 490           return true;
 491         }
 492       }
 493     }
 494     return false;
 495   }
 496 
 497   virtual void doit() {
 498     if (_obj != NULL) {
 499       if (TraceBiasedLocking) {
 500         tty->print_cr("Revoking bias with potentially per-thread safepoint:");
 501       }
 502 
 503       JavaThread* biased_locker = NULL;
 504       _status_code = revoke_bias((*_obj)(), false, false, _requesting_thread, &biased_locker);
 505 #if INCLUDE_JFR
 506       if (biased_locker != NULL) {
 507         _biased_locker_id = JFR_THREAD_ID(biased_locker);
 508       }
 509 #endif // INCLUDE_JFR
 510 
 511       clean_up_cached_monitor_info();
 512       return;
 513     } else {
 514       if (TraceBiasedLocking) {
 515         tty->print_cr("Revoking bias with global safepoint:");
 516       }
 517       BiasedLocking::revoke_at_safepoint(_objs);
 518     }
 519   }
 520 
 521   BiasedLocking::Condition status_code() const {
 522     return _status_code;
 523   }
 524 
 525   traceid biased_locker() const {
 526     return _biased_locker_id;
 527   }
 528 };
 529 
 530 
 531 class VM_BulkRevokeBias : public VM_RevokeBias {
 532 private:
 533   bool _bulk_rebias;
 534   bool _attempt_rebias_of_object;
 535 
 536 public:
 537   VM_BulkRevokeBias(Handle* obj, JavaThread* requesting_thread,
 538                     bool bulk_rebias,
 539                     bool attempt_rebias_of_object)
 540     : VM_RevokeBias(obj, requesting_thread)
 541     , _bulk_rebias(bulk_rebias)
 542     , _attempt_rebias_of_object(attempt_rebias_of_object) {}
 543 
 544   virtual VMOp_Type type() const { return VMOp_BulkRevokeBias; }
 545   virtual bool doit_prologue()   { return true; }
 546 
 547   virtual void doit() {


 617   if (heuristics == HR_NOT_BIASED) {
 618     return NOT_BIASED;
 619   } else if (heuristics == HR_SINGLE_REVOKE) {
 620     Klass *k = obj->klass();
 621     markOop prototype_header = k->prototype_header();
 622     if (mark->biased_locker() == THREAD &&
 623         prototype_header->bias_epoch() == mark->bias_epoch()) {
 624       // A thread is trying to revoke the bias of an object biased
 625       // toward it, again likely due to an identity hash code
 626       // computation. We can again avoid a safepoint in this case
 627       // since we are only going to walk our own stack. There are no
 628       // races with revocations occurring in other threads because we
 629       // reach no safepoints in the revocation path.
 630       // Also check the epoch because even if threads match, another thread
 631       // can come in with a CAS to steal the bias of an object that has a
 632       // stale epoch.
 633       ResourceMark rm;
 634       if (TraceBiasedLocking) {
 635         tty->print_cr("Revoking bias by walking my own stack:");
 636       }
 637       EventBiasedLockSelfRevocation event;
 638       BiasedLocking::Condition cond = revoke_bias(obj(), false, false, (JavaThread*) THREAD, NULL);
 639       ((JavaThread*) THREAD)->set_cached_monitor_info(NULL);
 640       assert(cond == BIAS_REVOKED, "why not?");
 641       if (event.should_commit()) {
 642         event.set_lockClass(k);
 643         event.commit();
 644       }
 645       return cond;
 646     } else {
 647       EventBiasedLockRevocation event;
 648       VM_RevokeBias revoke(&obj, (JavaThread*) THREAD);
 649       VMThread::execute(&revoke);
 650       if (event.should_commit() && (revoke.status_code() != NOT_BIASED)) {
 651         event.set_lockClass(k);
 652         // Subtract 1 to match the id of events committed inside the safepoint
 653         event.set_safepointId(SafepointSynchronize::safepoint_counter() - 1);
 654         event.set_previousOwner(revoke.biased_locker());
 655         event.commit();
 656       }
 657       return revoke.status_code();
 658     }
 659   }
 660 
 661   assert((heuristics == HR_BULK_REVOKE) ||
 662          (heuristics == HR_BULK_REBIAS), "?");
 663   EventBiasedLockClassRevocation event;
 664   VM_BulkRevokeBias bulk_revoke(&obj, (JavaThread*) THREAD,
 665                                 (heuristics == HR_BULK_REBIAS),
 666                                 attempt_rebias);
 667   VMThread::execute(&bulk_revoke);
 668   if (event.should_commit()) {
 669     event.set_revokedClass(obj->klass());
 670     event.set_disableBiasing((heuristics != HR_BULK_REBIAS));
 671     // Subtract 1 to match the id of events committed inside the safepoint
 672     event.set_safepointId(SafepointSynchronize::safepoint_counter() - 1);
 673     event.commit();
 674   }
 675   return bulk_revoke.status_code();
 676 }
 677 
 678 
 679 void BiasedLocking::revoke(GrowableArray<Handle>* objs) {
 680   assert(!SafepointSynchronize::is_at_safepoint(), "must not be called while at safepoint");
 681   if (objs->length() == 0) {
 682     return;
 683   }
 684   VM_RevokeBias revoke(objs, JavaThread::current());
 685   VMThread::execute(&revoke);
 686 }
 687 
 688 
 689 void BiasedLocking::revoke_at_safepoint(Handle h_obj) {
 690   assert(SafepointSynchronize::is_at_safepoint(), "must only be called while at safepoint");
 691   oop obj = h_obj();
 692   HeuristicsResult heuristics = update_heuristics(obj, false);
 693   if (heuristics == HR_SINGLE_REVOKE) {
 694     revoke_bias(obj, false, false, NULL, NULL);
 695   } else if ((heuristics == HR_BULK_REBIAS) ||
 696              (heuristics == HR_BULK_REVOKE)) {
 697     bulk_revoke_or_rebias_at_safepoint(obj, (heuristics == HR_BULK_REBIAS), false, NULL);
 698   }
 699   clean_up_cached_monitor_info();
 700 }
 701 
 702 
 703 void BiasedLocking::revoke_at_safepoint(GrowableArray<Handle>* objs) {
 704   assert(SafepointSynchronize::is_at_safepoint(), "must only be called while at safepoint");
 705   int len = objs->length();
 706   for (int i = 0; i < len; i++) {
 707     oop obj = (objs->at(i))();
 708     HeuristicsResult heuristics = update_heuristics(obj, false);
 709     if (heuristics == HR_SINGLE_REVOKE) {
 710       revoke_bias(obj, false, false, NULL, NULL);
 711     } else if ((heuristics == HR_BULK_REBIAS) ||
 712                (heuristics == HR_BULK_REVOKE)) {
 713       bulk_revoke_or_rebias_at_safepoint(obj, (heuristics == HR_BULK_REBIAS), false, NULL);
 714     }
 715   }
 716   clean_up_cached_monitor_info();
 717 }
 718 
 719 
 720 void BiasedLocking::preserve_marks() {
 721   if (!UseBiasedLocking)
 722     return;
 723 
 724   assert(SafepointSynchronize::is_at_safepoint(), "must only be called while at safepoint");
 725 
 726   assert(_preserved_oop_stack  == NULL, "double initialization");
 727   assert(_preserved_mark_stack == NULL, "double initialization");
 728 
 729   // In order to reduce the number of mark words preserved during GC
 730   // due to the presence of biased locking, we reinitialize most mark


< prev index next >