< prev index next >

src/share/vm/runtime/biasedLocking.cpp

Print this page
rev 9030 : 8223690: Add JFR BiasedLock Event Support


  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 requested, return information on which thread held the bias
 260   if (biased_locker != NULL) {
 261     *biased_locker = biased_thread;
 262   }
 263 
 264   return BiasedLocking::BIAS_REVOKED;
 265 }
 266 
 267 
 268 enum HeuristicsResult {
 269   HR_NOT_BIASED    = 1,
 270   HR_SINGLE_REVOKE = 2,
 271   HR_BULK_REBIAS   = 3,
 272   HR_BULK_REVOKE   = 4
 273 };
 274 
 275 
 276 static HeuristicsResult update_heuristics(oop o, bool allow_rebias) {
 277   markOop mark = o->mark();
 278   if (!mark->has_bias_pattern()) {
 279     return HR_NOT_BIASED;
 280   }
 281 
 282   // Heuristics to attempt to throttle the number of revocations.
 283   // Stages:


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


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


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


< prev index next >