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/atomic.inline.hpp"
  29 #include "runtime/basicLock.hpp"
  30 #include "runtime/biasedLocking.hpp"
  31 #include "runtime/task.hpp"
  32 #include "runtime/vframe.hpp"
  33 #include "runtime/vmThread.hpp"
  34 #include "runtime/vm_operations.hpp"
  35 
  36 static bool _biased_locking_enabled = false;
  37 BiasedLockingCounters BiasedLocking::_counters;
  38 
  39 static GrowableArray<Handle>*  _preserved_oop_stack  = NULL;
  40 static GrowableArray<markOop>* _preserved_mark_stack = NULL;
  41 
  42 static void enable_biased_locking(Klass* k) {
  43   k->set_prototype_header(markOopDesc::biased_locking_prototype());
  44 }
  45 
  46 class VM_EnableBiasedLocking: public VM_Operation {
  47  private:
  48   bool _is_cheap_allocated;
  49  public:
  50   VM_EnableBiasedLocking(bool is_cheap_allocated) { _is_cheap_allocated = is_cheap_allocated; }
  51   VMOp_Type type() const          { return VMOp_EnableBiasedLocking; }
  52   Mode evaluation_mode() const    { return _is_cheap_allocated ? _async_safepoint : _safepoint; }
  53   bool is_cheap_allocated() const { return _is_cheap_allocated; }
  54 
  55   void doit() {
  56     // Iterate the system dictionary enabling biased locking for all
  57     // currently loaded classes
  58     SystemDictionary::classes_do(enable_biased_locking);
  59     // Indicate that future instances should enable it as well
  60     _biased_locking_enabled = true;
  61 
  62     if (TraceBiasedLocking) {
  63       tty->print_cr("Biased locking enabled");
  64     }
  65   }
  66 
  67   bool allow_nested_vm_operations() const        { return false; }
  68 };
  69 
  70 
  71 // One-shot PeriodicTask subclass for enabling biased locking
  72 class EnableBiasedLockingTask : public PeriodicTask {
  73  public:
  74   EnableBiasedLockingTask(size_t interval_time) : PeriodicTask(interval_time) {}
  75 
  76   virtual void task() {
  77     // Use async VM operation to avoid blocking the Watcher thread.
  78     // VM Thread will free C heap storage.
  79     VM_EnableBiasedLocking *op = new VM_EnableBiasedLocking(true);
  80     VMThread::execute(op);
  81 
  82     // Reclaim our storage and disenroll ourself
  83     delete this;
  84   }
  85 };
  86 
  87 
  88 void BiasedLocking::init() {
  89   // If biased locking is enabled, schedule a task to fire a few
  90   // seconds into the run which turns on biased locking for all
  91   // currently loaded classes as well as future ones. This is a
  92   // workaround for startup time regressions due to a large number of
  93   // safepoints being taken during VM startup for bias revocation.
  94   // Ideally we would have a lower cost for individual bias revocation
  95   // and not need a mechanism like this.
  96   if (UseBiasedLocking) {
  97     if (BiasedLockingStartupDelay > 0) {
  98       EnableBiasedLockingTask* task = new EnableBiasedLockingTask(BiasedLockingStartupDelay);
  99       task->enroll();
 100     } else {
 101       VM_EnableBiasedLocking op(false);
 102       VMThread::execute(&op);
 103     }
 104   }
 105 }
 106 
 107 
 108 bool BiasedLocking::enabled() {
 109   return _biased_locking_enabled;
 110 }
 111 
 112 // Returns MonitorInfos for all objects locked on this thread in youngest to oldest order
 113 static GrowableArray<MonitorInfo*>* get_or_compute_monitor_info(JavaThread* thread) {
 114   GrowableArray<MonitorInfo*>* info = thread->cached_monitor_info();
 115   if (info != NULL) {
 116     return info;
 117   }
 118 
 119   info = new GrowableArray<MonitorInfo*>();
 120 
 121   // It's possible for the thread to not have any Java frames on it,
 122   // i.e., if it's the main thread and it's already returned from main()
 123   if (thread->has_last_Java_frame()) {
 124     RegisterMap rm(thread);
 125     for (javaVFrame* vf = thread->last_java_vframe(&rm); vf != NULL; vf = vf->java_sender()) {
 126       GrowableArray<MonitorInfo*> *monitors = vf->monitors();
 127       if (monitors != NULL) {
 128         int len = monitors->length();
 129         // Walk monitors youngest to oldest
 130         for (int i = len - 1; i >= 0; i--) {
 131           MonitorInfo* mon_info = monitors->at(i);
 132           if (mon_info->eliminated()) continue;
 133           oop owner = mon_info->owner();
 134           if (owner != NULL) {
 135             info->append(mon_info);
 136           }
 137         }
 138       }
 139     }
 140   }
 141 
 142   thread->set_cached_monitor_info(info);
 143   return info;
 144 }
 145 
 146 
 147 static BiasedLocking::Condition revoke_bias(oop obj, bool allow_rebias, bool is_bulk, JavaThread* requesting_thread) {
 148   markOop mark = obj->mark();
 149   if (!mark->has_bias_pattern()) {
 150     if (TraceBiasedLocking) {
 151       ResourceMark rm;
 152       tty->print_cr("  (Skipping revocation of object of type %s because it's no longer biased)",
 153                     obj->klass()->external_name());
 154     }
 155     return BiasedLocking::NOT_BIASED;
 156   }
 157 
 158   uint age = mark->age();
 159   markOop   biased_prototype = markOopDesc::biased_locking_prototype()->set_age(age);
 160   markOop unbiased_prototype = markOopDesc::prototype()->set_age(age);
 161 
 162   if (TraceBiasedLocking && (Verbose || !is_bulk)) {
 163     ResourceMark rm;
 164     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,
 165                   p2i((void *)obj), (intptr_t) mark, obj->klass()->external_name(), (intptr_t) obj->klass()->prototype_header(), (allow_rebias ? 1 : 0), (intptr_t) requesting_thread);
 166   }
 167 
 168   JavaThread* biased_thread = mark->biased_locker();
 169   if (biased_thread == NULL) {
 170     // Object is anonymously biased. We can get here if, for
 171     // example, we revoke the bias due to an identity hash code
 172     // being computed for an object.
 173     if (!allow_rebias) {
 174       obj->set_mark(unbiased_prototype);
 175     }
 176     if (TraceBiasedLocking && (Verbose || !is_bulk)) {
 177       tty->print_cr("  Revoked bias of anonymously-biased object");
 178     }
 179     return BiasedLocking::BIAS_REVOKED;
 180   }
 181 
 182   // Handle case where the thread toward which the object was biased has exited
 183   bool thread_is_alive = false;
 184   if (requesting_thread == biased_thread) {
 185     thread_is_alive = true;
 186   } else {
 187     for (JavaThread* cur_thread = Threads::first(); cur_thread != NULL; cur_thread = cur_thread->next()) {
 188       if (cur_thread == biased_thread) {
 189         thread_is_alive = true;
 190         break;
 191       }
 192     }
 193   }
 194   if (!thread_is_alive) {
 195     if (allow_rebias) {
 196       obj->set_mark(biased_prototype);
 197     } else {
 198       obj->set_mark(unbiased_prototype);
 199     }
 200     if (TraceBiasedLocking && (Verbose || !is_bulk)) {
 201       tty->print_cr("  Revoked bias of object biased toward dead thread");
 202     }
 203     return BiasedLocking::BIAS_REVOKED;
 204   }
 205 
 206   // Thread owning bias is alive.
 207   // Check to see whether it currently owns the lock and, if so,
 208   // write down the needed displaced headers to the thread's stack.
 209   // Otherwise, restore the object's header either to the unlocked
 210   // or unbiased state.
 211   GrowableArray<MonitorInfo*>* cached_monitor_info = get_or_compute_monitor_info(biased_thread);
 212   BasicLock* highest_lock = NULL;
 213   for (int i = 0; i < cached_monitor_info->length(); i++) {
 214     MonitorInfo* mon_info = cached_monitor_info->at(i);
 215     if (mon_info->owner() == obj) {
 216       if (TraceBiasedLocking && Verbose) {
 217         tty->print_cr("   mon_info->owner (" PTR_FORMAT ") == obj (" PTR_FORMAT ")",
 218                       p2i((void *) mon_info->owner()),
 219                       p2i((void *) obj));
 220       }
 221       // Assume recursive case and fix up highest lock later
 222       markOop mark = markOopDesc::encode((BasicLock*) NULL);
 223       highest_lock = mon_info->lock();
 224       highest_lock->set_displaced_header(mark);
 225     } else {
 226       if (TraceBiasedLocking && Verbose) {
 227         tty->print_cr("   mon_info->owner (" PTR_FORMAT ") != obj (" PTR_FORMAT ")",
 228                       p2i((void *) mon_info->owner()),
 229                       p2i((void *) obj));
 230       }
 231     }
 232   }
 233   if (highest_lock != NULL) {
 234     // Fix up highest lock to contain displaced header and point
 235     // object at it
 236     highest_lock->set_displaced_header(unbiased_prototype);
 237     // Reset object header to point to displaced mark.
 238     // Must release storing the lock address for platforms without TSO
 239     // ordering (e.g. ppc).
 240     obj->release_set_mark(markOopDesc::encode(highest_lock));
 241     assert(!obj->mark()->has_bias_pattern(), "illegal mark state: stack lock used bias bit");
 242     if (TraceBiasedLocking && (Verbose || !is_bulk)) {
 243       tty->print_cr("  Revoked bias of currently-locked object");
 244     }
 245   } else {
 246     if (TraceBiasedLocking && (Verbose || !is_bulk)) {
 247       tty->print_cr("  Revoked bias of currently-unlocked object");
 248     }
 249     if (allow_rebias) {
 250       obj->set_mark(biased_prototype);
 251     } else {
 252       // Store the unlocked value into the object's header.
 253       obj->set_mark(unbiased_prototype);
 254     }
 255   }
 256 
 257   return BiasedLocking::BIAS_REVOKED;
 258 }
 259 
 260 
 261 enum HeuristicsResult {
 262   HR_NOT_BIASED    = 1,
 263   HR_SINGLE_REVOKE = 2,
 264   HR_BULK_REBIAS   = 3,
 265   HR_BULK_REVOKE   = 4
 266 };
 267 
 268 
 269 static HeuristicsResult update_heuristics(oop o, bool allow_rebias) {
 270   markOop mark = o->mark();
 271   if (!mark->has_bias_pattern()) {
 272     return HR_NOT_BIASED;
 273   }
 274 
 275   // Heuristics to attempt to throttle the number of revocations.
 276   // Stages:
 277   // 1. Revoke the biases of all objects in the heap of this type,
 278   //    but allow rebiasing of those objects if unlocked.
 279   // 2. Revoke the biases of all objects in the heap of this type
 280   //    and don't allow rebiasing of these objects. Disable
 281   //    allocation of objects of that type with the bias bit set.
 282   Klass* k = o->klass();
 283   jlong cur_time = os::javaTimeMillis();
 284   jlong last_bulk_revocation_time = k->last_biased_lock_bulk_revocation_time();
 285   int revocation_count = k->biased_lock_revocation_count();
 286   if ((revocation_count >= BiasedLockingBulkRebiasThreshold) &&
 287       (revocation_count <  BiasedLockingBulkRevokeThreshold) &&
 288       (last_bulk_revocation_time != 0) &&
 289       (cur_time - last_bulk_revocation_time >= BiasedLockingDecayTime)) {
 290     // This is the first revocation we've seen in a while of an
 291     // object of this type since the last time we performed a bulk
 292     // rebiasing operation. The application is allocating objects in
 293     // bulk which are biased toward a thread and then handing them
 294     // off to another thread. We can cope with this allocation
 295     // pattern via the bulk rebiasing mechanism so we reset the
 296     // klass's revocation count rather than allow it to increase
 297     // monotonically. If we see the need to perform another bulk
 298     // rebias operation later, we will, and if subsequently we see
 299     // many more revocation operations in a short period of time we
 300     // will completely disable biasing for this type.
 301     k->set_biased_lock_revocation_count(0);
 302     revocation_count = 0;
 303   }
 304 
 305   // Make revocation count saturate just beyond BiasedLockingBulkRevokeThreshold
 306   if (revocation_count <= BiasedLockingBulkRevokeThreshold) {
 307     revocation_count = k->atomic_incr_biased_lock_revocation_count();
 308   }
 309 
 310   if (revocation_count == BiasedLockingBulkRevokeThreshold) {
 311     return HR_BULK_REVOKE;
 312   }
 313 
 314   if (revocation_count == BiasedLockingBulkRebiasThreshold) {
 315     return HR_BULK_REBIAS;
 316   }
 317 
 318   return HR_SINGLE_REVOKE;
 319 }
 320 
 321 
 322 static BiasedLocking::Condition bulk_revoke_or_rebias_at_safepoint(oop o,
 323                                                                    bool bulk_rebias,
 324                                                                    bool attempt_rebias_of_object,
 325                                                                    JavaThread* requesting_thread) {
 326   assert(SafepointSynchronize::is_at_safepoint(), "must be done at safepoint");
 327 
 328   if (TraceBiasedLocking) {
 329     tty->print_cr("* Beginning bulk revocation (kind == %s) because of object "
 330                   INTPTR_FORMAT " , mark " INTPTR_FORMAT " , type %s",
 331                   (bulk_rebias ? "rebias" : "revoke"),
 332                   p2i((void *) o), (intptr_t) o->mark(), o->klass()->external_name());
 333   }
 334 
 335   jlong cur_time = os::javaTimeMillis();
 336   o->klass()->set_last_biased_lock_bulk_revocation_time(cur_time);
 337 
 338 
 339   Klass* k_o = o->klass();
 340   Klass* klass = k_o;
 341 
 342   if (bulk_rebias) {
 343     // Use the epoch in the klass of the object to implicitly revoke
 344     // all biases of objects of this data type and force them to be
 345     // reacquired. However, we also need to walk the stacks of all
 346     // threads and update the headers of lightweight locked objects
 347     // with biases to have the current epoch.
 348 
 349     // If the prototype header doesn't have the bias pattern, don't
 350     // try to update the epoch -- assume another VM operation came in
 351     // and reset the header to the unbiased state, which will
 352     // implicitly cause all existing biases to be revoked
 353     if (klass->prototype_header()->has_bias_pattern()) {
 354       int prev_epoch = klass->prototype_header()->bias_epoch();
 355       klass->set_prototype_header(klass->prototype_header()->incr_bias_epoch());
 356       int cur_epoch = klass->prototype_header()->bias_epoch();
 357 
 358       // Now walk all threads' stacks and adjust epochs of any biased
 359       // and locked objects of this data type we encounter
 360       for (JavaThread* thr = Threads::first(); thr != NULL; thr = thr->next()) {
 361         GrowableArray<MonitorInfo*>* cached_monitor_info = get_or_compute_monitor_info(thr);
 362         for (int i = 0; i < cached_monitor_info->length(); i++) {
 363           MonitorInfo* mon_info = cached_monitor_info->at(i);
 364           oop owner = mon_info->owner();
 365           markOop mark = owner->mark();
 366           if ((owner->klass() == k_o) && mark->has_bias_pattern()) {
 367             // We might have encountered this object already in the case of recursive locking
 368             assert(mark->bias_epoch() == prev_epoch || mark->bias_epoch() == cur_epoch, "error in bias epoch adjustment");
 369             owner->set_mark(mark->set_bias_epoch(cur_epoch));
 370           }
 371         }
 372       }
 373     }
 374 
 375     // At this point we're done. All we have to do is potentially
 376     // adjust the header of the given object to revoke its bias.
 377     revoke_bias(o, attempt_rebias_of_object && klass->prototype_header()->has_bias_pattern(), true, requesting_thread);
 378   } else {
 379     if (TraceBiasedLocking) {
 380       ResourceMark rm;
 381       tty->print_cr("* Disabling biased locking for type %s", klass->external_name());
 382     }
 383 
 384     // Disable biased locking for this data type. Not only will this
 385     // cause future instances to not be biased, but existing biased
 386     // instances will notice that this implicitly caused their biases
 387     // to be revoked.
 388     klass->set_prototype_header(markOopDesc::prototype());
 389 
 390     // Now walk all threads' stacks and forcibly revoke the biases of
 391     // any locked and biased objects of this data type we encounter.
 392     for (JavaThread* thr = Threads::first(); thr != NULL; thr = thr->next()) {
 393       GrowableArray<MonitorInfo*>* cached_monitor_info = get_or_compute_monitor_info(thr);
 394       for (int i = 0; i < cached_monitor_info->length(); i++) {
 395         MonitorInfo* mon_info = cached_monitor_info->at(i);
 396         oop owner = mon_info->owner();
 397         markOop mark = owner->mark();
 398         if ((owner->klass() == k_o) && mark->has_bias_pattern()) {
 399           revoke_bias(owner, false, true, requesting_thread);
 400         }
 401       }
 402     }
 403 
 404     // Must force the bias of the passed object to be forcibly revoked
 405     // as well to ensure guarantees to callers
 406     revoke_bias(o, false, true, requesting_thread);
 407   }
 408 
 409   if (TraceBiasedLocking) {
 410     tty->print_cr("* Ending bulk revocation");
 411   }
 412 
 413   BiasedLocking::Condition status_code = BiasedLocking::BIAS_REVOKED;
 414 
 415   if (attempt_rebias_of_object &&
 416       o->mark()->has_bias_pattern() &&
 417       klass->prototype_header()->has_bias_pattern()) {
 418     markOop new_mark = markOopDesc::encode(requesting_thread, o->mark()->age(),
 419                                            klass->prototype_header()->bias_epoch());
 420     o->set_mark(new_mark);
 421     status_code = BiasedLocking::BIAS_REVOKED_AND_REBIASED;
 422     if (TraceBiasedLocking) {
 423       tty->print_cr("  Rebiased object toward thread " INTPTR_FORMAT, (intptr_t) requesting_thread);
 424     }
 425   }
 426 
 427   assert(!o->mark()->has_bias_pattern() ||
 428          (attempt_rebias_of_object && (o->mark()->biased_locker() == requesting_thread)),
 429          "bug in bulk bias revocation");
 430 
 431   return status_code;
 432 }
 433 
 434 
 435 static void clean_up_cached_monitor_info() {
 436   // Walk the thread list clearing out the cached monitors
 437   for (JavaThread* thr = Threads::first(); thr != NULL; thr = thr->next()) {
 438     thr->set_cached_monitor_info(NULL);
 439   }
 440 }
 441 
 442 
 443 class VM_RevokeBias : public VM_Operation {
 444 protected:
 445   Handle* _obj;
 446   GrowableArray<Handle>* _objs;
 447   JavaThread* _requesting_thread;
 448   BiasedLocking::Condition _status_code;
 449 
 450 public:
 451   VM_RevokeBias(Handle* obj, JavaThread* requesting_thread)
 452     : _obj(obj)
 453     , _objs(NULL)
 454     , _requesting_thread(requesting_thread)
 455     , _status_code(BiasedLocking::NOT_BIASED) {}
 456 
 457   VM_RevokeBias(GrowableArray<Handle>* objs, JavaThread* requesting_thread)
 458     : _obj(NULL)
 459     , _objs(objs)
 460     , _requesting_thread(requesting_thread)
 461     , _status_code(BiasedLocking::NOT_BIASED) {}
 462 
 463   virtual VMOp_Type type() const { return VMOp_RevokeBias; }
 464 
 465   virtual bool doit_prologue() {
 466     // Verify that there is actual work to do since the callers just
 467     // give us locked object(s). If we don't find any biased objects
 468     // there is nothing to do and we avoid a safepoint.
 469     if (_obj != NULL) {
 470       markOop mark = (*_obj)()->mark();
 471       if (mark->has_bias_pattern()) {
 472         return true;
 473       }
 474     } else {
 475       for ( int i = 0 ; i < _objs->length(); i++ ) {
 476         markOop mark = (_objs->at(i))()->mark();
 477         if (mark->has_bias_pattern()) {
 478           return true;
 479         }
 480       }
 481     }
 482     return false;
 483   }
 484 
 485   virtual void doit() {
 486     if (_obj != NULL) {
 487       if (TraceBiasedLocking) {
 488         tty->print_cr("Revoking bias with potentially per-thread safepoint:");
 489       }
 490       _status_code = revoke_bias((*_obj)(), false, false, _requesting_thread);
 491       clean_up_cached_monitor_info();
 492       return;
 493     } else {
 494       if (TraceBiasedLocking) {
 495         tty->print_cr("Revoking bias with global safepoint:");
 496       }
 497       BiasedLocking::revoke_at_safepoint(_objs);
 498     }
 499   }
 500 
 501   BiasedLocking::Condition status_code() const {
 502     return _status_code;
 503   }
 504 };
 505 
 506 
 507 class VM_BulkRevokeBias : public VM_RevokeBias {
 508 private:
 509   bool _bulk_rebias;
 510   bool _attempt_rebias_of_object;
 511 
 512 public:
 513   VM_BulkRevokeBias(Handle* obj, JavaThread* requesting_thread,
 514                     bool bulk_rebias,
 515                     bool attempt_rebias_of_object)
 516     : VM_RevokeBias(obj, requesting_thread)
 517     , _bulk_rebias(bulk_rebias)
 518     , _attempt_rebias_of_object(attempt_rebias_of_object) {}
 519 
 520   virtual VMOp_Type type() const { return VMOp_BulkRevokeBias; }
 521   virtual bool doit_prologue()   { return true; }
 522 
 523   virtual void doit() {
 524     _status_code = bulk_revoke_or_rebias_at_safepoint((*_obj)(), _bulk_rebias, _attempt_rebias_of_object, _requesting_thread);
 525     clean_up_cached_monitor_info();
 526   }
 527 };
 528 
 529 
 530 BiasedLocking::Condition BiasedLocking::revoke_and_rebias(Handle obj, bool attempt_rebias, TRAPS) {
 531   assert(!SafepointSynchronize::is_at_safepoint(), "must not be called while at safepoint");
 532 
 533   // We can revoke the biases of anonymously-biased objects
 534   // efficiently enough that we should not cause these revocations to
 535   // update the heuristics because doing so may cause unwanted bulk
 536   // revocations (which are expensive) to occur.
 537   markOop mark = obj->mark();
 538   if (mark->is_biased_anonymously() && !attempt_rebias) {
 539     // We are probably trying to revoke the bias of this object due to
 540     // an identity hash code computation. Try to revoke the bias
 541     // without a safepoint. This is possible if we can successfully
 542     // compare-and-exchange an unbiased header into the mark word of
 543     // the object, meaning that no other thread has raced to acquire
 544     // the bias of the object.
 545     markOop biased_value       = mark;
 546     markOop unbiased_prototype = markOopDesc::prototype()->set_age(mark->age());
 547     markOop res_mark = (markOop) Atomic::cmpxchg_ptr(unbiased_prototype, obj->mark_addr(), mark);
 548     if (res_mark == biased_value) {
 549       return BIAS_REVOKED;
 550     }
 551   } else if (mark->has_bias_pattern()) {
 552     Klass* k = obj->klass();
 553     markOop prototype_header = k->prototype_header();
 554     if (!prototype_header->has_bias_pattern()) {
 555       // This object has a stale bias from before the bulk revocation
 556       // for this data type occurred. It's pointless to update the
 557       // heuristics at this point so simply update the header with a
 558       // CAS. If we fail this race, the object's bias has been revoked
 559       // by another thread so we simply return and let the caller deal
 560       // with it.
 561       markOop biased_value       = mark;
 562       markOop res_mark = (markOop) Atomic::cmpxchg_ptr(prototype_header, obj->mark_addr(), mark);
 563       assert(!(*(obj->mark_addr()))->has_bias_pattern(), "even if we raced, should still be revoked");
 564       return BIAS_REVOKED;
 565     } else if (prototype_header->bias_epoch() != mark->bias_epoch()) {
 566       // The epoch of this biasing has expired indicating that the
 567       // object is effectively unbiased. Depending on whether we need
 568       // to rebias or revoke the bias of this object we can do it
 569       // efficiently enough with a CAS that we shouldn't update the
 570       // heuristics. This is normally done in the assembly code but we
 571       // can reach this point due to various points in the runtime
 572       // needing to revoke biases.
 573       if (attempt_rebias) {
 574         assert(THREAD->is_Java_thread(), "");
 575         markOop biased_value       = mark;
 576         markOop rebiased_prototype = markOopDesc::encode((JavaThread*) THREAD, mark->age(), prototype_header->bias_epoch());
 577         markOop res_mark = (markOop) Atomic::cmpxchg_ptr(rebiased_prototype, obj->mark_addr(), mark);
 578         if (res_mark == biased_value) {
 579           return BIAS_REVOKED_AND_REBIASED;
 580         }
 581       } else {
 582         markOop biased_value       = mark;
 583         markOop unbiased_prototype = markOopDesc::prototype()->set_age(mark->age());
 584         markOop res_mark = (markOop) Atomic::cmpxchg_ptr(unbiased_prototype, obj->mark_addr(), mark);
 585         if (res_mark == biased_value) {
 586           return BIAS_REVOKED;
 587         }
 588       }
 589     }
 590   }
 591 
 592   HeuristicsResult heuristics = update_heuristics(obj(), attempt_rebias);
 593   if (heuristics == HR_NOT_BIASED) {
 594     return NOT_BIASED;
 595   } else if (heuristics == HR_SINGLE_REVOKE) {
 596     Klass *k = obj->klass();
 597     markOop prototype_header = k->prototype_header();
 598     if (mark->biased_locker() == THREAD &&
 599         prototype_header->bias_epoch() == mark->bias_epoch()) {
 600       // A thread is trying to revoke the bias of an object biased
 601       // toward it, again likely due to an identity hash code
 602       // computation. We can again avoid a safepoint in this case
 603       // since we are only going to walk our own stack. There are no
 604       // races with revocations occurring in other threads because we
 605       // reach no safepoints in the revocation path.
 606       // Also check the epoch because even if threads match, another thread
 607       // can come in with a CAS to steal the bias of an object that has a
 608       // stale epoch.
 609       ResourceMark rm;
 610       if (TraceBiasedLocking) {
 611         tty->print_cr("Revoking bias by walking my own stack:");
 612       }
 613       BiasedLocking::Condition cond = revoke_bias(obj(), false, false, (JavaThread*) THREAD);
 614       ((JavaThread*) THREAD)->set_cached_monitor_info(NULL);
 615       assert(cond == BIAS_REVOKED, "why not?");
 616       return cond;
 617     } else {
 618       VM_RevokeBias revoke(&obj, (JavaThread*) THREAD);
 619       VMThread::execute(&revoke);
 620       return revoke.status_code();
 621     }
 622   }
 623 
 624   assert((heuristics == HR_BULK_REVOKE) ||
 625          (heuristics == HR_BULK_REBIAS), "?");
 626   VM_BulkRevokeBias bulk_revoke(&obj, (JavaThread*) THREAD,
 627                                 (heuristics == HR_BULK_REBIAS),
 628                                 attempt_rebias);
 629   VMThread::execute(&bulk_revoke);
 630   return bulk_revoke.status_code();
 631 }
 632 
 633 
 634 void BiasedLocking::revoke(GrowableArray<Handle>* objs) {
 635   assert(!SafepointSynchronize::is_at_safepoint(), "must not be called while at safepoint");
 636   if (objs->length() == 0) {
 637     return;
 638   }
 639   VM_RevokeBias revoke(objs, JavaThread::current());
 640   VMThread::execute(&revoke);
 641 }
 642 
 643 
 644 void BiasedLocking::revoke_at_safepoint(Handle h_obj) {
 645   assert(SafepointSynchronize::is_at_safepoint(), "must only be called while at safepoint");
 646   oop obj = h_obj();
 647   HeuristicsResult heuristics = update_heuristics(obj, false);
 648   if (heuristics == HR_SINGLE_REVOKE) {
 649     revoke_bias(obj, false, false, NULL);
 650   } else if ((heuristics == HR_BULK_REBIAS) ||
 651              (heuristics == HR_BULK_REVOKE)) {
 652     bulk_revoke_or_rebias_at_safepoint(obj, (heuristics == HR_BULK_REBIAS), false, NULL);
 653   }
 654   clean_up_cached_monitor_info();
 655 }
 656 
 657 
 658 void BiasedLocking::revoke_at_safepoint(GrowableArray<Handle>* objs) {
 659   assert(SafepointSynchronize::is_at_safepoint(), "must only be called while at safepoint");
 660   int len = objs->length();
 661   for (int i = 0; i < len; i++) {
 662     oop obj = (objs->at(i))();
 663     HeuristicsResult heuristics = update_heuristics(obj, false);
 664     if (heuristics == HR_SINGLE_REVOKE) {
 665       revoke_bias(obj, false, false, NULL);
 666     } else if ((heuristics == HR_BULK_REBIAS) ||
 667                (heuristics == HR_BULK_REVOKE)) {
 668       bulk_revoke_or_rebias_at_safepoint(obj, (heuristics == HR_BULK_REBIAS), false, NULL);
 669     }
 670   }
 671   clean_up_cached_monitor_info();
 672 }
 673 
 674 
 675 void BiasedLocking::preserve_marks() {
 676   if (!UseBiasedLocking)
 677     return;
 678 
 679   assert(SafepointSynchronize::is_at_safepoint(), "must only be called while at safepoint");
 680 
 681   assert(_preserved_oop_stack  == NULL, "double initialization");
 682   assert(_preserved_mark_stack == NULL, "double initialization");
 683 
 684   // In order to reduce the number of mark words preserved during GC
 685   // due to the presence of biased locking, we reinitialize most mark
 686   // words to the class's prototype during GC -- even those which have
 687   // a currently valid bias owner. One important situation where we
 688   // must not clobber a bias is when a biased object is currently
 689   // locked. To handle this case we iterate over the currently-locked
 690   // monitors in a prepass and, if they are biased, preserve their
 691   // mark words here. This should be a relatively small set of objects
 692   // especially compared to the number of objects in the heap.
 693   _preserved_mark_stack = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<markOop>(10, true);
 694   _preserved_oop_stack = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<Handle>(10, true);
 695 
 696   ResourceMark rm;
 697   Thread* cur = Thread::current();
 698   for (JavaThread* thread = Threads::first(); thread != NULL; thread = thread->next()) {
 699     if (thread->has_last_Java_frame()) {
 700       RegisterMap rm(thread);
 701       for (javaVFrame* vf = thread->last_java_vframe(&rm); vf != NULL; vf = vf->java_sender()) {
 702         GrowableArray<MonitorInfo*> *monitors = vf->monitors();
 703         if (monitors != NULL) {
 704           int len = monitors->length();
 705           // Walk monitors youngest to oldest
 706           for (int i = len - 1; i >= 0; i--) {
 707             MonitorInfo* mon_info = monitors->at(i);
 708             if (mon_info->owner_is_scalar_replaced()) continue;
 709             oop owner = mon_info->owner();
 710             if (owner != NULL) {
 711               markOop mark = owner->mark();
 712               if (mark->has_bias_pattern()) {
 713                 _preserved_oop_stack->push(Handle(cur, owner));
 714                 _preserved_mark_stack->push(mark);
 715               }
 716             }
 717           }
 718         }
 719       }
 720     }
 721   }
 722 }
 723 
 724 
 725 void BiasedLocking::restore_marks() {
 726   if (!UseBiasedLocking)
 727     return;
 728 
 729   assert(_preserved_oop_stack  != NULL, "double free");
 730   assert(_preserved_mark_stack != NULL, "double free");
 731 
 732   int len = _preserved_oop_stack->length();
 733   for (int i = 0; i < len; i++) {
 734     Handle owner = _preserved_oop_stack->at(i);
 735     markOop mark = _preserved_mark_stack->at(i);
 736     owner->set_mark(mark);
 737   }
 738 
 739   delete _preserved_oop_stack;
 740   _preserved_oop_stack = NULL;
 741   delete _preserved_mark_stack;
 742   _preserved_mark_stack = NULL;
 743 }
 744 
 745 
 746 int* BiasedLocking::total_entry_count_addr()                   { return _counters.total_entry_count_addr(); }
 747 int* BiasedLocking::biased_lock_entry_count_addr()             { return _counters.biased_lock_entry_count_addr(); }
 748 int* BiasedLocking::anonymously_biased_lock_entry_count_addr() { return _counters.anonymously_biased_lock_entry_count_addr(); }
 749 int* BiasedLocking::rebiased_lock_entry_count_addr()           { return _counters.rebiased_lock_entry_count_addr(); }
 750 int* BiasedLocking::revoked_lock_entry_count_addr()            { return _counters.revoked_lock_entry_count_addr(); }
 751 int* BiasedLocking::fast_path_entry_count_addr()               { return _counters.fast_path_entry_count_addr(); }
 752 int* BiasedLocking::slow_path_entry_count_addr()               { return _counters.slow_path_entry_count_addr(); }
 753 
 754 
 755 // BiasedLockingCounters
 756 
 757 int BiasedLockingCounters::slow_path_entry_count() {
 758   if (_slow_path_entry_count != 0) {
 759     return _slow_path_entry_count;
 760   }
 761   int sum = _biased_lock_entry_count   + _anonymously_biased_lock_entry_count +
 762             _rebiased_lock_entry_count + _revoked_lock_entry_count +
 763             _fast_path_entry_count;
 764 
 765   return _total_entry_count - sum;
 766 }
 767 
 768 void BiasedLockingCounters::print_on(outputStream* st) {
 769   tty->print_cr("# total entries: %d", _total_entry_count);
 770   tty->print_cr("# biased lock entries: %d", _biased_lock_entry_count);
 771   tty->print_cr("# anonymously biased lock entries: %d", _anonymously_biased_lock_entry_count);
 772   tty->print_cr("# rebiased lock entries: %d", _rebiased_lock_entry_count);
 773   tty->print_cr("# revoked lock entries: %d", _revoked_lock_entry_count);
 774   tty->print_cr("# fast path lock entries: %d", _fast_path_entry_count);
 775   tty->print_cr("# slow path lock entries: %d", slow_path_entry_count());
 776 }