< prev index next >

src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/Mark.java

Print this page

 39     VM.registerVMInitializedObserver(new Observer() {
 40         public void update(Observable o, Object data) {
 41           initialize(VM.getVM().getTypeDataBase());
 42         }
 43       });
 44   }
 45 
 46   private static synchronized void initialize(TypeDataBase db) throws WrongTypeException {
 47     Type type  = db.lookupType("oopDesc");
 48     markField  = type.getCIntegerField("_mark");
 49 
 50     ageBits             = db.lookupLongConstant("markWord::age_bits").longValue();
 51     lockBits            = db.lookupLongConstant("markWord::lock_bits").longValue();
 52     biasedLockBits      = db.lookupLongConstant("markWord::biased_lock_bits").longValue();
 53     maxHashBits         = db.lookupLongConstant("markWord::max_hash_bits").longValue();
 54     hashBits            = db.lookupLongConstant("markWord::hash_bits").longValue();
 55     lockShift           = db.lookupLongConstant("markWord::lock_shift").longValue();
 56     biasedLockShift     = db.lookupLongConstant("markWord::biased_lock_shift").longValue();
 57     ageShift            = db.lookupLongConstant("markWord::age_shift").longValue();
 58     hashShift           = db.lookupLongConstant("markWord::hash_shift").longValue();



 59     lockMask            = db.lookupLongConstant("markWord::lock_mask").longValue();
 60     lockMaskInPlace     = db.lookupLongConstant("markWord::lock_mask_in_place").longValue();
 61     biasedLockMask      = db.lookupLongConstant("markWord::biased_lock_mask").longValue();
 62     biasedLockMaskInPlace  = db.lookupLongConstant("markWord::biased_lock_mask_in_place").longValue();
 63     biasedLockBitInPlace  = db.lookupLongConstant("markWord::biased_lock_bit_in_place").longValue();
 64     ageMask             = db.lookupLongConstant("markWord::age_mask").longValue();
 65     ageMaskInPlace      = db.lookupLongConstant("markWord::age_mask_in_place").longValue();
 66     hashMask            = db.lookupLongConstant("markWord::hash_mask").longValue();
 67     hashMaskInPlace     = db.lookupLongConstant("markWord::hash_mask_in_place").longValue();
 68     biasedLockAlignment  = db.lookupLongConstant("markWord::biased_lock_alignment").longValue();
 69     lockedValue         = db.lookupLongConstant("markWord::locked_value").longValue();
 70     unlockedValue       = db.lookupLongConstant("markWord::unlocked_value").longValue();
 71     monitorValue        = db.lookupLongConstant("markWord::monitor_value").longValue();
 72     markedValue         = db.lookupLongConstant("markWord::marked_value").longValue();
 73     biasedLockPattern = db.lookupLongConstant("markWord::biased_lock_pattern").longValue();
 74     noHash              = db.lookupLongConstant("markWord::no_hash").longValue();
 75     noHashInPlace       = db.lookupLongConstant("markWord::no_hash_in_place").longValue();
 76     noLockInPlace       = db.lookupLongConstant("markWord::no_lock_in_place").longValue();
 77     maxAge              = db.lookupLongConstant("markWord::max_age").longValue();
 78   }
 79 
 80   // Field accessors
 81   private static CIntegerField markField;
 82 
 83   // Constants -- read from VM
 84   private static long ageBits;
 85   private static long lockBits;
 86   private static long biasedLockBits;
 87   private static long maxHashBits;
 88   private static long hashBits;
 89 
 90   private static long lockShift;
 91   private static long biasedLockShift;
 92   private static long ageShift;
 93   private static long hashShift;

 94 
 95   private static long lockMask;
 96   private static long lockMaskInPlace;
 97   private static long biasedLockMask;
 98   private static long biasedLockMaskInPlace;
 99   private static long biasedLockBitInPlace;
100   private static long ageMask;
101   private static long ageMaskInPlace;
102   private static long hashMask;
103   private static long hashMaskInPlace;
104   private static long biasedLockAlignment;
105 
106   private static long lockedValue;
107   private static long unlockedValue;
108   private static long monitorValue;
109   private static long markedValue;
110   private static long biasedLockPattern;
111 
112   private static long noHash;
113 
114   private static long noHashInPlace;
115   private static long noLockInPlace;
116 
117   private static long maxAge;
118 
119   /* Constants in markWord used by CMS. */
120   private static long cmsShift;
121   private static long cmsMask;
122   private static long sizeShift;
123 




