1 /*
   2  * Copyright (c) 2005, 2014, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  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 
  56   void doit() {
  57     // Iterate the system dictionary enabling biased locking for all
  58     // currently loaded classes
  59     SystemDictionary::classes_do(enable_biased_locking);
  60     // Indicate that future instances should enable it as well
  61     _biased_locking_enabled = true;
  62 
  63     if (TraceBiasedLocking) {
  64       tty->print_cr("Biased locking enabled");
  65     }
  66   }
  67 
  68   bool allow_nested_vm_operations() const        { return false; }
  69 };
  70 
  71 
  72 // One-shot PeriodicTask subclass for enabling biased locking
  73 class EnableBiasedLockingTask : public PeriodicTask {
  74  public:
  75   EnableBiasedLockingTask(size_t interval_time) : PeriodicTask(interval_time) {}
  76 
  77   virtual void task() {
  78     // Use async VM operation to avoid blocking the Watcher thread.
  79     // VM Thread will free C heap storage.
  80     VM_EnableBiasedLocking *op = new VM_EnableBiasedLocking(true);
  81     VMThread::execute(op);
  82 
  83     // Reclaim our storage and disenroll ourself
  84     delete this;
  85   }
  86 };
  87 
  88 
  89 void BiasedLocking::init() {
  90   // If biased locking is enabled, schedule a task to fire a few
  91   // seconds into the run which turns on biased locking for all
  92   // currently loaded classes as well as future ones. This is a
  93   // workaround for startup time regressions due to a large number of
  94   // safepoints being taken during VM startup for bias revocation.
  95   // Ideally we would have a lower cost for individual bias revocation
  96   // and not need a mechanism like this.
  97   if (UseBiasedLocking) {
  98     if (BiasedLockingStartupDelay > 0) {
  99       EnableBiasedLockingTask* task = new EnableBiasedLockingTask(BiasedLockingStartupDelay);
 100       task->enroll();
 101     } else {
 102       VM_EnableBiasedLocking op(false);
 103       VMThread::execute(&op);
 104     }
 105   }
 106 }
 107 
 108 
 109 bool BiasedLocking::enabled() {
 110   return _biased_locking_enabled;
 111 }
 112 
 113 // Returns MonitorInfos for all objects locked on this thread in youngest to oldest order
 114 static GrowableArray<MonitorInfo*>* get_or_compute_monitor_info(JavaThread* thread) {
 115   GrowableArray<MonitorInfo*>* info = thread->cached_monitor_info();
 116   if (info != NULL) {
 117     return info;
 118   }
 119 
 120   info = new GrowableArray<MonitorInfo*>();
 121 
 122   // It's possible for the thread to not have any Java frames on it,
 123   // i.e., if it's the main thread and it's already returned from main()
 124   if (thread->has_last_Java_frame()) {
 125     RegisterMap rm(thread);
 126     for (javaVFrame* vf = thread->last_java_vframe(&rm); vf != NULL; vf = vf->java_sender()) {
 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 
 170   JavaThread* biased_thread = mark->biased_locker();
 171   if (biased_thread == NULL) {
 172     // Object is anonymously biased. We can get here if, for
 173     // example, we revoke the bias due to an identity hash code
 174     // being computed for an object.
 175     if (!allow_rebias) {
 176       obj->set_mark(unbiased_prototype);
 177     }
 178     if (TraceBiasedLocking && (Verbose || !is_bulk)) {
 179       tty->print_cr("  Revoked bias of anonymously-biased object");
 180     }
 181     return BiasedLocking::BIAS_REVOKED;
 182   }
 183 
 184   // Handle case where the thread toward which the object was biased has exited
 185   bool thread_is_alive = false;
 186   if (requesting_thread == biased_thread) {
 187     thread_is_alive = true;
 188   } else {
 189     for (JavaThread* cur_thread = Threads::first(); cur_thread != NULL; cur_thread = cur_thread->next()) {
 190       if (cur_thread == biased_thread) {
 191         thread_is_alive = true;
 192         break;
 193       }
 194     }
 195   }
 196   if (!thread_is_alive) {
 197     if (allow_rebias) {
 198       obj->set_mark(biased_prototype);
 199     } else {
 200       obj->set_mark(unbiased_prototype);
 201     }
 202     if (TraceBiasedLocking && (Verbose || !is_bulk)) {
 203       tty->print_cr("  Revoked bias of object biased toward dead thread");
 204     }
 205     return BiasedLocking::BIAS_REVOKED;
 206   }
 207 
 208   // Thread owning bias is alive.
 209   // Check to see whether it currently owns the lock and, if so,
 210   // write down the needed displaced headers to the thread's stack.
 211   // Otherwise, restore the object's header either to the unlocked
 212   // or unbiased state.
 213   GrowableArray<MonitorInfo*>* cached_monitor_info = get_or_compute_monitor_info(biased_thread);
 214   BasicLock* highest_lock = NULL;
 215   for (int i = 0; i < cached_monitor_info->length(); i++) {
 216     MonitorInfo* mon_info = cached_monitor_info->at(i);
 217     if (mon_info->owner() == obj) {
 218       if (TraceBiasedLocking && Verbose) {
 219         tty->print_cr("   mon_info->owner (" PTR_FORMAT ") == obj (" PTR_FORMAT ")",
 220                       p2i((void *) mon_info->owner()),
 221                       p2i((void *) obj));
 222       }
 223       // Assume recursive case and fix up highest lock later
 224       markOop mark = markOopDesc::encode((BasicLock*) NULL);
 225       highest_lock = mon_info->lock();
 226       highest_lock->set_displaced_header(mark);
 227     } else {
 228       if (TraceBiasedLocking && Verbose) {
 229         tty->print_cr("   mon_info->owner (" PTR_FORMAT ") != obj (" PTR_FORMAT ")",
 230                       p2i((void *) mon_info->owner()),
 231                       p2i((void *) obj));
 232       }
 233     }
 234   }
 235   if (highest_lock != NULL) {
 236     // Fix up highest lock to contain displaced header and point
 237     // object at it
 238     highest_lock->set_displaced_header(unbiased_prototype);
 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:
 284   // 1. Revoke the biases of all objects in the heap of this type,
 285   //    but allow rebiasing of those objects if unlocked.
 286   // 2. Revoke the biases of all objects in the heap of this type
 287   //    and don't allow rebiasing of these objects. Disable
 288   //    allocation of objects of that type with the bias bit set.
 289   Klass* k = o->klass();
 290   jlong cur_time = os::javaTimeMillis();
 291   jlong last_bulk_revocation_time = k->last_biased_lock_bulk_revocation_time();
 292   int revocation_count = k->biased_lock_revocation_count();
 293   if ((revocation_count >= BiasedLockingBulkRebiasThreshold) &&
 294       (revocation_count <  BiasedLockingBulkRevokeThreshold) &&
 295       (last_bulk_revocation_time != 0) &&
 296       (cur_time - last_bulk_revocation_time >= BiasedLockingDecayTime)) {
 297     // This is the first revocation we've seen in a while of an
 298     // object of this type since the last time we performed a bulk
 299     // rebiasing operation. The application is allocating objects in
 300     // bulk which are biased toward a thread and then handing them
 301     // off to another thread. We can cope with this allocation
 302     // pattern via the bulk rebiasing mechanism so we reset the
 303     // klass's revocation count rather than allow it to increase
 304     // monotonically. If we see the need to perform another bulk
 305     // rebias operation later, we will, and if subsequently we see
 306     // many more revocation operations in a short period of time we
 307     // will completely disable biasing for this type.
 308     k->set_biased_lock_revocation_count(0);
 309     revocation_count = 0;
 310   }
 311 
 312   // Make revocation count saturate just beyond BiasedLockingBulkRevokeThreshold
 313   if (revocation_count <= BiasedLockingBulkRevokeThreshold) {
 314     revocation_count = k->atomic_incr_biased_lock_revocation_count();
 315   }
 316 
 317   if (revocation_count == BiasedLockingBulkRevokeThreshold) {
 318     return HR_BULK_REVOKE;
 319   }
 320 
 321   if (revocation_count == BiasedLockingBulkRebiasThreshold) {
 322     return HR_BULK_REBIAS;
 323   }
 324 
 325   return HR_SINGLE_REVOKE;
 326 }
 327 
 328 
 329 static BiasedLocking::Condition bulk_revoke_or_rebias_at_safepoint(oop o,
 330                                                                    bool bulk_rebias,
 331                                                                    bool attempt_rebias_of_object,
 332                                                                    JavaThread* requesting_thread) {
 333   assert(SafepointSynchronize::is_at_safepoint(), "must be done at safepoint");
 334 
 335   if (TraceBiasedLocking) {
 336     tty->print_cr("* Beginning bulk revocation (kind == %s) because of object "
 337                   INTPTR_FORMAT " , mark " INTPTR_FORMAT " , type %s",
 338                   (bulk_rebias ? "rebias" : "revoke"),
 339                   p2i((void *) o), (intptr_t) o->mark(), o->klass()->external_name());
 340   }
 341 
 342   jlong cur_time = os::javaTimeMillis();
 343   o->klass()->set_last_biased_lock_bulk_revocation_time(cur_time);
 344 
 345 
 346   Klass* k_o = o->klass();
 347   Klass* klass = k_o;
 348 
 349   if (bulk_rebias) {
 350     // Use the epoch in the klass of the object to implicitly revoke
 351     // all biases of objects of this data type and force them to be
 352     // reacquired. However, we also need to walk the stacks of all
 353     // threads and update the headers of lightweight locked objects
 354     // with biases to have the current epoch.
 355 
 356     // If the prototype header doesn't have the bias pattern, don't
 357     // try to update the epoch -- assume another VM operation came in
 358     // and reset the header to the unbiased state, which will
 359     // implicitly cause all existing biases to be revoked
 360     if (klass->prototype_header()->has_bias_pattern()) {
 361       int prev_epoch = klass->prototype_header()->bias_epoch();
 362       klass->set_prototype_header(klass->prototype_header()->incr_bias_epoch());
 363       int cur_epoch = klass->prototype_header()->bias_epoch();
 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 
 434   assert(!o->mark()->has_bias_pattern() ||
 435          (attempt_rebias_of_object && (o->mark()->biased_locker() == requesting_thread)),
 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() {
 542     _status_code = bulk_revoke_or_rebias_at_safepoint((*_obj)(), _bulk_rebias, _attempt_rebias_of_object, _requesting_thread);
 543     clean_up_cached_monitor_info();
 544   }
 545 };
 546 
 547 
 548 BiasedLocking::Condition BiasedLocking::revoke_and_rebias(Handle obj, bool attempt_rebias, TRAPS) {
 549   assert(!SafepointSynchronize::is_at_safepoint(), "must not be called while at safepoint");
 550 
 551   // We can revoke the biases of anonymously-biased objects
 552   // efficiently enough that we should not cause these revocations to
 553   // update the heuristics because doing so may cause unwanted bulk
 554   // revocations (which are expensive) to occur.
 555   markOop mark = obj->mark();
 556   if (mark->is_biased_anonymously() && !attempt_rebias) {
 557     // We are probably trying to revoke the bias of this object due to
 558     // an identity hash code computation. Try to revoke the bias
 559     // without a safepoint. This is possible if we can successfully
 560     // compare-and-exchange an unbiased header into the mark word of
 561     // the object, meaning that no other thread has raced to acquire
 562     // the bias of the object.
 563     markOop biased_value       = mark;
 564     markOop unbiased_prototype = markOopDesc::prototype()->set_age(mark->age());
 565     markOop res_mark = (markOop) Atomic::cmpxchg_ptr(unbiased_prototype, obj->mark_addr(), mark);
 566     if (res_mark == biased_value) {
 567       return BIAS_REVOKED;
 568     }
 569   } else if (mark->has_bias_pattern()) {
 570     Klass* k = obj->klass();
 571     markOop prototype_header = k->prototype_header();
 572     if (!prototype_header->has_bias_pattern()) {
 573       // This object has a stale bias from before the bulk revocation
 574       // for this data type occurred. It's pointless to update the
 575       // heuristics at this point so simply update the header with a
 576       // CAS. If we fail this race, the object's bias has been revoked
 577       // by another thread so we simply return and let the caller deal
 578       // with it.
 579       markOop biased_value       = mark;
 580       markOop res_mark = (markOop) Atomic::cmpxchg_ptr(prototype_header, obj->mark_addr(), mark);
 581       assert(!(*(obj->mark_addr()))->has_bias_pattern(), "even if we raced, should still be revoked");
 582       return BIAS_REVOKED;
 583     } else if (prototype_header->bias_epoch() != mark->bias_epoch()) {
 584       // The epoch of this biasing has expired indicating that the
 585       // object is effectively unbiased. Depending on whether we need
 586       // to rebias or revoke the bias of this object we can do it
 587       // efficiently enough with a CAS that we shouldn't update the
 588       // heuristics. This is normally done in the assembly code but we
 589       // can reach this point due to various points in the runtime
 590       // needing to revoke biases.
 591       if (attempt_rebias) {
 592         assert(THREAD->is_Java_thread(), "");
 593         markOop biased_value       = mark;
 594         markOop rebiased_prototype = markOopDesc::encode((JavaThread*) THREAD, mark->age(), prototype_header->bias_epoch());
 595         markOop res_mark = (markOop) Atomic::cmpxchg_ptr(rebiased_prototype, obj->mark_addr(), mark);
 596         if (res_mark == biased_value) {
 597           return BIAS_REVOKED_AND_REBIASED;
 598         }
 599       } else {
 600         markOop biased_value       = mark;
 601         markOop unbiased_prototype = markOopDesc::prototype()->set_age(mark->age());
 602         markOop res_mark = (markOop) Atomic::cmpxchg_ptr(unbiased_prototype, obj->mark_addr(), mark);
 603         if (res_mark == biased_value) {
 604           return BIAS_REVOKED;
 605         }
 606       }
 607     }
 608   }
 609 
 610   HeuristicsResult heuristics = update_heuristics(obj(), attempt_rebias);
 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
 725   // words to the class's prototype during GC -- even those which have
 726   // a currently valid bias owner. One important situation where we
 727   // must not clobber a bias is when a biased object is currently
 728   // locked. To handle this case we iterate over the currently-locked
 729   // monitors in a prepass and, if they are biased, preserve their
 730   // mark words here. This should be a relatively small set of objects
 731   // especially compared to the number of objects in the heap.
 732   _preserved_mark_stack = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<markOop>(10, true);
 733   _preserved_oop_stack = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<Handle>(10, true);
 734 
 735   ResourceMark rm;
 736   Thread* cur = Thread::current();
 737   for (JavaThread* thread = Threads::first(); thread != NULL; thread = thread->next()) {
 738     if (thread->has_last_Java_frame()) {
 739       RegisterMap rm(thread);
 740       for (javaVFrame* vf = thread->last_java_vframe(&rm); vf != NULL; vf = vf->java_sender()) {
 741         GrowableArray<MonitorInfo*> *monitors = vf->monitors();
 742         if (monitors != NULL) {
 743           int len = monitors->length();
 744           // Walk monitors youngest to oldest
 745           for (int i = len - 1; i >= 0; i--) {
 746             MonitorInfo* mon_info = monitors->at(i);
 747             if (mon_info->owner_is_scalar_replaced()) continue;
 748             oop owner = mon_info->owner();
 749             if (owner != NULL) {
 750               markOop mark = owner->mark();
 751               if (mark->has_bias_pattern()) {
 752                 _preserved_oop_stack->push(Handle(cur, owner));
 753                 _preserved_mark_stack->push(mark);
 754               }
 755             }
 756           }
 757         }
 758       }
 759     }
 760   }
 761 }
 762 
 763 
 764 void BiasedLocking::restore_marks() {
 765   if (!UseBiasedLocking)
 766     return;
 767 
 768   assert(_preserved_oop_stack  != NULL, "double free");
 769   assert(_preserved_mark_stack != NULL, "double free");
 770 
 771   int len = _preserved_oop_stack->length();
 772   for (int i = 0; i < len; i++) {
 773     Handle owner = _preserved_oop_stack->at(i);
 774     markOop mark = _preserved_mark_stack->at(i);
 775     owner->set_mark(mark);
 776   }
 777 
 778   delete _preserved_oop_stack;
 779   _preserved_oop_stack = NULL;
 780   delete _preserved_mark_stack;
 781   _preserved_mark_stack = NULL;
 782 }
 783 
 784 
 785 int* BiasedLocking::total_entry_count_addr()                   { return _counters.total_entry_count_addr(); }
 786 int* BiasedLocking::biased_lock_entry_count_addr()             { return _counters.biased_lock_entry_count_addr(); }
 787 int* BiasedLocking::anonymously_biased_lock_entry_count_addr() { return _counters.anonymously_biased_lock_entry_count_addr(); }
 788 int* BiasedLocking::rebiased_lock_entry_count_addr()           { return _counters.rebiased_lock_entry_count_addr(); }
 789 int* BiasedLocking::revoked_lock_entry_count_addr()            { return _counters.revoked_lock_entry_count_addr(); }
 790 int* BiasedLocking::fast_path_entry_count_addr()               { return _counters.fast_path_entry_count_addr(); }
 791 int* BiasedLocking::slow_path_entry_count_addr()               { return _counters.slow_path_entry_count_addr(); }
 792 
 793 
 794 // BiasedLockingCounters
 795 
 796 int BiasedLockingCounters::slow_path_entry_count() {
 797   if (_slow_path_entry_count != 0) {
 798     return _slow_path_entry_count;
 799   }
 800   int sum = _biased_lock_entry_count   + _anonymously_biased_lock_entry_count +
 801             _rebiased_lock_entry_count + _revoked_lock_entry_count +
 802             _fast_path_entry_count;
 803 
 804   return _total_entry_count - sum;
 805 }
 806 
 807 void BiasedLockingCounters::print_on(outputStream* st) {
 808   tty->print_cr("# total entries: %d", _total_entry_count);
 809   tty->print_cr("# biased lock entries: %d", _biased_lock_entry_count);
 810   tty->print_cr("# anonymously biased lock entries: %d", _anonymously_biased_lock_entry_count);
 811   tty->print_cr("# rebiased lock entries: %d", _rebiased_lock_entry_count);
 812   tty->print_cr("# revoked lock entries: %d", _revoked_lock_entry_count);
 813   tty->print_cr("# fast path lock entries: %d", _fast_path_entry_count);
 814   tty->print_cr("# slow path lock entries: %d", slow_path_entry_count());
 815 }