author | pliden |
Tue, 05 May 2015 11:17:12 +0200 | |
changeset 30583 | 74ff3d21d616 |
parent 26322 | 3e4ef23b8ee3 |
permissions | -rw-r--r-- |
1374 | 1 |
/* |
30583
74ff3d21d616
8079330: Circular dependency between G1CollectedHeap and G1BlockOffsetSharedArray
pliden
parents:
26322
diff
changeset
|
2 |
* Copyright (c) 2001, 2015, Oracle and/or its affiliates. All rights reserved. |
1374 | 3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 |
* |
|
5 |
* This code is free software; you can redistribute it and/or modify it |
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
|
7 |
* published by the Free Software Foundation. |
|
8 |
* |
|
9 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
|
10 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
11 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
12 |
* version 2 for more details (a copy is included in the LICENSE file that |
|
13 |
* accompanied this code). |
|
14 |
* |
|
15 |
* You should have received a copy of the GNU General Public License version |
|
16 |
* 2 along with this work; if not, write to the Free Software Foundation, |
|
17 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
18 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
3262
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
3262
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
3262
diff
changeset
|
21 |
* questions. |
1374 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1BLOCKOFFSETTABLE_INLINE_HPP |
26 |
#define SHARE_VM_GC_IMPLEMENTATION_G1_G1BLOCKOFFSETTABLE_INLINE_HPP |
|
27 |
||
28 |
#include "gc_implementation/g1/g1BlockOffsetTable.hpp" |
|
25481
1427aa24638c
8047818: G1 HeapRegions can no longer be ContiguousSpaces
mgerdin
parents:
25361
diff
changeset
|
29 |
#include "gc_implementation/g1/heapRegion.inline.hpp" |
7397 | 30 |
#include "memory/space.hpp" |
31 |
||
1374 | 32 |
inline HeapWord* G1BlockOffsetTable::block_start(const void* addr) { |
33 |
if (addr >= _bottom && addr < _end) { |
|
34 |
return block_start_unsafe(addr); |
|
35 |
} else { |
|
36 |
return NULL; |
|
37 |
} |
|
38 |
} |
|
39 |
||
40 |
inline HeapWord* |
|
41 |
G1BlockOffsetTable::block_start_const(const void* addr) const { |
|
42 |
if (addr >= _bottom && addr < _end) { |
|
43 |
return block_start_unsafe_const(addr); |
|
44 |
} else { |
|
45 |
return NULL; |
|
46 |
} |
|
47 |
} |
|
48 |
||
26160 | 49 |
u_char G1BlockOffsetSharedArray::offset_array(size_t index) const { |
50 |
check_index(index, "index out of range"); |
|
51 |
return _offset_array[index]; |
|
52 |
} |
|
53 |
||
54 |
void G1BlockOffsetSharedArray::set_offset_array(size_t index, u_char offset) { |
|
55 |
check_index(index, "index out of range"); |
|
56 |
set_offset_array_raw(index, offset); |
|
57 |
} |
|
58 |
||
59 |
void G1BlockOffsetSharedArray::set_offset_array(size_t index, HeapWord* high, HeapWord* low) { |
|
60 |
check_index(index, "index out of range"); |
|
61 |
assert(high >= low, "addresses out of order"); |
|
62 |
size_t offset = pointer_delta(high, low); |
|
63 |
check_offset(offset, "offset too large"); |
|
64 |
set_offset_array(index, (u_char)offset); |
|
65 |
} |
|
66 |
||
67 |
void G1BlockOffsetSharedArray::set_offset_array(size_t left, size_t right, u_char offset) { |
|
68 |
check_index(right, "right index out of range"); |
|
69 |
assert(left <= right, "indexes out of order"); |
|
70 |
size_t num_cards = right - left + 1; |
|
71 |
if (UseMemSetInBOT) { |
|
72 |
memset(&_offset_array[left], offset, num_cards); |
|
73 |
} else { |
|
74 |
size_t i = left; |
|
75 |
const size_t end = i + num_cards; |
|
76 |
for (; i < end; i++) { |
|
77 |
_offset_array[i] = offset; |
|
78 |
} |
|
79 |
} |
|
80 |
} |
|
81 |
||
82 |
// Variant of index_for that does not check the index for validity. |
|
83 |
inline size_t G1BlockOffsetSharedArray::index_for_raw(const void* p) const { |
|
84 |
return pointer_delta((char*)p, _reserved.start(), sizeof(char)) >> LogN; |
|
85 |
} |
|
86 |
||
1374 | 87 |
inline size_t G1BlockOffsetSharedArray::index_for(const void* p) const { |
88 |
char* pc = (char*)p; |
|
89 |
assert(pc >= (char*)_reserved.start() && |
|
90 |
pc < (char*)_reserved.end(), |
|
14584
bd4290e6d0a5
7194633: G1: Assertion and guarantee failures in block offset table
johnc
parents:
13728
diff
changeset
|
91 |
err_msg("p (" PTR_FORMAT ") not in reserved [" PTR_FORMAT ", " PTR_FORMAT ")", |
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
14584
diff
changeset
|
92 |
p2i(p), p2i(_reserved.start()), p2i(_reserved.end()))); |
26160 | 93 |
size_t result = index_for_raw(p); |
14584
bd4290e6d0a5
7194633: G1: Assertion and guarantee failures in block offset table
johnc
parents:
13728
diff
changeset
|
94 |
check_index(result, "bad index from address"); |
1374 | 95 |
return result; |
96 |
} |
|
97 |
||
98 |
inline HeapWord* |
|
99 |
G1BlockOffsetSharedArray::address_for_index(size_t index) const { |
|
14584
bd4290e6d0a5
7194633: G1: Assertion and guarantee failures in block offset table
johnc
parents:
13728
diff
changeset
|
100 |
check_index(index, "index out of range"); |
26160 | 101 |
HeapWord* result = address_for_index_raw(index); |
1374 | 102 |
assert(result >= _reserved.start() && result < _reserved.end(), |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
7397
diff
changeset
|
103 |
err_msg("bad address from index result " PTR_FORMAT |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
7397
diff
changeset
|
104 |
" _reserved.start() " PTR_FORMAT " _reserved.end() " |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
7397
diff
changeset
|
105 |
PTR_FORMAT, |
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
14584
diff
changeset
|
106 |
p2i(result), p2i(_reserved.start()), p2i(_reserved.end()))); |
1374 | 107 |
return result; |
108 |
} |
|
109 |
||
25361
5146d1e12a2f
8047820: G1 Block offset table does not need to support generic Space classes
mgerdin
parents:
24424
diff
changeset
|
110 |
inline size_t |
5146d1e12a2f
8047820: G1 Block offset table does not need to support generic Space classes
mgerdin
parents:
24424
diff
changeset
|
111 |
G1BlockOffsetArray::block_size(const HeapWord* p) const { |
5146d1e12a2f
8047820: G1 Block offset table does not need to support generic Space classes
mgerdin
parents:
24424
diff
changeset
|
112 |
return gsp()->block_size(p); |
5146d1e12a2f
8047820: G1 Block offset table does not need to support generic Space classes
mgerdin
parents:
24424
diff
changeset
|
113 |
} |
5146d1e12a2f
8047820: G1 Block offset table does not need to support generic Space classes
mgerdin
parents:
24424
diff
changeset
|
114 |
|
1374 | 115 |
inline HeapWord* |
116 |
G1BlockOffsetArray::block_at_or_preceding(const void* addr, |
|
117 |
bool has_max_index, |
|
118 |
size_t max_index) const { |
|
119 |
assert(_array->offset_array(0) == 0, "objects can't cross covered areas"); |
|
120 |
size_t index = _array->index_for(addr); |
|
121 |
// We must make sure that the offset table entry we use is valid. If |
|
122 |
// "addr" is past the end, start at the last known one and go forward. |
|
123 |
if (has_max_index) { |
|
124 |
index = MIN2(index, max_index); |
|
125 |
} |
|
126 |
HeapWord* q = _array->address_for_index(index); |
|
127 |
||
128 |
uint offset = _array->offset_array(index); // Extend u_char to uint. |
|
129 |
while (offset >= N_words) { |
|
130 |
// The excess of the offset from N_words indicates a power of Base |
|
131 |
// to go back by. |
|
132 |
size_t n_cards_back = BlockOffsetArray::entry_to_cards_back(offset); |
|
133 |
q -= (N_words * n_cards_back); |
|
25361
5146d1e12a2f
8047820: G1 Block offset table does not need to support generic Space classes
mgerdin
parents:
24424
diff
changeset
|
134 |
assert(q >= gsp()->bottom(), "Went below bottom!"); |
1374 | 135 |
index -= n_cards_back; |
136 |
offset = _array->offset_array(index); |
|
137 |
} |
|
138 |
assert(offset < N_words, "offset too large"); |
|
139 |
q -= offset; |
|
140 |
return q; |
|
141 |
} |
|
142 |
||
143 |
inline HeapWord* |
|
144 |
G1BlockOffsetArray:: |
|
145 |
forward_to_block_containing_addr_const(HeapWord* q, HeapWord* n, |
|
146 |
const void* addr) const { |
|
25361
5146d1e12a2f
8047820: G1 Block offset table does not need to support generic Space classes
mgerdin
parents:
24424
diff
changeset
|
147 |
if (addr >= gsp()->top()) return gsp()->top(); |
5146d1e12a2f
8047820: G1 Block offset table does not need to support generic Space classes
mgerdin
parents:
24424
diff
changeset
|
148 |
while (n <= addr) { |
5146d1e12a2f
8047820: G1 Block offset table does not need to support generic Space classes
mgerdin
parents:
24424
diff
changeset
|
149 |
q = n; |
5146d1e12a2f
8047820: G1 Block offset table does not need to support generic Space classes
mgerdin
parents:
24424
diff
changeset
|
150 |
oop obj = oop(q); |
5146d1e12a2f
8047820: G1 Block offset table does not need to support generic Space classes
mgerdin
parents:
24424
diff
changeset
|
151 |
if (obj->klass_or_null() == NULL) return q; |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
152 |
n += block_size(q); |
1374 | 153 |
} |
154 |
assert(q <= n, "wrong order for q and addr"); |
|
155 |
assert(addr < n, "wrong order for addr and n"); |
|
156 |
return q; |
|
157 |
} |
|
158 |
||
159 |
inline HeapWord* |
|
160 |
G1BlockOffsetArray::forward_to_block_containing_addr(HeapWord* q, |
|
161 |
const void* addr) { |
|
3262
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
1374
diff
changeset
|
162 |
if (oop(q)->klass_or_null() == NULL) return q; |
25361
5146d1e12a2f
8047820: G1 Block offset table does not need to support generic Space classes
mgerdin
parents:
24424
diff
changeset
|
163 |
HeapWord* n = q + block_size(q); |
1374 | 164 |
// In the normal case, where the query "addr" is a card boundary, and the |
165 |
// offset table chunks are the same size as cards, the block starting at |
|
166 |
// "q" will contain addr, so the test below will fail, and we'll fall |
|
167 |
// through quickly. |
|
168 |
if (n <= addr) { |
|
169 |
q = forward_to_block_containing_addr_slow(q, n, addr); |
|
170 |
} |
|
171 |
assert(q <= addr, "wrong order for current and arg"); |
|
172 |
return q; |
|
173 |
} |
|
174 |
||
7397 | 175 |
#endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1BLOCKOFFSETTABLE_INLINE_HPP |