124   public Mark(Address addr) {
125     super(addr);
126   }
127 
128   public long value() {
129     return markField.getValue(addr);
130   }
131 
132   public Address valueAsAddress() {
133     return addr.getAddressAt(markField.getOffset());
134   }
135 
136   // Biased locking accessors
137   // These must be checked by all code which calls into the
138   // ObjectSynchoronizer and other code. The biasing is not understood
139   // by the lower-level CAS-based locking code, although the runtime
140   // fixes up biased locks to be compatible with it when a bias is
141   // revoked.
142   public boolean hasBiasPattern() {
143     return (Bits.maskBitsLong(value(), biasedLockMaskInPlace) == biasedLockPattern);

205     return ((value() & unlockedValue) == 0);
206   }
207   public Mark displacedMarkHelper() {
208     if (Assert.ASSERTS_ENABLED) {
209       Assert.that(hasDisplacedMarkHelper(), "check");
210     }
211     Address addr = valueAsAddress().andWithMask(~monitorValue);
212     return new Mark(addr.getAddressAt(0));
213   }
214   public int age() { return (int) Bits.maskBitsLong(value() >> ageShift, ageMask); }
215 
216   // hash operations
217   public long hash() {
218     return Bits.maskBitsLong(value() >> hashShift, hashMask);
219   }
220 
221   public boolean hasNoHash() {
222     return hash() == noHash;
223   }
224 






225   // Debugging
226   public void printOn(PrintStream tty) {
227     if (isLocked()) {
228       tty.print("locked(0x" +
229                 Long.toHexString(value()) + ")->");
230       displacedMarkHelper().printOn(tty);
231     } else {
232       if (Assert.ASSERTS_ENABLED) {
233         Assert.that(isUnlocked(), "just checking");
234       }
235       tty.print("mark(");
236       tty.print("hash " + Long.toHexString(hash()) + ",");
237       tty.print("age " + age() + ")");
238     }
239   }
240 
241   public long getSize() { return (long)(value() >> sizeShift); }
242 }

 39     VM.registerVMInitializedObserver(new Observer() {
 40         public void update(Observable o, Object data) {
 41           initialize(VM.getVM().getTypeDataBase());
 42         }
 43       });
 44   }
 45 
 46   private static synchronized void initialize(TypeDataBase db) throws WrongTypeException {
 47     Type type  = db.lookupType("oopDesc");
 48     markField  = type.getCIntegerField("_mark");
 49 
 50     ageBits             = db.lookupLongConstant("markWord::age_bits").longValue();
 51     lockBits            = db.lookupLongConstant("markWord::lock_bits").longValue();
 52     biasedLockBits      = db.lookupLongConstant("markWord::biased_lock_bits").longValue();
 53     maxHashBits         = db.lookupLongConstant("markWord::max_hash_bits").longValue();
 54     hashBits            = db.lookupLongConstant("markWord::hash_bits").longValue();
 55     lockShift           = db.lookupLongConstant("markWord::lock_shift").longValue();
 56     biasedLockShift     = db.lookupLongConstant("markWord::biased_lock_shift").longValue();
 57     ageShift            = db.lookupLongConstant("markWord::age_shift").longValue();
 58     hashShift           = db.lookupLongConstant("markWord::hash_shift").longValue();
 59     if (VM.getVM().isLP64()) {
 60       klassShift          = db.lookupLongConstant("markWord::klass_shift").longValue();
 61     }
 62     lockMask            = db.lookupLongConstant("markWord::lock_mask").longValue();
 63     lockMaskInPlace     = db.lookupLongConstant("markWord::lock_mask_in_place").longValue();
 64     biasedLockMask      = db.lookupLongConstant("markWord::biased_lock_mask").longValue();
 65     biasedLockMaskInPlace  = db.lookupLongConstant("markWord::biased_lock_mask_in_place").longValue();
 66     biasedLockBitInPlace  = db.lookupLongConstant("markWord::biased_lock_bit_in_place").longValue();
 67     ageMask             = db.lookupLongConstant("markWord::age_mask").longValue();
 68     ageMaskInPlace      = db.lookupLongConstant("markWord::age_mask_in_place").longValue();
 69     hashMask            = db.lookupLongConstant("markWord::hash_mask").longValue();
 70     hashMaskInPlace     = db.lookupLongConstant("markWord::hash_mask_in_place").longValue();
 71     biasedLockAlignment  = db.lookupLongConstant("markWord::biased_lock_alignment").longValue();
 72     lockedValue         = db.lookupLongConstant("markWord::locked_value").longValue();
 73     unlockedValue       = db.lookupLongConstant("markWord::unlocked_value").longValue();
 74     monitorValue        = db.lookupLongConstant("markWord::monitor_value").longValue();
 75     markedValue         = db.lookupLongConstant("markWord::marked_value").longValue();
 76     biasedLockPattern = db.lookupLongConstant("markWord::biased_lock_pattern").longValue();
 77     noHash              = db.lookupLongConstant("markWord::no_hash").longValue();
 78     noHashInPlace       = db.lookupLongConstant("markWord::no_hash_in_place").longValue();
 79     noLockInPlace       = db.lookupLongConstant("markWord::no_lock_in_place").longValue();
 80     maxAge              = db.lookupLongConstant("markWord::max_age").longValue();
 81   }
 82 
 83   // Field accessors
 84   private static CIntegerField markField;
 85 
 86   // Constants -- read from VM
 87   private static long ageBits;
 88   private static long lockBits;
 89   private static long biasedLockBits;
 90   private static long maxHashBits;
 91   private static long hashBits;
 92 
 93   private static long lockShift;
 94   private static long biasedLockShift;
 95   private static long ageShift;
 96   private static long hashShift;
 97   private static long klassShift;
 98 
 99   private static long lockMask;
