Mercurial > hg > graal-compiler
changeset 23034:28cb37047aa0
reproduced comment from markOop.hpp in MonitorSnippets for convenience
author | Doug Simon <doug.simon@oracle.com> |
---|---|
date | Thu, 19 Nov 2015 20:33:47 +0100 |
parents | 9751654cd23f |
children | 78e6ba51f14b |
files | graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/replacements/MonitorSnippets.java |
diffstat | 1 files changed, 71 insertions(+), 0 deletions(-) [+] |
line wrap: on
line diff
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/replacements/MonitorSnippets.java Thu Nov 19 20:27:04 2015 +0100 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/replacements/MonitorSnippets.java Thu Nov 19 20:33:47 2015 +0100 @@ -116,6 +116,77 @@ * href="http://dl.acm.org/citation.cfm?id=1167515.1167496"> Eliminating synchronization-related * atomic operations with biased locking and bulk rebiasing</a> by Kenneth Russell and David * Detlefs. + * + * Comment below is reproduced from {@code markOop.hpp} for convenience: + * + * <pre> + * Bit-format of an object header (most significant first, big endian layout below): + * 32 bits: + * -------- + * hash:25 ------------>| age:4 biased_lock:1 lock:2 (normal object) + * JavaThread*:23 epoch:2 age:4 biased_lock:1 lock:2 (biased object) + * size:32 ------------------------------------------>| (CMS free block) + * PromotedObject*:29 ---------->| promo_bits:3 ----->| (CMS promoted object) + * + * 64 bits: + * -------- + * unused:25 hash:31 -->| unused:1 age:4 biased_lock:1 lock:2 (normal object) + * JavaThread*:54 epoch:2 unused:1 age:4 biased_lock:1 lock:2 (biased object) + * PromotedObject*:61 --------------------->| promo_bits:3 ----->| (CMS promoted object) + * size:64 ----------------------------------------------------->| (CMS free block) + * + * unused:25 hash:31 -->| cms_free:1 age:4 biased_lock:1 lock:2 (COOPs && normal object) + * JavaThread*:54 epoch:2 cms_free:1 age:4 biased_lock:1 lock:2 (COOPs && biased object) + * narrowOop:32 unused:24 cms_free:1 unused:4 promo_bits:3 ----->| (COOPs && CMS promoted object) + * unused:21 size:35 -->| cms_free:1 unused:7 ------------------>| (COOPs && CMS free block) + * + * - hash contains the identity hash value: largest value is + * 31 bits, see os::random(). Also, 64-bit vm's require + * a hash value no bigger than 32 bits because they will not + * properly generate a mask larger than that: see library_call.cpp + * and c1_CodePatterns_sparc.cpp. + * + * - the biased lock pattern is used to bias a lock toward a given + * thread. When this pattern is set in the low three bits, the lock + * is either biased toward a given thread or "anonymously" biased, + * indicating that it is possible for it to be biased. When the + * lock is biased toward a given thread, locking and unlocking can + * be performed by that thread without using atomic operations. + * When a lock's bias is revoked, it reverts back to the normal + * locking scheme described below. + * + * Note that we are overloading the meaning of the "unlocked" state + * of the header. Because we steal a bit from the age we can + * guarantee that the bias pattern will never be seen for a truly + * unlocked object. + * + * Note also that the biased state contains the age bits normally + * contained in the object header. Large increases in scavenge + * times were seen when these bits were absent and an arbitrary age + * assigned to all biased objects, because they tended to consume a + * significant fraction of the eden semispaces and were not + * promoted promptly, causing an increase in the amount of copying + * performed. The runtime system aligns all JavaThread* pointers to + * a very large value (currently 128 bytes (32bVM) or 256 bytes (64bVM)) + * to make room for the age bits & the epoch bits (used in support of + * biased locking), and for the CMS "freeness" bit in the 64bVM (+COOPs). + * + * [JavaThread* | epoch | age | 1 | 01] lock is biased toward given thread + * [0 | epoch | age | 1 | 01] lock is anonymously biased + * + * - the two lock bits are used to describe three states: locked/unlocked and monitor. + * + * [ptr | 00] locked ptr points to real header on stack + * [header | 0 | 01] unlocked regular object header + * [ptr | 10] monitor inflated lock (header is wapped out) + * [ptr | 11] marked used by markSweep to mark an object + * not valid at any other time + * + * We assume that stack/thread pointers have the lowest two bits cleared. + * </pre> + * + * Note that {@code Thread::allocate} enforces {@code JavaThread} objects to be aligned + * appropriately to comply with the layouts above. */ public class MonitorSnippets implements Snippets {