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 }
|