53 |
|
* (STRONG, |
54 |
|
* new Equivalence<Person>() { |
55 |
|
* public boolean equal(Person k, Object x) { |
56 |
< |
* return x instanceOf Person && k.name.equals(((Person)x).name); |
56 |
> |
* return x instanceof Person && k.name.equals(((Person)x).name); |
57 |
|
* } |
58 |
|
* public int hash(Object x) { |
59 |
< |
* return (x instanceOf Person)? ((Person)x).name.hashCode() : 0; |
59 |
> |
* return (x instanceof Person)? ((Person)x).name.hashCode() : 0; |
60 |
|
* } |
61 |
|
* }, |
62 |
|
* STRONG, EQUALS, 0); |
537 |
|
while (capacity < sc) |
538 |
|
capacity <<= 1; |
539 |
|
if (capacity > MAX_SEGMENT_CAPACITY) |
540 |
< |
capacity = MAX_SEGMENT_CAPACITY; |
540 |
> |
capacity = MAX_SEGMENT_CAPACITY; |
541 |
|
this.initialSegmentCapacity = capacity; |
542 |
|
} |
543 |
|
this.segments = (Segment[])new Segment[NSEGMENTS]; |
2101 |
|
final int locator; |
2102 |
|
final CustomConcurrentHashMap cchm; |
2103 |
|
WeakKeyNode(int locator, Object key, CustomConcurrentHashMap cchm) { |
2104 |
< |
super(key); |
2104 |
> |
super(key, getReclamationQueue()); |
2105 |
|
this.locator = locator; |
2106 |
|
this.cchm = cchm; |
2107 |
|
} |
2396 |
|
final int locator; |
2397 |
|
final CustomConcurrentHashMap cchm; |
2398 |
|
SoftKeyNode(int locator, Object key, CustomConcurrentHashMap cchm) { |
2399 |
< |
super(key); |
2399 |
> |
super(key, getReclamationQueue()); |
2400 |
|
this.locator = locator; |
2401 |
|
this.cchm = cchm; |
2402 |
|
} |
2984 |
|
|
2985 |
|
// Temporary Unsafe mechanics for preliminary release |
2986 |
|
|
2987 |
< |
static final Unsafe _unsafe; |
2987 |
> |
static final Unsafe UNSAFE; |
2988 |
|
static final long tableBase; |
2989 |
|
static final int tableShift; |
2990 |
|
static final long segmentsBase; |
3015 |
|
|
3016 |
|
static { |
3017 |
|
try { |
3018 |
< |
_unsafe = getUnsafe(); |
3019 |
< |
tableBase = _unsafe.arrayBaseOffset(Node[].class); |
3020 |
< |
int s = _unsafe.arrayIndexScale(Node[].class); |
3018 |
> |
UNSAFE = getUnsafe(); |
3019 |
> |
tableBase = UNSAFE.arrayBaseOffset(Node[].class); |
3020 |
> |
int s = UNSAFE.arrayIndexScale(Node[].class); |
3021 |
|
if ((s & (s-1)) != 0) |
3022 |
|
throw new Error("data type scale not a power of two"); |
3023 |
|
tableShift = 31 - Integer.numberOfLeadingZeros(s); |
3024 |
< |
segmentsBase = _unsafe.arrayBaseOffset(Segment[].class); |
3025 |
< |
s = _unsafe.arrayIndexScale(Segment[].class); |
3024 |
> |
segmentsBase = UNSAFE.arrayBaseOffset(Segment[].class); |
3025 |
> |
s = UNSAFE.arrayIndexScale(Segment[].class); |
3026 |
|
if ((s & (s-1)) != 0) |
3027 |
|
throw new Error("data type scale not a power of two"); |
3028 |
|
segmentsShift = 31 - Integer.numberOfLeadingZeros(s); |
3035 |
|
static final void storeNode(Node[] table, |
3036 |
|
int i, Node r) { |
3037 |
|
long nodeOffset = ((long) i << tableShift) + tableBase; |
3038 |
< |
_unsafe.putOrderedObject(table, nodeOffset, r); |
3038 |
> |
UNSAFE.putOrderedObject(table, nodeOffset, r); |
3039 |
|
} |
3040 |
|
|
3041 |
|
static final void storeSegment(Segment[] segs, |
3042 |
|
int i, Segment s) { |
3043 |
|
long segmentOffset = ((long) i << segmentsShift) + segmentsBase; |
3044 |
< |
_unsafe.putOrderedObject(segs, segmentOffset, s); |
3044 |
> |
UNSAFE.putOrderedObject(segs, segmentOffset, s); |
3045 |
|
} |
3046 |
|
|
3047 |
|
|