100   private static long lockMaskInPlace;
101   private static long biasedLockMask;
102   private static long biasedLockMaskInPlace;
103   private static long biasedLockBitInPlace;
104   private static long ageMask;
105   private static long ageMaskInPlace;
106   private static long hashMask;
107   private static long hashMaskInPlace;
108   private static long biasedLockAlignment;
109 
110   private static long lockedValue;
111   private static long unlockedValue;
112   private static long monitorValue;
113   private static long markedValue;
114   private static long biasedLockPattern;
115 
116   private static long noHash;
117 
118   private static long noHashInPlace;
119   private static long noLockInPlace;
120 
121   private static long maxAge;
122 
123   /* Constants in markWord used by CMS. */
124   private static long cmsShift;
125   private static long cmsMask;
126   private static long sizeShift;
127 
128   public static long getKlassShift() {
129     return klassShift;
130   }
131 
132   public Mark(Address addr) {
133     super(addr);
134   }
135 
136   public long value() {
137     return markField.getValue(addr);
138   }
139 
140   public Address valueAsAddress() {
141     return addr.getAddressAt(markField.getOffset());
142   }
143 
144   // Biased locking accessors
145   // These must be checked by all code which calls into the
146   // ObjectSynchoronizer and other code. The biasing is not understood
147   // by the lower-level CAS-based locking code, although the runtime
148   // fixes up biased locks to be compatible with it when a bias is
149   // revoked.
150   public boolean hasBiasPattern() {
151     return (Bits.maskBitsLong(value(), biasedLockMaskInPlace) == biasedLockPattern);

213     return ((value() & unlockedValue) == 0);
214   }
215   public Mark displacedMarkHelper() {
216     if (Assert.ASSERTS_ENABLED) {
217       Assert.that(hasDisplacedMarkHelper(), "check");
218     }
219     Address addr = valueAsAddress().andWithMask(~monitorValue);
220     return new Mark(addr.getAddressAt(0));
221   }
222   public int age() { return (int) Bits.maskBitsLong(value() >> ageShift, ageMask); }
223 
224   // hash operations
225   public long hash() {
226     return Bits.maskBitsLong(value() >> hashShift, hashMask);
227   }
228 
229   public boolean hasNoHash() {
230     return hash() == noHash;
231   }
232 
233   public Klass getKlass() {
234     assert(VM.getVM().isCompactObjectHeadersEnabled());
235     assert(!hasMonitor());
236     return (Klass)Metadata.instantiateWrapperFor(addr.getCompKlassAddressAt(0));
237   }
238 
239   // Debugging
240   public void printOn(PrintStream tty) {
241     if (isLocked()) {
242       tty.print("locked(0x" +
243                 Long.toHexString(value()) + ")->");
244       displacedMarkHelper().printOn(tty);
245     } else {
246       if (Assert.ASSERTS_ENABLED) {
247         Assert.that(isUnlocked(), "just checking");
248       }
249       tty.print("mark(");
250       tty.print("hash " + Long.toHexString(hash()) + ",");
251       tty.print("age " + age() + ")");
252     }
253   }
254 
255   public long getSize() { return (long)(value() >> sizeShift); }
256 }
< prev index next >