Cross Reference: /openjdk7/hotspot/src/share/vm/runtime/synchronizer.cpp

Lines Matching refs:mark
180     assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
187   assert(!object->mark()->has_bias_pattern(), "should not see bias pattern here");
190   markOop mark ;
194      mark = object->mark() ;
195      assert (!mark->is_neutral(), "invariant") ;
196      if (mark->has_locker() && mark != markOopDesc::INFLATING()) {
197         assert(THREAD->is_lock_owned((address)mark->locker()), "invariant") ;
199      if (mark->has_monitor()) {
200         ObjectMonitor * m = mark->monitor() ;
201         assert(((oop)(m->object()))->mark() == mark, "invariant") ;
207   mark = object->mark() ;
210   // swing the displaced header from the box back to the mark.
211   if (mark == (markOop) lock) {
213      if ((markOop) Atomic::cmpxchg_ptr (dhw, object->mark_addr(), mark) == mark) {
228   markOop mark = obj->mark();
229   assert(!mark->has_bias_pattern(), "should not see bias pattern here");
231   if (mark->is_neutral()) {
232     // Anticipate successful CAS -- the ST of the displaced mark must
234     lock->set_displaced_header(mark);
235     if (mark == (markOop) Atomic::cmpxchg_ptr(lock, obj()->mark_addr(), mark)) {
241   if (mark->has_locker() && THREAD->is_lock_owned((address)mark->locker())) {
242     assert(lock != mark->locker(), "must not re-lock the same lock");
243     assert(lock != (BasicLock*)obj->mark(), "don't relock with same BasicLock");
250   if (mark->has_monitor() && mark->monitor()->is_entered(THREAD)) {
288     assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
301     assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
316     assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
327     assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
343   assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
382     assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
401     assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
413     assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
416   markOop mark = obj->mark();
417   if (mark->has_locker() && THREAD->is_lock_owned((address)mark->locker())) {
427     assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
430   markOop mark = obj->mark();
431   if (mark->has_locker() && THREAD->is_lock_owned((address)mark->locker())) {
475   markOop mark = obj->mark() ;
476   if (!mark->is_being_inflated()) {
477     return mark ;       // normal fast-path return
482     markOop mark = obj->mark() ;
483     if (!mark->is_being_inflated()) {
484       return mark ;    // normal fast-path return
523          while (obj->mark() == markOopDesc::INFLATING()) {
615     if (obj->mark()->has_bias_pattern()) {
624       assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
640   markOop mark = ReadStableMark (obj);
643   assert (!mark->has_bias_pattern(), "invariant") ;
645   if (mark->is_neutral()) {
646     hash = mark->hash();              // this is a normal header
651     temp = mark->copy_set_hash(hash); // merge the hash code into header
653     test = (markOop) Atomic::cmpxchg_ptr(temp, obj->mark_addr(), mark);
654     if (test == mark) {
660   } else if (mark->has_monitor()) {
661     monitor = mark->monitor();
669   } else if (Self->is_lock_owned((address)mark->locker())) {
670     temp = mark->displaced_mark_helper(); // this is a lightweight monitor owned
690   mark = monitor->header();
691   assert (mark->is_neutral(), "invariant") ;
692   hash = mark->hash();
695     temp = mark->copy_set_hash(hash); // merge hash code into header
697     test = (markOop) Atomic::cmpxchg_ptr(temp, monitor, mark);
698     if (test != mark) {
722     assert(!h_obj->mark()->has_bias_pattern(), "biases should be revoked by now");
728   markOop mark = ReadStableMark (obj) ;
731   if (mark->has_locker()) {
732     return thread->is_lock_owned((address)mark->locker());
735   if (mark->has_monitor()) {
736     ObjectMonitor* monitor = mark->monitor();
740   assert(mark->is_neutral(), "sanity check");
756   // Possible mark states: neutral, biased, stack-locked, inflated
758   if (UseBiasedLocking && h_obj()->mark()->has_bias_pattern()) {
761     assert(!h_obj->mark()->has_bias_pattern(),
767   markOop mark = ReadStableMark (obj) ;
770   if (mark->has_locker()) {
771     return self->is_lock_owned((address)mark->locker()) ?
778   if (mark->has_monitor()) {
779     void * owner = mark->monitor()->_owner ;
786   assert(mark->is_neutral(), "sanity check");
798     assert(!h_obj->mark()->has_bias_pattern(), "biases should be revoked by now");
804   markOop mark = ReadStableMark (obj) ;
807   if (mark->has_locker()) {
808     owner = (address) mark->locker();
812   if (mark->has_monitor()) {
813     ObjectMonitor* monitor = mark->monitor();
825   // assert(mark->is_neutral(), "sanity check");
886 // --   assigned to an object.  The object is inflated and the mark refers
1181   markOop mark = obj->mark();
1182   if (mark->has_monitor()) {
1183     assert(ObjectSynchronizer::verify_objmon_isinpool(mark->monitor()), "monitor is invalid");
1184     assert(mark->monitor()->header()->is_neutral(), "monitor must record a good object header");
1185     return mark->monitor();
1202       const markOop mark = object->mark() ;
1203       assert (!mark->has_bias_pattern(), "invariant") ;
1205       // The mark can be in one of the following states:
1213       if (mark->has_monitor()) {
1214           ObjectMonitor * inf = mark->monitor() ;
1227       if (mark == markOopDesc::INFLATING()) {
1237       // to install INFLATING into the mark word.  We originally installed INFLATING,
1239       // objectmonitor into the mark.  This was correct, but artificially lengthened
1240       // the interval in which INFLATED appeared in the mark, thus increasing
1252       if (mark->has_locker()) {
1256           // in which INFLATING appears in the mark.
1263           markOop cmp = (markOop) Atomic::cmpxchg_ptr (markOopDesc::INFLATING(), object->mark_addr(), mark) ;
1264           if (cmp != mark) {
1269           // We've successfully installed INFLATING (0) into the mark-word.
1270           // This is the only case where 0 will appear in a mark-work.
1271           // Only the singular thread that successfully swings the mark-word
1274           // Why do we CAS a 0 into the mark-word instead of just CASing the
1275           // mark-word from the stack-locked value directly to the new inflated state?
1291           // Critically, while object->mark is 0 mark->displaced_mark_helper() is stable.
1295           // fetch the displaced mark from the owner's stack.
1297           // object is in the mark.  Furthermore the owner can't complete
1299           markOop dmw = mark->displaced_mark_helper() ;
1305           // Optimization: if the mark->locker stack address is associated
1310           m->set_owner(mark->locker());
1316           guarantee (object->mark() == markOopDesc::INFLATING(), "invariant") ;
1326               tty->print_cr("Inflating object " INTPTR_FORMAT " , mark " INTPTR_FORMAT " , type %s",
1327                 (intptr_t) object, (intptr_t) object->mark(),
1344       assert (mark->is_neutral(), "invariant");
1348       m->set_header(mark);
1356       if (Atomic::cmpxchg_ptr (markOopDesc::encode(m), object->mark_addr(), mark) != mark) {
1376           tty->print_cr("Inflating object " INTPTR_FORMAT " , mark " INTPTR_FORMAT " , type %s",
1377             (intptr_t) object, (intptr_t) object->mark(),
1429   guarantee (obj->mark() == markOopDesc::encode(mid), "invariant") ;
1430   guarantee (mid == obj->mark()->monitor(), "invariant");
1444            tty->print_cr("Deflating object " INTPTR_FORMAT " , mark " INTPTR_FORMAT " , type %s",
1445                 (intptr_t) obj, (intptr_t) obj->mark(), Klass::cast(obj->klass())->external_name());