Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
openanolis
dragonwell8_hotspot
提交
2c61150c
D
dragonwell8_hotspot
项目概览
openanolis
/
dragonwell8_hotspot
通知
2
Star
2
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
D
dragonwell8_hotspot
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
2c61150c
编写于
4月 25, 2012
作者:
J
jmasa
浏览文件
操作
浏览文件
下载
差异文件
Merge
上级
7b83234d
72a17806
变更
14
展开全部
隐藏空白更改
内联
并排
Showing
14 changed file
with
620 addition
and
620 deletion
+620
-620
src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.cpp
...entation/concurrentMarkSweep/compactibleFreeListSpace.cpp
+147
-147
src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp
...entation/concurrentMarkSweep/compactibleFreeListSpace.hpp
+2
-2
src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp
...ion/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp
+27
-27
src/share/vm/gc_implementation/concurrentMarkSweep/freeChunk.hpp
...re/vm/gc_implementation/concurrentMarkSweep/freeChunk.hpp
+12
-12
src/share/vm/gc_implementation/concurrentMarkSweep/promotionInfo.cpp
...m/gc_implementation/concurrentMarkSweep/promotionInfo.cpp
+1
-1
src/share/vm/gc_implementation/concurrentMarkSweep/promotionInfo.hpp
...m/gc_implementation/concurrentMarkSweep/promotionInfo.hpp
+9
-9
src/share/vm/gc_implementation/concurrentMarkSweep/vmStructs_cms.hpp
...m/gc_implementation/concurrentMarkSweep/vmStructs_cms.hpp
+1
-1
src/share/vm/gc_implementation/shared/allocationStats.hpp
src/share/vm/gc_implementation/shared/allocationStats.hpp
+45
-45
src/share/vm/memory/binaryTreeDictionary.cpp
src/share/vm/memory/binaryTreeDictionary.cpp
+195
-195
src/share/vm/memory/binaryTreeDictionary.hpp
src/share/vm/memory/binaryTreeDictionary.hpp
+68
-68
src/share/vm/memory/freeBlockDictionary.cpp
src/share/vm/memory/freeBlockDictionary.cpp
+2
-2
src/share/vm/memory/freeBlockDictionary.hpp
src/share/vm/memory/freeBlockDictionary.hpp
+19
-19
src/share/vm/memory/freeList.cpp
src/share/vm/memory/freeList.cpp
+38
-38
src/share/vm/memory/freeList.hpp
src/share/vm/memory/freeList.hpp
+54
-54
未找到文件。
src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.cpp
浏览文件 @
2c61150c
此差异已折叠。
点击以展开。
src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp
浏览文件 @
2c61150c
...
...
@@ -499,7 +499,7 @@ class CompactibleFreeListSpace: public CompactibleSpace {
// Verify that the given chunk is in the free lists:
// i.e. either the binary tree dictionary, the indexed free lists
// or the linear allocation block.
bool
verify
ChunkInFreeLists
(
FreeChunk
*
fc
)
const
;
bool
verify
_chunk_in_free_list
(
FreeChunk
*
fc
)
const
;
// Verify that the given chunk is the linear allocation block
bool
verify_chunk_is_linear_alloc_block
(
FreeChunk
*
fc
)
const
;
// Do some basic checks on the the free lists.
...
...
@@ -608,7 +608,7 @@ class CompactibleFreeListSpace: public CompactibleSpace {
void
coalDeath
(
size_t
size
);
void
smallSplitBirth
(
size_t
size
);
void
smallSplitDeath
(
size_t
size
);
void
split
B
irth
(
size_t
size
);
void
split
_b
irth
(
size_t
size
);
void
splitDeath
(
size_t
size
);
void
split
(
size_t
from
,
size_t
to1
);
...
...
src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp
浏览文件 @
2c61150c
...
...
@@ -1026,7 +1026,7 @@ HeapWord* ConcurrentMarkSweepGeneration::have_lock_and_allocate(size_t size,
// its mark-bit or P-bits not yet set. Such objects need
// to be safely navigable by block_start().
assert
(
oop
(
res
)
->
klass_or_null
()
==
NULL
,
"Object should be uninitialized here."
);
assert
(
!
((
FreeChunk
*
)
res
)
->
is
F
ree
(),
"Error, block will look free but show wrong size"
);
assert
(
!
((
FreeChunk
*
)
res
)
->
is
_f
ree
(),
"Error, block will look free but show wrong size"
);
collector
()
->
direct_allocated
(
res
,
adjustedSize
);
_direct_allocated_words
+=
adjustedSize
;
// allocation counters
...
...
@@ -1391,7 +1391,7 @@ ConcurrentMarkSweepGeneration::par_promote(int thread_num,
oop
obj
=
oop
(
obj_ptr
);
OrderAccess
::
storestore
();
assert
(
obj
->
klass_or_null
()
==
NULL
,
"Object should be uninitialized here."
);
assert
(
!
((
FreeChunk
*
)
obj_ptr
)
->
is
F
ree
(),
"Error, block will look free but show wrong size"
);
assert
(
!
((
FreeChunk
*
)
obj_ptr
)
->
is
_f
ree
(),
"Error, block will look free but show wrong size"
);
// IMPORTANT: See note on object initialization for CMS above.
// Otherwise, copy the object. Here we must be careful to insert the
// klass pointer last, since this marks the block as an allocated object.
...
...
@@ -1400,7 +1400,7 @@ ConcurrentMarkSweepGeneration::par_promote(int thread_num,
// Restore the mark word copied above.
obj
->
set_mark
(
m
);
assert
(
obj
->
klass_or_null
()
==
NULL
,
"Object should be uninitialized here."
);
assert
(
!
((
FreeChunk
*
)
obj_ptr
)
->
is
F
ree
(),
"Error, block will look free but show wrong size"
);
assert
(
!
((
FreeChunk
*
)
obj_ptr
)
->
is
_f
ree
(),
"Error, block will look free but show wrong size"
);
OrderAccess
::
storestore
();
if
(
UseCompressedOops
)
{
...
...
@@ -1421,7 +1421,7 @@ ConcurrentMarkSweepGeneration::par_promote(int thread_num,
promoInfo
->
track
((
PromotedObject
*
)
obj
,
old
->
klass
());
}
assert
(
obj
->
klass_or_null
()
==
NULL
,
"Object should be uninitialized here."
);
assert
(
!
((
FreeChunk
*
)
obj_ptr
)
->
is
F
ree
(),
"Error, block will look free but show wrong size"
);
assert
(
!
((
FreeChunk
*
)
obj_ptr
)
->
is
_f
ree
(),
"Error, block will look free but show wrong size"
);
assert
(
old
->
is_oop
(),
"Will use and dereference old klass ptr below"
);
// Finally, install the klass pointer (this should be volatile).
...
...
@@ -2034,7 +2034,7 @@ void CMSCollector::do_compaction_work(bool clear_all_soft_refs) {
pointer_delta
(
cms_space
->
end
(),
cms_space
->
compaction_top
())
*
HeapWordSize
,
"All the free space should be compacted into one chunk at top"
);
assert
(
cms_space
->
dictionary
()
->
total
ChunkS
ize
(
assert
(
cms_space
->
dictionary
()
->
total
_chunk_s
ize
(
debug_only
(
cms_space
->
freelistLock
()))
==
0
||
cms_space
->
totalSizeInIndexedFreeLists
()
==
0
,
"All the free space should be in a single chunk"
);
...
...
@@ -6131,7 +6131,7 @@ void ConcurrentMarkSweepGeneration::setNearLargestChunk() {
double
nearLargestPercent
=
FLSLargestBlockCoalesceProximity
;
HeapWord
*
minAddr
=
_cmsSpace
->
bottom
();
HeapWord
*
largestAddr
=
(
HeapWord
*
)
_cmsSpace
->
dictionary
()
->
find
LargestD
ict
();
(
HeapWord
*
)
_cmsSpace
->
dictionary
()
->
find
_largest_d
ict
();
if
(
largestAddr
==
NULL
)
{
// The dictionary appears to be empty. In this case
// try to coalesce at the end of the heap.
...
...
@@ -7906,7 +7906,7 @@ SweepClosure::SweepClosure(CMSCollector* collector,
_last_fc
=
NULL
;
_sp
->
initializeIndexedFreeListArrayReturnedBytes
();
_sp
->
dictionary
()
->
initialize
DictReturnedB
ytes
();
_sp
->
dictionary
()
->
initialize
_dict_returned_b
ytes
();
)
assert
(
_limit
>=
_sp
->
bottom
()
&&
_limit
<=
_sp
->
end
(),
"sweep _limit out of bounds"
);
...
...
@@ -7954,13 +7954,13 @@ SweepClosure::~SweepClosure() {
if
(
PrintCMSStatistics
&&
CMSVerifyReturnedBytes
)
{
size_t
indexListReturnedBytes
=
_sp
->
sumIndexedFreeListArrayReturnedBytes
();
size_t
dict
ReturnedBytes
=
_sp
->
dictionary
()
->
sumDictReturnedB
ytes
();
size_t
returned
Bytes
=
indexListReturnedBytes
+
dictReturnedB
ytes
;
gclog_or_tty
->
print
(
"Returned "
SIZE_FORMAT
" bytes"
,
returned
B
ytes
);
size_t
dict
_returned_bytes
=
_sp
->
dictionary
()
->
sum_dict_returned_b
ytes
();
size_t
returned
_bytes
=
indexListReturnedBytes
+
dict_returned_b
ytes
;
gclog_or_tty
->
print
(
"Returned "
SIZE_FORMAT
" bytes"
,
returned
_b
ytes
);
gclog_or_tty
->
print
(
" Indexed List Returned "
SIZE_FORMAT
" bytes"
,
indexListReturnedBytes
);
gclog_or_tty
->
print_cr
(
" Dictionary Returned "
SIZE_FORMAT
" bytes"
,
dict
ReturnedB
ytes
);
dict
_returned_b
ytes
);
}
}
if
(
CMSTraceSweeper
)
{
...
...
@@ -7985,9 +7985,9 @@ void SweepClosure::initialize_free_range(HeapWord* freeFinger,
if
(
CMSTestInFreeList
)
{
if
(
freeRangeInFreeLists
)
{
FreeChunk
*
fc
=
(
FreeChunk
*
)
freeFinger
;
assert
(
fc
->
is
F
ree
(),
"A chunk on the free list should be free."
);
assert
(
fc
->
is
_f
ree
(),
"A chunk on the free list should be free."
);
assert
(
fc
->
size
()
>
0
,
"Free range should have a size"
);
assert
(
_sp
->
verify
ChunkInFreeLists
(
fc
),
"Chunk is not in free lists"
);
assert
(
_sp
->
verify
_chunk_in_free_list
(
fc
),
"Chunk is not in free lists"
);
}
}
}
...
...
@@ -8057,7 +8057,7 @@ size_t SweepClosure::do_blk_careful(HeapWord* addr) {
assert
(
addr
<
_limit
,
"sweep invariant"
);
// check if we should yield
do_yield_check
(
addr
);
if
(
fc
->
is
F
ree
())
{
if
(
fc
->
is
_f
ree
())
{
// Chunk that is already free
res
=
fc
->
size
();
do_already_free_chunk
(
fc
);
...
...
@@ -8145,7 +8145,7 @@ void SweepClosure::do_already_free_chunk(FreeChunk* fc) {
// Chunks that cannot be coalesced are not in the
// free lists.
if
(
CMSTestInFreeList
&&
!
fc
->
cantCoalesce
())
{
assert
(
_sp
->
verify
ChunkInFreeLists
(
fc
),
assert
(
_sp
->
verify
_chunk_in_free_list
(
fc
),
"free chunk should be in free lists"
);
}
// a chunk that is already free, should not have been
...
...
@@ -8171,7 +8171,7 @@ void SweepClosure::do_already_free_chunk(FreeChunk* fc) {
FreeChunk
*
nextChunk
=
(
FreeChunk
*
)(
addr
+
size
);
assert
((
HeapWord
*
)
nextChunk
<=
_sp
->
end
(),
"Chunk size out of bounds?"
);
if
((
HeapWord
*
)
nextChunk
<
_sp
->
end
()
&&
// There is another free chunk to the right ...
nextChunk
->
is
F
ree
()
&&
// ... which is free...
nextChunk
->
is
_f
ree
()
&&
// ... which is free...
nextChunk
->
cantCoalesce
())
{
// ... but can't be coalesced
// nothing to do
}
else
{
...
...
@@ -8203,7 +8203,7 @@ void SweepClosure::do_already_free_chunk(FreeChunk* fc) {
assert
(
ffc
->
size
()
==
pointer_delta
(
addr
,
freeFinger
()),
"Size of free range is inconsistent with chunk size."
);
if
(
CMSTestInFreeList
)
{
assert
(
_sp
->
verify
ChunkInFreeLists
(
ffc
),
assert
(
_sp
->
verify
_chunk_in_free_list
(
ffc
),
"free range is not in free lists"
);
}
_sp
->
removeFreeChunkFromFreeLists
(
ffc
);
...
...
@@ -8262,7 +8262,7 @@ size_t SweepClosure::do_garbage_chunk(FreeChunk* fc) {
assert
(
ffc
->
size
()
==
pointer_delta
(
addr
,
freeFinger
()),
"Size of free range is inconsistent with chunk size."
);
if
(
CMSTestInFreeList
)
{
assert
(
_sp
->
verify
ChunkInFreeLists
(
ffc
),
assert
(
_sp
->
verify
_chunk_in_free_list
(
ffc
),
"free range is not in free lists"
);
}
_sp
->
removeFreeChunkFromFreeLists
(
ffc
);
...
...
@@ -8351,11 +8351,11 @@ void SweepClosure::do_post_free_or_garbage_chunk(FreeChunk* fc,
size_t
chunkSize
)
{
// do_post_free_or_garbage_chunk() should only be called in the case
// of the adaptive free list allocator.
const
bool
fcInFreeLists
=
fc
->
is
F
ree
();
const
bool
fcInFreeLists
=
fc
->
is
_f
ree
();
assert
(
_sp
->
adaptive_freelists
(),
"Should only be used in this case."
);
assert
((
HeapWord
*
)
fc
<=
_limit
,
"sweep invariant"
);
if
(
CMSTestInFreeList
&&
fcInFreeLists
)
{
assert
(
_sp
->
verify
ChunkInFreeLists
(
fc
),
"free chunk is not in free lists"
);
assert
(
_sp
->
verify
_chunk_in_free_list
(
fc
),
"free chunk is not in free lists"
);
}
if
(
CMSTraceSweeper
)
{
...
...
@@ -8410,7 +8410,7 @@ void SweepClosure::do_post_free_or_garbage_chunk(FreeChunk* fc,
assert
(
ffc
->
size
()
==
pointer_delta
(
fc_addr
,
freeFinger
()),
"Size of free range is inconsistent with chunk size."
);
if
(
CMSTestInFreeList
)
{
assert
(
_sp
->
verify
ChunkInFreeLists
(
ffc
),
assert
(
_sp
->
verify
_chunk_in_free_list
(
ffc
),
"Chunk is not in free lists"
);
}
_sp
->
coalDeath
(
ffc
->
size
());
...
...
@@ -8459,7 +8459,7 @@ void SweepClosure::lookahead_and_flush(FreeChunk* fc, size_t chunk_size) {
" when examining fc = "
PTR_FORMAT
"("
SIZE_FORMAT
")"
,
_limit
,
_sp
->
bottom
(),
_sp
->
end
(),
fc
,
chunk_size
));
if
(
eob
>=
_limit
)
{
assert
(
eob
==
_limit
||
fc
->
is
F
ree
(),
"Only a free chunk should allow us to cross over the limit"
);
assert
(
eob
==
_limit
||
fc
->
is
_f
ree
(),
"Only a free chunk should allow us to cross over the limit"
);
if
(
CMSTraceSweeper
)
{
gclog_or_tty
->
print_cr
(
"_limit "
PTR_FORMAT
" reached or crossed by block "
"["
PTR_FORMAT
","
PTR_FORMAT
") in space "
...
...
@@ -8482,8 +8482,8 @@ void SweepClosure::flush_cur_free_chunk(HeapWord* chunk, size_t size) {
if
(
!
freeRangeInFreeLists
())
{
if
(
CMSTestInFreeList
)
{
FreeChunk
*
fc
=
(
FreeChunk
*
)
chunk
;
fc
->
set
S
ize
(
size
);
assert
(
!
_sp
->
verify
ChunkInFreeLists
(
fc
),
fc
->
set
_s
ize
(
size
);
assert
(
!
_sp
->
verify
_chunk_in_free_list
(
fc
),
"chunk should not be in free lists yet"
);
}
if
(
CMSTraceSweeper
)
{
...
...
@@ -8557,8 +8557,8 @@ void SweepClosure::do_yield_work(HeapWord* addr) {
// This is actually very useful in a product build if it can
// be called from the debugger. Compile it into the product
// as needed.
bool
debug_verify
ChunkInFreeLists
(
FreeChunk
*
fc
)
{
return
debug_cms_space
->
verify
ChunkInFreeLists
(
fc
);
bool
debug_verify
_chunk_in_free_list
(
FreeChunk
*
fc
)
{
return
debug_cms_space
->
verify
_chunk_in_free_list
(
fc
);
}
#endif
...
...
@@ -9255,7 +9255,7 @@ void ASConcurrentMarkSweepGeneration::shrink_by(size_t desired_bytes) {
size_t
chunk_at_end_old_size
=
chunk_at_end
->
size
();
assert
(
chunk_at_end_old_size
>=
word_size_change
,
"Shrink is too large"
);
chunk_at_end
->
set
S
ize
(
chunk_at_end_old_size
-
chunk_at_end
->
set
_s
ize
(
chunk_at_end_old_size
-
word_size_change
);
_cmsSpace
->
freed
((
HeapWord
*
)
chunk_at_end
->
end
(),
word_size_change
);
...
...
src/share/vm/gc_implementation/concurrentMarkSweep/freeChunk.hpp
浏览文件 @
2c61150c
...
...
@@ -75,20 +75,20 @@ class FreeChunk VALUE_OBJ_CLASS_SPEC {
// calls. We really want the read of _mark and _prev from this pointer
// to be volatile but making the fields volatile causes all sorts of
// compilation errors.
return
((
volatile
FreeChunk
*
)
addr
)
->
is
F
ree
();
return
((
volatile
FreeChunk
*
)
addr
)
->
is
_f
ree
();
}
bool
is
F
ree
()
const
volatile
{
bool
is
_f
ree
()
const
volatile
{
LP64_ONLY
(
if
(
UseCompressedOops
)
return
mark
()
->
is_cms_free_chunk
();
else
)
return
(((
intptr_t
)
_prev
)
&
0x1
)
==
0x1
;
}
bool
cantCoalesce
()
const
{
assert
(
is
F
ree
(),
"can't get coalesce bit on not free"
);
assert
(
is
_f
ree
(),
"can't get coalesce bit on not free"
);
return
(((
intptr_t
)
_prev
)
&
0x2
)
==
0x2
;
}
void
dontCoalesce
()
{
// the block should be free
assert
(
is
F
ree
(),
"Should look like a free block"
);
assert
(
is
_f
ree
(),
"Should look like a free block"
);
_prev
=
(
FreeChunk
*
)(((
intptr_t
)
_prev
)
|
0x2
);
}
FreeChunk
*
prev
()
const
{
...
...
@@ -103,23 +103,23 @@ class FreeChunk VALUE_OBJ_CLASS_SPEC {
LP64_ONLY
(
if
(
UseCompressedOops
)
return
mark
()
->
get_size
();
else
)
return
_size
;
}
void
set
S
ize
(
size_t
sz
)
{
void
set
_s
ize
(
size_t
sz
)
{
LP64_ONLY
(
if
(
UseCompressedOops
)
set_mark
(
markOopDesc
::
set_size_and_free
(
sz
));
else
)
_size
=
sz
;
}
FreeChunk
*
next
()
const
{
return
_next
;
}
void
link
A
fter
(
FreeChunk
*
ptr
)
{
link
N
ext
(
ptr
);
if
(
ptr
!=
NULL
)
ptr
->
link
P
rev
(
this
);
void
link
_a
fter
(
FreeChunk
*
ptr
)
{
link
_n
ext
(
ptr
);
if
(
ptr
!=
NULL
)
ptr
->
link
_p
rev
(
this
);
}
void
link
N
ext
(
FreeChunk
*
ptr
)
{
_next
=
ptr
;
}
void
link
P
rev
(
FreeChunk
*
ptr
)
{
void
link
_n
ext
(
FreeChunk
*
ptr
)
{
_next
=
ptr
;
}
void
link
_p
rev
(
FreeChunk
*
ptr
)
{
LP64_ONLY
(
if
(
UseCompressedOops
)
_prev
=
ptr
;
else
)
_prev
=
(
FreeChunk
*
)((
intptr_t
)
ptr
|
0x1
);
}
void
clear
N
ext
()
{
_next
=
NULL
;
}
void
clear
_n
ext
()
{
_next
=
NULL
;
}
void
markNotFree
()
{
// Set _prev (klass) to null before (if) clearing the mark word below
_prev
=
NULL
;
...
...
@@ -129,7 +129,7 @@ class FreeChunk VALUE_OBJ_CLASS_SPEC {
set_mark
(
markOopDesc
::
prototype
());
}
#endif
assert
(
!
is
F
ree
(),
"Error"
);
assert
(
!
is
_f
ree
(),
"Error"
);
}
// Return the address past the end of this chunk
...
...
src/share/vm/gc_implementation/concurrentMarkSweep/promotionInfo.cpp
浏览文件 @
2c61150c
...
...
@@ -121,7 +121,7 @@ void PromotionInfo::track(PromotedObject* trackOop) {
void
PromotionInfo
::
track
(
PromotedObject
*
trackOop
,
klassOop
klassOfOop
)
{
// make a copy of header as it may need to be spooled
markOop
mark
=
oop
(
trackOop
)
->
mark
();
trackOop
->
clear
N
ext
();
trackOop
->
clear
_n
ext
();
if
(
mark
->
must_be_preserved_for_cms_scavenge
(
klassOfOop
))
{
// save non-prototypical header, and mark oop
saveDisplacedHeader
(
mark
);
...
...
src/share/vm/gc_implementation/concurrentMarkSweep/promotionInfo.hpp
浏览文件 @
2c61150c
...
...
@@ -43,7 +43,7 @@ class PromotedObject VALUE_OBJ_CLASS_SPEC {
// whose position will depend on endian-ness of the platform.
// This is so that there is no interference with the
// cms_free_bit occupying bit position 7 (lsb == 0)
// when we are using compressed oops; see FreeChunk::is
F
ree().
// when we are using compressed oops; see FreeChunk::is
_f
ree().
// We cannot move the cms_free_bit down because currently
// biased locking code assumes that age bits are contiguous
// with the lock bits. Even if that assumption were relaxed,
...
...
@@ -65,7 +65,7 @@ class PromotedObject VALUE_OBJ_CLASS_SPEC {
};
public:
inline
PromotedObject
*
next
()
const
{
assert
(
!
((
FreeChunk
*
)
this
)
->
is
F
ree
(),
"Error"
);
assert
(
!
((
FreeChunk
*
)
this
)
->
is
_f
ree
(),
"Error"
);
PromotedObject
*
res
;
if
(
UseCompressedOops
)
{
// The next pointer is a compressed oop stored in the top 32 bits
...
...
@@ -85,27 +85,27 @@ class PromotedObject VALUE_OBJ_CLASS_SPEC {
}
else
{
_next
|=
(
intptr_t
)
x
;
}
assert
(
!
((
FreeChunk
*
)
this
)
->
is
F
ree
(),
"Error"
);
assert
(
!
((
FreeChunk
*
)
this
)
->
is
_f
ree
(),
"Error"
);
}
inline
void
setPromotedMark
()
{
_next
|=
promoted_mask
;
assert
(
!
((
FreeChunk
*
)
this
)
->
is
F
ree
(),
"Error"
);
assert
(
!
((
FreeChunk
*
)
this
)
->
is
_f
ree
(),
"Error"
);
}
inline
bool
hasPromotedMark
()
const
{
assert
(
!
((
FreeChunk
*
)
this
)
->
is
F
ree
(),
"Error"
);
assert
(
!
((
FreeChunk
*
)
this
)
->
is
_f
ree
(),
"Error"
);
return
(
_next
&
promoted_mask
)
==
promoted_mask
;
}
inline
void
setDisplacedMark
()
{
_next
|=
displaced_mark
;
assert
(
!
((
FreeChunk
*
)
this
)
->
is
F
ree
(),
"Error"
);
assert
(
!
((
FreeChunk
*
)
this
)
->
is
_f
ree
(),
"Error"
);
}
inline
bool
hasDisplacedMark
()
const
{
assert
(
!
((
FreeChunk
*
)
this
)
->
is
F
ree
(),
"Error"
);
assert
(
!
((
FreeChunk
*
)
this
)
->
is
_f
ree
(),
"Error"
);
return
(
_next
&
displaced_mark
)
!=
0
;
}
inline
void
clear
N
ext
()
{
inline
void
clear
_n
ext
()
{
_next
=
0
;
assert
(
!
((
FreeChunk
*
)
this
)
->
is
F
ree
(),
"Error"
);
assert
(
!
((
FreeChunk
*
)
this
)
->
is
_f
ree
(),
"Error"
);
}
debug_only
(
void
*
next_addr
()
{
return
(
void
*
)
&
_next
;
})
};
...
...
src/share/vm/gc_implementation/concurrentMarkSweep/vmStructs_cms.hpp
浏览文件 @
2c61150c
...
...
@@ -46,7 +46,7 @@
nonstatic_field(LinearAllocBlock, _word_size, size_t) \
nonstatic_field(FreeList<FreeChunk>, _size, size_t) \
nonstatic_field(FreeList<FreeChunk>, _count, ssize_t) \
nonstatic_field(BinaryTreeDictionary<FreeChunk>,_total
S
ize, size_t) \
nonstatic_field(BinaryTreeDictionary<FreeChunk>,_total
_s
ize, size_t) \
nonstatic_field(CompactibleFreeListSpace, _dictionary, FreeBlockDictionary<FreeChunk>*) \
nonstatic_field(CompactibleFreeListSpace, _indexedFreeList[0], FreeList<FreeChunk>) \
nonstatic_field(CompactibleFreeListSpace, _smallLinearAllocBlock, LinearAllocBlock)
...
...
src/share/vm/gc_implementation/shared/allocationStats.hpp
浏览文件 @
2c61150c
...
...
@@ -39,7 +39,7 @@ class AllocationStats VALUE_OBJ_CLASS_SPEC {
// We measure the demand between the end of the previous sweep and
// beginning of this sweep:
// Count(end_last_sweep) - Count(start_this_sweep)
// + split
Births(between) - splitD
eaths(between)
// + split
_births(between) - split_d
eaths(between)
// The above number divided by the time since the end of the
// previous sweep gives us a time rate of demand for blocks
// of this size. We compute a padded average of this rate as
...
...
@@ -51,34 +51,34 @@ class AllocationStats VALUE_OBJ_CLASS_SPEC {
AdaptivePaddedAverage
_demand_rate_estimate
;
ssize_t
_desired
;
// Demand stimate computed as described above
ssize_t
_coal
D
esired
;
// desired +/- small-percent for tuning coalescing
ssize_t
_coal
_d
esired
;
// desired +/- small-percent for tuning coalescing
ssize_t
_surplus
;
// count - (desired +/- small-percent),
// used to tune splitting in best fit
ssize_t
_bfr
S
urp
;
// surplus at start of current sweep
ssize_t
_prev
S
weep
;
// count from end of previous sweep
ssize_t
_before
S
weep
;
// count from before current sweep
ssize_t
_coal
B
irths
;
// additional chunks from coalescing
ssize_t
_coal
D
eaths
;
// loss from coalescing
ssize_t
_split
B
irths
;
// additional chunks from splitting
ssize_t
_split
D
eaths
;
// loss from splitting
size_t
_returned
B
ytes
;
// number of bytes returned to list.
ssize_t
_bfr
_s
urp
;
// surplus at start of current sweep
ssize_t
_prev
_s
weep
;
// count from end of previous sweep
ssize_t
_before
_s
weep
;
// count from before current sweep
ssize_t
_coal
_b
irths
;
// additional chunks from coalescing
ssize_t
_coal
_d
eaths
;
// loss from coalescing
ssize_t
_split
_b
irths
;
// additional chunks from splitting
ssize_t
_split
_d
eaths
;
// loss from splitting
size_t
_returned
_b
ytes
;
// number of bytes returned to list.
public:
void
initialize
(
bool
split_birth
=
false
)
{
AdaptivePaddedAverage
*
dummy
=
new
(
&
_demand_rate_estimate
)
AdaptivePaddedAverage
(
CMS_FLSWeight
,
CMS_FLSPadding
);
_desired
=
0
;
_coal
D
esired
=
0
;
_coal
_d
esired
=
0
;
_surplus
=
0
;
_bfr
S
urp
=
0
;
_prev
S
weep
=
0
;
_before
S
weep
=
0
;
_coal
B
irths
=
0
;
_coal
D
eaths
=
0
;
_split
B
irths
=
(
split_birth
?
1
:
0
);
_split
D
eaths
=
0
;
_returned
B
ytes
=
0
;
_bfr
_s
urp
=
0
;
_prev
_s
weep
=
0
;
_before
_s
weep
=
0
;
_coal
_b
irths
=
0
;
_coal
_d
eaths
=
0
;
_split
_b
irths
=
(
split_birth
?
1
:
0
);
_split
_d
eaths
=
0
;
_returned
_b
ytes
=
0
;
}
AllocationStats
()
{
...
...
@@ -99,12 +99,12 @@ class AllocationStats VALUE_OBJ_CLASS_SPEC {
// vulnerable to noisy glitches. In such cases, we
// ignore the current sample and use currently available
// historical estimates.
assert
(
prev
Sweep
()
+
splitBirths
()
+
coalB
irths
()
// "Total Production Stock"
>=
split
Deaths
()
+
coalD
eaths
()
+
(
ssize_t
)
count
,
// "Current stock + depletion"
assert
(
prev
_sweep
()
+
split_births
()
+
coal_b
irths
()
// "Total Production Stock"
>=
split
_deaths
()
+
coal_d
eaths
()
+
(
ssize_t
)
count
,
// "Current stock + depletion"
"Conservation Principle"
);
if
(
inter_sweep_current
>
_threshold
)
{
ssize_t
demand
=
prev
Sweep
()
-
(
ssize_t
)
count
+
splitBirths
()
+
coalB
irths
()
-
split
Deaths
()
-
coalD
eaths
();
ssize_t
demand
=
prev
_sweep
()
-
(
ssize_t
)
count
+
split_births
()
+
coal_b
irths
()
-
split
_deaths
()
-
coal_d
eaths
();
assert
(
demand
>=
0
,
err_msg
(
"Demand ("
SSIZE_FORMAT
") should be non-negative for "
PTR_FORMAT
" (size="
SIZE_FORMAT
")"
,
...
...
@@ -130,40 +130,40 @@ class AllocationStats VALUE_OBJ_CLASS_SPEC {
ssize_t
desired
()
const
{
return
_desired
;
}
void
set_desired
(
ssize_t
v
)
{
_desired
=
v
;
}
ssize_t
coal
Desired
()
const
{
return
_coalD
esired
;
}
void
set_coal
Desired
(
ssize_t
v
)
{
_coalD
esired
=
v
;
}
ssize_t
coal
_desired
()
const
{
return
_coal_d
esired
;
}
void
set_coal
_desired
(
ssize_t
v
)
{
_coal_d
esired
=
v
;
}
ssize_t
surplus
()
const
{
return
_surplus
;
}
void
set_surplus
(
ssize_t
v
)
{
_surplus
=
v
;
}
void
increment_surplus
()
{
_surplus
++
;
}
void
decrement_surplus
()
{
_surplus
--
;
}
ssize_t
bfr
Surp
()
const
{
return
_bfrS
urp
;
}
void
set_bfr
Surp
(
ssize_t
v
)
{
_bfrS
urp
=
v
;
}
ssize_t
prev
Sweep
()
const
{
return
_prevS
weep
;
}
void
set_prev
Sweep
(
ssize_t
v
)
{
_prevS
weep
=
v
;
}
ssize_t
before
Sweep
()
const
{
return
_beforeS
weep
;
}
void
set_before
Sweep
(
ssize_t
v
)
{
_beforeS
weep
=
v
;
}
ssize_t
bfr
_surp
()
const
{
return
_bfr_s
urp
;
}
void
set_bfr
_surp
(
ssize_t
v
)
{
_bfr_s
urp
=
v
;
}
ssize_t
prev
_sweep
()
const
{
return
_prev_s
weep
;
}
void
set_prev
_sweep
(
ssize_t
v
)
{
_prev_s
weep
=
v
;
}
ssize_t
before
_sweep
()
const
{
return
_before_s
weep
;
}
void
set_before
_sweep
(
ssize_t
v
)
{
_before_s
weep
=
v
;
}
ssize_t
coal
Births
()
const
{
return
_coalB
irths
;
}
void
set_coal
Births
(
ssize_t
v
)
{
_coalB
irths
=
v
;
}
void
increment_coal
Births
()
{
_coalB
irths
++
;
}
ssize_t
coal
_births
()
const
{
return
_coal_b
irths
;
}
void
set_coal
_births
(
ssize_t
v
)
{
_coal_b
irths
=
v
;
}
void
increment_coal
_births
()
{
_coal_b
irths
++
;
}
ssize_t
coal
Deaths
()
const
{
return
_coalD
eaths
;
}
void
set_coal
Deaths
(
ssize_t
v
)
{
_coalD
eaths
=
v
;
}
void
increment_coal
Deaths
()
{
_coalD
eaths
++
;
}
ssize_t
coal
_deaths
()
const
{
return
_coal_d
eaths
;
}
void
set_coal
_deaths
(
ssize_t
v
)
{
_coal_d
eaths
=
v
;
}
void
increment_coal
_deaths
()
{
_coal_d
eaths
++
;
}
ssize_t
split
Births
()
const
{
return
_splitB
irths
;
}
void
set_split
Births
(
ssize_t
v
)
{
_splitB
irths
=
v
;
}
void
increment_split
Births
()
{
_splitB
irths
++
;
}
ssize_t
split
_births
()
const
{
return
_split_b
irths
;
}
void
set_split
_births
(
ssize_t
v
)
{
_split_b
irths
=
v
;
}
void
increment_split
_births
()
{
_split_b
irths
++
;
}
ssize_t
split
Deaths
()
const
{
return
_splitD
eaths
;
}
void
set_split
Deaths
(
ssize_t
v
)
{
_splitD
eaths
=
v
;
}
void
increment_split
Deaths
()
{
_splitD
eaths
++
;
}
ssize_t
split
_deaths
()
const
{
return
_split_d
eaths
;
}
void
set_split
_deaths
(
ssize_t
v
)
{
_split_d
eaths
=
v
;
}
void
increment_split
_deaths
()
{
_split_d
eaths
++
;
}
NOT_PRODUCT
(
size_t
returned
Bytes
()
const
{
return
_returnedB
ytes
;
}
void
set_returned
Bytes
(
size_t
v
)
{
_returnedB
ytes
=
v
;
}
size_t
returned
_bytes
()
const
{
return
_returned_b
ytes
;
}
void
set_returned
_bytes
(
size_t
v
)
{
_returned_b
ytes
=
v
;
}
)
};
...
...
src/share/vm/memory/binaryTreeDictionary.cpp
浏览文件 @
2c61150c
此差异已折叠。
点击以展开。
src/share/vm/memory/binaryTreeDictionary.hpp
浏览文件 @
2c61150c
...
...
@@ -70,22 +70,22 @@ class TreeList: public FreeList<Chunk> {
// Accessors for links in tree.
void
set
L
eft
(
TreeList
<
Chunk
>*
tl
)
{
void
set
_l
eft
(
TreeList
<
Chunk
>*
tl
)
{
_left
=
tl
;
if
(
tl
!=
NULL
)
tl
->
set
P
arent
(
this
);
tl
->
set
_p
arent
(
this
);
}
void
set
R
ight
(
TreeList
<
Chunk
>*
tl
)
{
void
set
_r
ight
(
TreeList
<
Chunk
>*
tl
)
{
_right
=
tl
;
if
(
tl
!=
NULL
)
tl
->
set
P
arent
(
this
);
tl
->
set
_p
arent
(
this
);
}
void
set
P
arent
(
TreeList
<
Chunk
>*
tl
)
{
_parent
=
tl
;
}
void
set
_p
arent
(
TreeList
<
Chunk
>*
tl
)
{
_parent
=
tl
;
}
void
clearLeft
()
{
_left
=
NULL
;
}
void
clear
R
ight
()
{
_right
=
NULL
;
}
void
clear
P
arent
()
{
_parent
=
NULL
;
}
void
initialize
()
{
clearLeft
();
clear
Right
(),
clearP
arent
();
}
void
clear
_r
ight
()
{
_right
=
NULL
;
}
void
clear
_p
arent
()
{
_parent
=
NULL
;
}
void
initialize
()
{
clearLeft
();
clear
_right
(),
clear_p
arent
();
}
// For constructing a TreeList from a Tree chunk or
// address and size.
...
...
@@ -104,16 +104,16 @@ class TreeList: public FreeList<Chunk> {
// use with caution!
TreeChunk
<
Chunk
>*
largest_address
();
// remove
ChunkReplaceIfN
eeded() removes the given "tc" from the TreeList.
// remove
_chunk_replace_if_n
eeded() removes the given "tc" from the TreeList.
// If "tc" is the first chunk in the list, it is also the
// TreeList that is the node in the tree. remove
ChunkReplaceIfN
eeded()
// TreeList that is the node in the tree. remove
_chunk_replace_if_n
eeded()
// returns the possibly replaced TreeList* for the node in
// the tree. It also updates the parent of the original
// node to point to the new node.
TreeList
<
Chunk
>*
remove
ChunkReplaceIfN
eeded
(
TreeChunk
<
Chunk
>*
tc
);
TreeList
<
Chunk
>*
remove
_chunk_replace_if_n
eeded
(
TreeChunk
<
Chunk
>*
tc
);
// See FreeList.
void
return
ChunkAtH
ead
(
TreeChunk
<
Chunk
>*
tc
);
void
return
ChunkAtT
ail
(
TreeChunk
<
Chunk
>*
tc
);
void
return
_chunk_at_h
ead
(
TreeChunk
<
Chunk
>*
tc
);
void
return
_chunk_at_t
ail
(
TreeChunk
<
Chunk
>*
tc
);
};
// A TreeChunk is a subclass of a Chunk that additionally
...
...
@@ -151,7 +151,7 @@ class TreeChunk : public Chunk {
size_t
size
()
const
volatile
{
return
Chunk
::
size
();
}
// debugging
void
verify
TreeChunkL
ist
()
const
;
void
verify
_tree_chunk_l
ist
()
const
;
};
...
...
@@ -159,19 +159,19 @@ template <class Chunk>
class
BinaryTreeDictionary
:
public
FreeBlockDictionary
<
Chunk
>
{
friend
class
VMStructs
;
bool
_splay
;
size_t
_total
S
ize
;
size_t
_total
FreeB
locks
;
size_t
_total
_s
ize
;
size_t
_total
_free_b
locks
;
TreeList
<
Chunk
>*
_root
;
bool
_adaptive_freelists
;
// private accessors
bool
splay
()
const
{
return
_splay
;
}
void
set_splay
(
bool
v
)
{
_splay
=
v
;
}
void
set_total
Size
(
size_t
v
)
{
_totalS
ize
=
v
;
}
virtual
void
inc_total
S
ize
(
size_t
v
);
virtual
void
dec_total
S
ize
(
size_t
v
);
size_t
total
FreeBlocks
()
const
{
return
_totalFreeB
locks
;
}
void
set_total
FreeBlocks
(
size_t
v
)
{
_totalFreeB
locks
=
v
;
}
void
set_total
_size
(
size_t
v
)
{
_total_s
ize
=
v
;
}
virtual
void
inc_total
_s
ize
(
size_t
v
);
virtual
void
dec_total
_s
ize
(
size_t
v
);
size_t
total
_free_blocks
()
const
{
return
_total_free_b
locks
;
}
void
set_total
_free_blocks
(
size_t
v
)
{
_total_free_b
locks
=
v
;
}
TreeList
<
Chunk
>*
root
()
const
{
return
_root
;
}
void
set_root
(
TreeList
<
Chunk
>*
v
)
{
_root
=
v
;
}
bool
adaptive_freelists
()
{
return
_adaptive_freelists
;
}
...
...
@@ -186,46 +186,46 @@ class BinaryTreeDictionary: public FreeBlockDictionary<Chunk> {
// return it. If the chunk
// is the last chunk of that size, remove the node for that size
// from the tree.
TreeChunk
<
Chunk
>*
get
ChunkFromT
ree
(
size_t
size
,
enum
FreeBlockDictionary
<
Chunk
>::
Dither
dither
,
bool
splay
);
TreeChunk
<
Chunk
>*
get
_chunk_from_t
ree
(
size_t
size
,
enum
FreeBlockDictionary
<
Chunk
>::
Dither
dither
,
bool
splay
);
// Return a list of the specified size or NULL from the tree.
// The list is not removed from the tree.
TreeList
<
Chunk
>*
find
L
ist
(
size_t
size
)
const
;
TreeList
<
Chunk
>*
find
_l
ist
(
size_t
size
)
const
;
// Remove this chunk from the tree. If the removal results
// in an empty list in the tree, remove the empty list.
TreeChunk
<
Chunk
>*
remove
ChunkFromT
ree
(
TreeChunk
<
Chunk
>*
tc
);
TreeChunk
<
Chunk
>*
remove
_chunk_from_t
ree
(
TreeChunk
<
Chunk
>*
tc
);
// Remove the node in the trees starting at tl that has the
// minimum value and return it. Repair the tree as needed.
TreeList
<
Chunk
>*
remove
TreeM
inimum
(
TreeList
<
Chunk
>*
tl
);
void
semi
SplayS
tep
(
TreeList
<
Chunk
>*
tl
);
TreeList
<
Chunk
>*
remove
_tree_m
inimum
(
TreeList
<
Chunk
>*
tl
);
void
semi
_splay_s
tep
(
TreeList
<
Chunk
>*
tl
);
// Add this free chunk to the tree.
void
insert
ChunkInT
ree
(
Chunk
*
freeChunk
);
void
insert
_chunk_in_t
ree
(
Chunk
*
freeChunk
);
public:
static
const
size_t
min_tree_chunk_size
=
sizeof
(
TreeChunk
<
Chunk
>
)
/
HeapWordSize
;
void
verify
T
ree
()
const
;
void
verify
_t
ree
()
const
;
// verify that the given chunk is in the tree.
bool
verify
ChunkInFreeLists
(
Chunk
*
tc
)
const
;
bool
verify
_chunk_in_free_list
(
Chunk
*
tc
)
const
;
private:
void
verify
TreeH
elper
(
TreeList
<
Chunk
>*
tl
)
const
;
static
size_t
verify
PrevFreeP
trs
(
TreeList
<
Chunk
>*
tl
);
void
verify
_tree_h
elper
(
TreeList
<
Chunk
>*
tl
)
const
;
static
size_t
verify
_prev_free_p
trs
(
TreeList
<
Chunk
>*
tl
);
// Returns the total number of chunks in the list.
size_t
total
ListL
ength
(
TreeList
<
Chunk
>*
tl
)
const
;
size_t
total
_list_l
ength
(
TreeList
<
Chunk
>*
tl
)
const
;
// Returns the total number of words in the chunks in the tree
// starting at "tl".
size_t
total
SizeInT
ree
(
TreeList
<
Chunk
>*
tl
)
const
;
size_t
total
_size_in_t
ree
(
TreeList
<
Chunk
>*
tl
)
const
;
// Returns the sum of the square of the size of each block
// in the tree starting at "tl".
double
sum_of_squared_block_sizes
(
TreeList
<
Chunk
>*
const
tl
)
const
;
// Returns the total number of free blocks in the tree starting
// at "tl".
size_t
total
FreeBlocksInT
ree
(
TreeList
<
Chunk
>*
tl
)
const
;
size_t
num
FreeB
locks
()
const
;
size_t
total
_free_blocks_in_t
ree
(
TreeList
<
Chunk
>*
tl
)
const
;
size_t
num
_free_b
locks
()
const
;
size_t
treeHeight
()
const
;
size_t
tree
HeightH
elper
(
TreeList
<
Chunk
>*
tl
)
const
;
size_t
total
NodesInT
ree
(
TreeList
<
Chunk
>*
tl
)
const
;
size_t
total
NodesH
elper
(
TreeList
<
Chunk
>*
tl
)
const
;
size_t
tree
_height_h
elper
(
TreeList
<
Chunk
>*
tl
)
const
;
size_t
total
_nodes_in_t
ree
(
TreeList
<
Chunk
>*
tl
)
const
;
size_t
total
_nodes_h
elper
(
TreeList
<
Chunk
>*
tl
)
const
;
public:
// Constructor
...
...
@@ -233,7 +233,7 @@ class BinaryTreeDictionary: public FreeBlockDictionary<Chunk> {
BinaryTreeDictionary
(
MemRegion
mr
,
bool
adaptive_freelists
,
bool
splay
=
false
);
// Public accessors
size_t
total
Size
()
const
{
return
_totalS
ize
;
}
size_t
total
_size
()
const
{
return
_total_s
ize
;
}
// Reset the dictionary to the initial conditions with
// a single free chunk.
...
...
@@ -245,37 +245,37 @@ class BinaryTreeDictionary: public FreeBlockDictionary<Chunk> {
// Return a chunk of size "size" or greater from
// the tree.
// want a better dynamic splay strategy for the future.
Chunk
*
get
C
hunk
(
size_t
size
,
enum
FreeBlockDictionary
<
Chunk
>::
Dither
dither
)
{
Chunk
*
get
_c
hunk
(
size_t
size
,
enum
FreeBlockDictionary
<
Chunk
>::
Dither
dither
)
{
FreeBlockDictionary
<
Chunk
>::
verify_par_locked
();
Chunk
*
res
=
get
ChunkFromT
ree
(
size
,
dither
,
splay
());
assert
(
res
==
NULL
||
res
->
is
F
ree
(),
Chunk
*
res
=
get
_chunk_from_t
ree
(
size
,
dither
,
splay
());
assert
(
res
==
NULL
||
res
->
is
_f
ree
(),
"Should be returning a free chunk"
);
return
res
;
}
void
return
C
hunk
(
Chunk
*
chunk
)
{
void
return
_c
hunk
(
Chunk
*
chunk
)
{
FreeBlockDictionary
<
Chunk
>::
verify_par_locked
();
insert
ChunkInT
ree
(
chunk
);
insert
_chunk_in_t
ree
(
chunk
);
}
void
remove
C
hunk
(
Chunk
*
chunk
)
{
void
remove
_c
hunk
(
Chunk
*
chunk
)
{
FreeBlockDictionary
<
Chunk
>::
verify_par_locked
();
remove
ChunkFromT
ree
((
TreeChunk
<
Chunk
>*
)
chunk
);
assert
(
chunk
->
is
F
ree
(),
"Should still be a free chunk"
);
remove
_chunk_from_t
ree
((
TreeChunk
<
Chunk
>*
)
chunk
);
assert
(
chunk
->
is
_f
ree
(),
"Should still be a free chunk"
);
}
size_t
max
ChunkS
ize
()
const
;
size_t
total
ChunkS
ize
(
debug_only
(
const
Mutex
*
lock
))
const
{
size_t
max
_chunk_s
ize
()
const
;
size_t
total
_chunk_s
ize
(
debug_only
(
const
Mutex
*
lock
))
const
{
debug_only
(
if
(
lock
!=
NULL
&&
lock
->
owned_by_self
())
{
assert
(
total
SizeInTree
(
root
())
==
totalS
ize
(),
"_total
S
ize inconsistency"
);
assert
(
total
_size_in_tree
(
root
())
==
total_s
ize
(),
"_total
_s
ize inconsistency"
);
}
)
return
total
S
ize
();
return
total
_s
ize
();
}
size_t
min
S
ize
()
const
{
size_t
min
_s
ize
()
const
{
return
min_tree_chunk_size
;
}
...
...
@@ -288,40 +288,40 @@ class BinaryTreeDictionary: public FreeBlockDictionary<Chunk> {
// Find the list with size "size" in the binary tree and update
// the statistics in the list according to "split" (chunk was
// split or coalesce) and "birth" (chunk was added or removed).
void
dict
CensusUpd
ate
(
size_t
size
,
bool
split
,
bool
birth
);
void
dict
_census_udp
ate
(
size_t
size
,
bool
split
,
bool
birth
);
// Return true if the dictionary is overpopulated (more chunks of
// this size than desired) for size "size".
bool
coal
DictOverP
opulated
(
size_t
size
);
bool
coal
_dict_over_p
opulated
(
size_t
size
);
// Methods called at the beginning of a sweep to prepare the
// statistics for the sweep.
void
begin
SweepDictC
ensus
(
double
coalSurplusPercent
,
void
begin
_sweep_dict_c
ensus
(
double
coalSurplusPercent
,
float
inter_sweep_current
,
float
inter_sweep_estimate
,
float
intra_sweep_estimate
);
// Methods called after the end of a sweep to modify the
// statistics for the sweep.
void
end
SweepDictC
ensus
(
double
splitSurplusPercent
);
void
end
_sweep_dict_c
ensus
(
double
splitSurplusPercent
);
// Return the largest free chunk in the tree.
Chunk
*
find
LargestD
ict
()
const
;
Chunk
*
find
_largest_d
ict
()
const
;
// Accessors for statistics
void
set
TreeS
urplus
(
double
splitSurplusPercent
);
void
set
TreeH
ints
(
void
);
void
set
_tree_s
urplus
(
double
splitSurplusPercent
);
void
set
_tree_h
ints
(
void
);
// Reset statistics for all the lists in the tree.
void
clear
TreeC
ensus
(
void
);
void
clear
_tree_c
ensus
(
void
);
// Print the statistcis for all the lists in the tree. Also may
// print out summaries.
void
print
DictC
ensus
(
void
)
const
;
void
print
_dict_c
ensus
(
void
)
const
;
void
print_free_lists
(
outputStream
*
st
)
const
;
// For debugging. Returns the sum of the _returned
B
ytes for
// For debugging. Returns the sum of the _returned
_b
ytes for
// all lists in the tree.
size_t
sum
DictReturnedB
ytes
()
PRODUCT_RETURN0
;
// Sets the _returned
B
ytes for all the lists in the tree to zero.
void
initialize
DictReturnedB
ytes
()
PRODUCT_RETURN
;
size_t
sum
_dict_returned_b
ytes
()
PRODUCT_RETURN0
;
// Sets the _returned
_b
ytes for all the lists in the tree to zero.
void
initialize
_dict_returned_b
ytes
()
PRODUCT_RETURN
;
// For debugging. Return the total number of chunks in the dictionary.
size_t
total
C
ount
()
PRODUCT_RETURN0
;
size_t
total
_c
ount
()
PRODUCT_RETURN0
;
void
report
S
tatistics
()
const
;
void
report
_s
tatistics
()
const
;
void
verify
()
const
;
};
...
...
src/share/vm/memory/freeBlockDictionary.cpp
浏览文件 @
2c61150c
...
...
@@ -52,8 +52,8 @@ template <class Chunk> void FreeBlockDictionary<Chunk>::set_par_lock(Mutex* lock
template
<
class
Chunk
>
void
FreeBlockDictionary
<
Chunk
>::
verify_par_locked
()
const
{
#ifdef ASSERT
if
(
ParallelGCThreads
>
0
)
{
Thread
*
my
T
hread
=
Thread
::
current
();
if
(
my
T
hread
->
is_GC_task_thread
())
{
Thread
*
my
_t
hread
=
Thread
::
current
();
if
(
my
_t
hread
->
is_GC_task_thread
())
{
assert
(
par_lock
()
!=
NULL
,
"Should be using locking?"
);
assert_lock_strong
(
par_lock
());
}
...
...
src/share/vm/memory/freeBlockDictionary.hpp
浏览文件 @
2c61150c
...
...
@@ -51,45 +51,45 @@ class FreeBlockDictionary: public CHeapObj {
NOT_PRODUCT
(
Mutex
*
_lock
;)
public:
virtual
void
remove
C
hunk
(
Chunk
*
fc
)
=
0
;
virtual
Chunk
*
get
C
hunk
(
size_t
size
,
Dither
dither
=
atLeast
)
=
0
;
virtual
void
return
C
hunk
(
Chunk
*
chunk
)
=
0
;
virtual
size_t
total
ChunkS
ize
(
debug_only
(
const
Mutex
*
lock
))
const
=
0
;
virtual
size_t
max
ChunkS
ize
()
const
=
0
;
virtual
size_t
min
S
ize
()
const
=
0
;
virtual
void
remove
_c
hunk
(
Chunk
*
fc
)
=
0
;
virtual
Chunk
*
get
_c
hunk
(
size_t
size
,
Dither
dither
=
atLeast
)
=
0
;
virtual
void
return
_c
hunk
(
Chunk
*
chunk
)
=
0
;
virtual
size_t
total
_chunk_s
ize
(
debug_only
(
const
Mutex
*
lock
))
const
=
0
;
virtual
size_t
max
_chunk_s
ize
()
const
=
0
;
virtual
size_t
min
_s
ize
()
const
=
0
;
// Reset the dictionary to the initial conditions for a single
// block.
virtual
void
reset
(
HeapWord
*
addr
,
size_t
size
)
=
0
;
virtual
void
reset
()
=
0
;
virtual
void
dict
CensusUpd
ate
(
size_t
size
,
bool
split
,
bool
birth
)
=
0
;
virtual
bool
coal
DictOverP
opulated
(
size_t
size
)
=
0
;
virtual
void
begin
SweepDictC
ensus
(
double
coalSurplusPercent
,
virtual
void
dict
_census_udp
ate
(
size_t
size
,
bool
split
,
bool
birth
)
=
0
;
virtual
bool
coal
_dict_over_p
opulated
(
size_t
size
)
=
0
;
virtual
void
begin
_sweep_dict_c
ensus
(
double
coalSurplusPercent
,
float
inter_sweep_current
,
float
inter_sweep_estimate
,
float
intra__sweep_current
)
=
0
;
virtual
void
end
SweepDictC
ensus
(
double
splitSurplusPercent
)
=
0
;
virtual
Chunk
*
find
LargestD
ict
()
const
=
0
;
virtual
void
end
_sweep_dict_c
ensus
(
double
splitSurplusPercent
)
=
0
;
virtual
Chunk
*
find
_largest_d
ict
()
const
=
0
;
// verify that the given chunk is in the dictionary.
virtual
bool
verify
ChunkInFreeLists
(
Chunk
*
tc
)
const
=
0
;
virtual
bool
verify
_chunk_in_free_list
(
Chunk
*
tc
)
const
=
0
;
// Sigma_{all_free_blocks} (block_size^2)
virtual
double
sum_of_squared_block_sizes
()
const
=
0
;
virtual
Chunk
*
find_chunk_ends_at
(
HeapWord
*
target
)
const
=
0
;
virtual
void
inc_total
S
ize
(
size_t
v
)
=
0
;
virtual
void
dec_total
S
ize
(
size_t
v
)
=
0
;
virtual
void
inc_total
_s
ize
(
size_t
v
)
=
0
;
virtual
void
dec_total
_s
ize
(
size_t
v
)
=
0
;
NOT_PRODUCT
(
virtual
size_t
sum
DictReturnedB
ytes
()
=
0
;
virtual
void
initialize
DictReturnedB
ytes
()
=
0
;
virtual
size_t
total
C
ount
()
=
0
;
virtual
size_t
sum
_dict_returned_b
ytes
()
=
0
;
virtual
void
initialize
_dict_returned_b
ytes
()
=
0
;
virtual
size_t
total
_c
ount
()
=
0
;
)
virtual
void
report
S
tatistics
()
const
{
virtual
void
report
_s
tatistics
()
const
{
gclog_or_tty
->
print
(
"No statistics available"
);
}
virtual
void
print
DictC
ensus
()
const
=
0
;
virtual
void
print
_dict_c
ensus
()
const
=
0
;
virtual
void
print_free_lists
(
outputStream
*
st
)
const
=
0
;
virtual
void
verify
()
const
=
0
;
...
...
src/share/vm/memory/freeList.cpp
浏览文件 @
2c61150c
...
...
@@ -65,7 +65,7 @@ FreeList<Chunk>::FreeList(Chunk* fc) :
_hint
=
0
;
init_statistics
();
#ifndef PRODUCT
_allocation_stats
.
set_returned
B
ytes
(
size
()
*
HeapWordSize
);
_allocation_stats
.
set_returned
_b
ytes
(
size
()
*
HeapWordSize
);
#endif
}
...
...
@@ -83,7 +83,7 @@ void FreeList<Chunk>::init_statistics(bool split_birth) {
}
template
<
class
Chunk
>
Chunk
*
FreeList
<
Chunk
>::
get
ChunkAtH
ead
()
{
Chunk
*
FreeList
<
Chunk
>::
get
_chunk_at_h
ead
()
{
assert_proper_lock_protection
();
assert
(
head
()
==
NULL
||
head
()
->
prev
()
==
NULL
,
"list invariant"
);
assert
(
tail
()
==
NULL
||
tail
()
->
next
()
==
NULL
,
"list invariant"
);
...
...
@@ -93,7 +93,7 @@ Chunk* FreeList<Chunk>::getChunkAtHead() {
if
(
nextFC
!=
NULL
)
{
// The chunk fc being removed has a "next". Set the "next" to the
// "prev" of fc.
nextFC
->
link
P
rev
(
NULL
);
nextFC
->
link
_p
rev
(
NULL
);
}
else
{
// removed tail of list
link_tail
(
NULL
);
}
...
...
@@ -126,10 +126,10 @@ void FreeList<Chunk>::getFirstNChunksFromList(size_t n, FreeList<Chunk>* fl) {
if
(
new_head
==
NULL
)
{
set_tail
(
NULL
);
}
else
{
new_head
->
link
P
rev
(
NULL
);
new_head
->
link
_p
rev
(
NULL
);
}
// Now we can fix up the tail.
tl
->
link
N
ext
(
NULL
);
tl
->
link
_n
ext
(
NULL
);
// And return the result.
fl
->
set_tail
(
tl
);
fl
->
set_count
(
k
);
...
...
@@ -138,7 +138,7 @@ void FreeList<Chunk>::getFirstNChunksFromList(size_t n, FreeList<Chunk>* fl) {
// Remove this chunk from the list
template
<
class
Chunk
>
void
FreeList
<
Chunk
>::
remove
C
hunk
(
Chunk
*
fc
)
{
void
FreeList
<
Chunk
>::
remove
_c
hunk
(
Chunk
*
fc
)
{
assert_proper_lock_protection
();
assert
(
head
()
!=
NULL
,
"Remove from empty list"
);
assert
(
fc
!=
NULL
,
"Remove a NULL chunk"
);
...
...
@@ -151,7 +151,7 @@ void FreeList<Chunk>::removeChunk(Chunk*fc) {
if
(
nextFC
!=
NULL
)
{
// The chunk fc being removed has a "next". Set the "next" to the
// "prev" of fc.
nextFC
->
link
P
rev
(
prevFC
);
nextFC
->
link
_p
rev
(
prevFC
);
}
else
{
// removed tail of list
link_tail
(
prevFC
);
}
...
...
@@ -160,7 +160,7 @@ void FreeList<Chunk>::removeChunk(Chunk*fc) {
assert
(
nextFC
==
NULL
||
nextFC
->
prev
()
==
NULL
,
"Prev of head should be NULL"
);
}
else
{
prevFC
->
link
N
ext
(
nextFC
);
prevFC
->
link
_n
ext
(
nextFC
);
assert
(
tail
()
!=
prevFC
||
prevFC
->
next
()
==
NULL
,
"Next of tail should be NULL"
);
}
...
...
@@ -169,10 +169,10 @@ void FreeList<Chunk>::removeChunk(Chunk*fc) {
"H/T/C Inconsistency"
);
// clear next and prev fields of fc, debug only
NOT_PRODUCT
(
fc
->
link
P
rev
(
NULL
);
fc
->
link
N
ext
(
NULL
);
fc
->
link
_p
rev
(
NULL
);
fc
->
link
_n
ext
(
NULL
);
)
assert
(
fc
->
is
F
ree
(),
"Should still be a free chunk"
);
assert
(
fc
->
is
_f
ree
(),
"Should still be a free chunk"
);
assert
(
head
()
==
NULL
||
head
()
->
prev
()
==
NULL
,
"list invariant"
);
assert
(
tail
()
==
NULL
||
tail
()
->
next
()
==
NULL
,
"list invariant"
);
assert
(
head
()
==
NULL
||
head
()
->
size
()
==
size
(),
"wrong item on list"
);
...
...
@@ -181,7 +181,7 @@ void FreeList<Chunk>::removeChunk(Chunk*fc) {
// Add this chunk at the head of the list.
template
<
class
Chunk
>
void
FreeList
<
Chunk
>::
return
ChunkAtH
ead
(
Chunk
*
chunk
,
bool
record_return
)
{
void
FreeList
<
Chunk
>::
return
_chunk_at_h
ead
(
Chunk
*
chunk
,
bool
record_return
)
{
assert_proper_lock_protection
();
assert
(
chunk
!=
NULL
,
"insert a NULL chunk"
);
assert
(
size
()
==
chunk
->
size
(),
"Wrong size"
);
...
...
@@ -190,7 +190,7 @@ void FreeList<Chunk>::returnChunkAtHead(Chunk* chunk, bool record_return) {
Chunk
*
oldHead
=
head
();
assert
(
chunk
!=
oldHead
,
"double insertion"
);
chunk
->
link
A
fter
(
oldHead
);
chunk
->
link
_a
fter
(
oldHead
);
link_head
(
chunk
);
if
(
oldHead
==
NULL
)
{
// only chunk in list
assert
(
tail
()
==
NULL
,
"inconsistent FreeList"
);
...
...
@@ -199,7 +199,7 @@ void FreeList<Chunk>::returnChunkAtHead(Chunk* chunk, bool record_return) {
increment_count
();
// of # of chunks in list
DEBUG_ONLY
(
if
(
record_return
)
{
increment_returned
B
ytes_by
(
size
()
*
HeapWordSize
);
increment_returned
_b
ytes_by
(
size
()
*
HeapWordSize
);
}
)
assert
(
head
()
==
NULL
||
head
()
->
prev
()
==
NULL
,
"list invariant"
);
...
...
@@ -209,14 +209,14 @@ void FreeList<Chunk>::returnChunkAtHead(Chunk* chunk, bool record_return) {
}
template
<
class
Chunk
>
void
FreeList
<
Chunk
>::
return
ChunkAtH
ead
(
Chunk
*
chunk
)
{
void
FreeList
<
Chunk
>::
return
_chunk_at_h
ead
(
Chunk
*
chunk
)
{
assert_proper_lock_protection
();
return
ChunkAtH
ead
(
chunk
,
true
);
return
_chunk_at_h
ead
(
chunk
,
true
);
}
// Add this chunk at the tail of the list.
template
<
class
Chunk
>
void
FreeList
<
Chunk
>::
return
ChunkAtT
ail
(
Chunk
*
chunk
,
bool
record_return
)
{
void
FreeList
<
Chunk
>::
return
_chunk_at_t
ail
(
Chunk
*
chunk
,
bool
record_return
)
{
assert_proper_lock_protection
();
assert
(
head
()
==
NULL
||
head
()
->
prev
()
==
NULL
,
"list invariant"
);
assert
(
tail
()
==
NULL
||
tail
()
->
next
()
==
NULL
,
"list invariant"
);
...
...
@@ -226,7 +226,7 @@ void FreeList<Chunk>::returnChunkAtTail(Chunk* chunk, bool record_return) {
Chunk
*
oldTail
=
tail
();
assert
(
chunk
!=
oldTail
,
"double insertion"
);
if
(
oldTail
!=
NULL
)
{
oldTail
->
link
A
fter
(
chunk
);
oldTail
->
link
_a
fter
(
chunk
);
}
else
{
// only chunk in list
assert
(
head
()
==
NULL
,
"inconsistent FreeList"
);
link_head
(
chunk
);
...
...
@@ -235,7 +235,7 @@ void FreeList<Chunk>::returnChunkAtTail(Chunk* chunk, bool record_return) {
increment_count
();
// of # of chunks in list
DEBUG_ONLY
(
if
(
record_return
)
{
increment_returned
B
ytes_by
(
size
()
*
HeapWordSize
);
increment_returned
_b
ytes_by
(
size
()
*
HeapWordSize
);
}
)
assert
(
head
()
==
NULL
||
head
()
->
prev
()
==
NULL
,
"list invariant"
);
...
...
@@ -245,8 +245,8 @@ void FreeList<Chunk>::returnChunkAtTail(Chunk* chunk, bool record_return) {
}
template
<
class
Chunk
>
void
FreeList
<
Chunk
>::
return
ChunkAtT
ail
(
Chunk
*
chunk
)
{
return
ChunkAtT
ail
(
chunk
,
true
);
void
FreeList
<
Chunk
>::
return
_chunk_at_t
ail
(
Chunk
*
chunk
)
{
return
_chunk_at_t
ail
(
chunk
,
true
);
}
template
<
class
Chunk
>
...
...
@@ -262,8 +262,8 @@ void FreeList<Chunk>::prepend(FreeList<Chunk>* fl) {
Chunk
*
fl_tail
=
fl
->
tail
();
Chunk
*
this_head
=
head
();
assert
(
fl_tail
->
next
()
==
NULL
,
"Well-formedness of fl"
);
fl_tail
->
link
N
ext
(
this_head
);
this_head
->
link
P
rev
(
fl_tail
);
fl_tail
->
link
_n
ext
(
this_head
);
this_head
->
link
_p
rev
(
fl_tail
);
set_head
(
fl
->
head
());
set_count
(
count
()
+
fl
->
count
());
}
...
...
@@ -273,10 +273,10 @@ void FreeList<Chunk>::prepend(FreeList<Chunk>* fl) {
}
}
// verify
ChunkInFreeLists
() is used to verify that an item is in this free list.
// verify
_chunk_in_free_list
() is used to verify that an item is in this free list.
// It is used as a debugging aid.
template
<
class
Chunk
>
bool
FreeList
<
Chunk
>::
verify
ChunkInFreeLists
(
Chunk
*
fc
)
const
{
bool
FreeList
<
Chunk
>::
verify
_chunk_in_free_list
(
Chunk
*
fc
)
const
{
// This is an internal consistency check, not part of the check that the
// chunk is in the free lists.
guarantee
(
fc
->
size
()
==
size
(),
"Wrong list is being searched"
);
...
...
@@ -302,21 +302,21 @@ void FreeList<Chunk>::verify_stats() const {
// dictionary for example, this might be the first block and
// in that case there would be no place that we could record
// the stats (which are kept in the block itself).
assert
((
_allocation_stats
.
prev
Sweep
()
+
_allocation_stats
.
splitB
irths
()
+
_allocation_stats
.
coal
B
irths
()
+
1
)
// Total Production Stock + 1
>=
(
_allocation_stats
.
split
Deaths
()
+
_allocation_stats
.
coalD
eaths
()
assert
((
_allocation_stats
.
prev
_sweep
()
+
_allocation_stats
.
split_b
irths
()
+
_allocation_stats
.
coal
_b
irths
()
+
1
)
// Total Production Stock + 1
>=
(
_allocation_stats
.
split
_deaths
()
+
_allocation_stats
.
coal_d
eaths
()
+
(
ssize_t
)
count
()),
// Total Current Stock + depletion
err_msg
(
"FreeList "
PTR_FORMAT
" of size "
SIZE_FORMAT
" violates Conservation Principle: "
"prev
S
weep("
SIZE_FORMAT
")"
" + split
B
irths("
SIZE_FORMAT
")"
" + coal
B
irths("
SIZE_FORMAT
") + 1 >= "
" split
D
eaths("
SIZE_FORMAT
")"
" coal
D
eaths("
SIZE_FORMAT
")"
"prev
_s
weep("
SIZE_FORMAT
")"
" + split
_b
irths("
SIZE_FORMAT
")"
" + coal
_b
irths("
SIZE_FORMAT
") + 1 >= "
" split
_d
eaths("
SIZE_FORMAT
")"
" coal
_d
eaths("
SIZE_FORMAT
")"
" + count("
SSIZE_FORMAT
")"
,
this
,
_size
,
_allocation_stats
.
prev
Sweep
(),
_allocation_stats
.
splitB
irths
(),
_allocation_stats
.
split
Births
(),
_allocation_stats
.
splitD
eaths
(),
_allocation_stats
.
coal
D
eaths
(),
count
()));
this
,
_size
,
_allocation_stats
.
prev
_sweep
(),
_allocation_stats
.
split_b
irths
(),
_allocation_stats
.
split
_births
(),
_allocation_stats
.
split_d
eaths
(),
_allocation_stats
.
coal
_d
eaths
(),
count
()));
}
template
<
class
Chunk
>
...
...
@@ -360,8 +360,8 @@ void FreeList<Chunk>::print_on(outputStream* st, const char* c) const {
st
->
print
(
"
\t
"
SSIZE_FORMAT_W
(
14
)
"
\t
"
SSIZE_FORMAT_W
(
14
)
"
\t
"
SSIZE_FORMAT_W
(
14
)
"
\t
"
SSIZE_FORMAT_W
(
14
)
"
\t
"
SSIZE_FORMAT_W
(
14
)
"
\t
"
SSIZE_FORMAT_W
(
14
)
"
\t
"
SSIZE_FORMAT_W
(
14
)
"
\t
"
SSIZE_FORMAT_W
(
14
)
"
\t
"
SSIZE_FORMAT_W
(
14
)
"
\t
"
SSIZE_FORMAT_W
(
14
)
"
\n
"
,
bfr
Surp
(),
surplus
(),
desired
(),
prevSweep
(),
beforeS
weep
(),
count
(),
coal
Births
(),
coalDeaths
(),
splitBirths
(),
splitD
eaths
());
bfr
_surp
(),
surplus
(),
desired
(),
prev_sweep
(),
before_s
weep
(),
count
(),
coal
_births
(),
coal_deaths
(),
split_births
(),
split_d
eaths
());
}
#ifndef SERIALGC
...
...
src/share/vm/memory/freeList.hpp
浏览文件 @
2c61150c
...
...
@@ -119,7 +119,7 @@ class FreeList VALUE_OBJ_CLASS_SPEC {
// If this method is not used (just set the head instead),
// this check can be avoided.
if
(
v
!=
NULL
)
{
v
->
link
P
rev
(
NULL
);
v
->
link
_p
rev
(
NULL
);
}
}
...
...
@@ -138,7 +138,7 @@ class FreeList VALUE_OBJ_CLASS_SPEC {
assert_proper_lock_protection
();
set_tail
(
v
);
if
(
v
!=
NULL
)
{
v
->
clear
N
ext
();
v
->
clear
_n
ext
();
}
}
...
...
@@ -185,12 +185,12 @@ class FreeList VALUE_OBJ_CLASS_SPEC {
inter_sweep_estimate
,
intra_sweep_estimate
);
}
ssize_t
coal
D
esired
()
const
{
return
_allocation_stats
.
coal
D
esired
();
ssize_t
coal
_d
esired
()
const
{
return
_allocation_stats
.
coal
_d
esired
();
}
void
set_coal
D
esired
(
ssize_t
v
)
{
void
set_coal
_d
esired
(
ssize_t
v
)
{
assert_proper_lock_protection
();
_allocation_stats
.
set_coal
D
esired
(
v
);
_allocation_stats
.
set_coal
_d
esired
(
v
);
}
ssize_t
surplus
()
const
{
...
...
@@ -209,106 +209,106 @@ class FreeList VALUE_OBJ_CLASS_SPEC {
_allocation_stats
.
decrement_surplus
();
}
ssize_t
bfr
S
urp
()
const
{
return
_allocation_stats
.
bfr
S
urp
();
ssize_t
bfr
_s
urp
()
const
{
return
_allocation_stats
.
bfr
_s
urp
();
}
void
set_bfr
S
urp
(
ssize_t
v
)
{
void
set_bfr
_s
urp
(
ssize_t
v
)
{
assert_proper_lock_protection
();
_allocation_stats
.
set_bfr
S
urp
(
v
);
_allocation_stats
.
set_bfr
_s
urp
(
v
);
}
ssize_t
prev
S
weep
()
const
{
return
_allocation_stats
.
prev
S
weep
();
ssize_t
prev
_s
weep
()
const
{
return
_allocation_stats
.
prev
_s
weep
();
}
void
set_prev
S
weep
(
ssize_t
v
)
{
void
set_prev
_s
weep
(
ssize_t
v
)
{
assert_proper_lock_protection
();
_allocation_stats
.
set_prev
S
weep
(
v
);
_allocation_stats
.
set_prev
_s
weep
(
v
);
}
ssize_t
before
S
weep
()
const
{
return
_allocation_stats
.
before
S
weep
();
ssize_t
before
_s
weep
()
const
{
return
_allocation_stats
.
before
_s
weep
();
}
void
set_before
S
weep
(
ssize_t
v
)
{
void
set_before
_s
weep
(
ssize_t
v
)
{
assert_proper_lock_protection
();
_allocation_stats
.
set_before
S
weep
(
v
);
_allocation_stats
.
set_before
_s
weep
(
v
);
}
ssize_t
coal
B
irths
()
const
{
return
_allocation_stats
.
coal
B
irths
();
ssize_t
coal
_b
irths
()
const
{
return
_allocation_stats
.
coal
_b
irths
();
}
void
set_coal
B
irths
(
ssize_t
v
)
{
void
set_coal
_b
irths
(
ssize_t
v
)
{
assert_proper_lock_protection
();
_allocation_stats
.
set_coal
B
irths
(
v
);
_allocation_stats
.
set_coal
_b
irths
(
v
);
}
void
increment_coal
B
irths
()
{
void
increment_coal
_b
irths
()
{
assert_proper_lock_protection
();
_allocation_stats
.
increment_coal
B
irths
();
_allocation_stats
.
increment_coal
_b
irths
();
}
ssize_t
coal
D
eaths
()
const
{
return
_allocation_stats
.
coal
D
eaths
();
ssize_t
coal
_d
eaths
()
const
{
return
_allocation_stats
.
coal
_d
eaths
();
}
void
set_coal
D
eaths
(
ssize_t
v
)
{
void
set_coal
_d
eaths
(
ssize_t
v
)
{
assert_proper_lock_protection
();
_allocation_stats
.
set_coal
D
eaths
(
v
);
_allocation_stats
.
set_coal
_d
eaths
(
v
);
}
void
increment_coal
D
eaths
()
{
void
increment_coal
_d
eaths
()
{
assert_proper_lock_protection
();
_allocation_stats
.
increment_coal
D
eaths
();
_allocation_stats
.
increment_coal
_d
eaths
();
}
ssize_t
split
B
irths
()
const
{
return
_allocation_stats
.
split
B
irths
();
ssize_t
split
_b
irths
()
const
{
return
_allocation_stats
.
split
_b
irths
();
}
void
set_split
B
irths
(
ssize_t
v
)
{
void
set_split
_b
irths
(
ssize_t
v
)
{
assert_proper_lock_protection
();
_allocation_stats
.
set_split
B
irths
(
v
);
_allocation_stats
.
set_split
_b
irths
(
v
);
}
void
increment_split
B
irths
()
{
void
increment_split
_b
irths
()
{
assert_proper_lock_protection
();
_allocation_stats
.
increment_split
B
irths
();
_allocation_stats
.
increment_split
_b
irths
();
}
ssize_t
split
D
eaths
()
const
{
return
_allocation_stats
.
split
D
eaths
();
ssize_t
split
_d
eaths
()
const
{
return
_allocation_stats
.
split
_d
eaths
();
}
void
set_split
D
eaths
(
ssize_t
v
)
{
void
set_split
_d
eaths
(
ssize_t
v
)
{
assert_proper_lock_protection
();
_allocation_stats
.
set_split
D
eaths
(
v
);
_allocation_stats
.
set_split
_d
eaths
(
v
);
}
void
increment_split
D
eaths
()
{
void
increment_split
_d
eaths
()
{
assert_proper_lock_protection
();
_allocation_stats
.
increment_split
D
eaths
();
_allocation_stats
.
increment_split
_d
eaths
();
}
NOT_PRODUCT
(
// For debugging. The "_returned
B
ytes" in all the lists are summed
// For debugging. The "_returned
_b
ytes" in all the lists are summed
// and compared with the total number of bytes swept during a
// collection.
size_t
returned
Bytes
()
const
{
return
_allocation_stats
.
returnedB
ytes
();
}
void
set_returned
Bytes
(
size_t
v
)
{
_allocation_stats
.
set_returnedB
ytes
(
v
);
}
void
increment_returned
B
ytes_by
(
size_t
v
)
{
_allocation_stats
.
set_returned
Bytes
(
_allocation_stats
.
returnedB
ytes
()
+
v
);
size_t
returned
_bytes
()
const
{
return
_allocation_stats
.
returned_b
ytes
();
}
void
set_returned
_bytes
(
size_t
v
)
{
_allocation_stats
.
set_returned_b
ytes
(
v
);
}
void
increment_returned
_b
ytes_by
(
size_t
v
)
{
_allocation_stats
.
set_returned
_bytes
(
_allocation_stats
.
returned_b
ytes
()
+
v
);
}
)
// Unlink head of list and return it. Returns NULL if
// the list is empty.
Chunk
*
get
ChunkAtH
ead
();
Chunk
*
get
_chunk_at_h
ead
();
// Remove the first "n" or "count", whichever is smaller, chunks from the
// list, setting "fl", which is required to be empty, to point to them.
void
getFirstNChunksFromList
(
size_t
n
,
FreeList
<
Chunk
>*
fl
);
// Unlink this chunk from it's free list
void
remove
C
hunk
(
Chunk
*
fc
);
void
remove
_c
hunk
(
Chunk
*
fc
);
// Add this chunk to this free list.
void
return
ChunkAtH
ead
(
Chunk
*
fc
);
void
return
ChunkAtT
ail
(
Chunk
*
fc
);
void
return
_chunk_at_h
ead
(
Chunk
*
fc
);
void
return
_chunk_at_t
ail
(
Chunk
*
fc
);
// Similar to returnChunk* but also records some diagnostic
// information.
void
return
ChunkAtH
ead
(
Chunk
*
fc
,
bool
record_return
);
void
return
ChunkAtT
ail
(
Chunk
*
fc
,
bool
record_return
);
void
return
_chunk_at_h
ead
(
Chunk
*
fc
,
bool
record_return
);
void
return
_chunk_at_t
ail
(
Chunk
*
fc
,
bool
record_return
);
// Prepend "fl" (whose size is required to be the same as that of "this")
// to the front of "this" list.
...
...
@@ -316,7 +316,7 @@ class FreeList VALUE_OBJ_CLASS_SPEC {
// Verify that the chunk is in the list.
// found. Return NULL if "fc" is not found.
bool
verify
ChunkInFreeLists
(
Chunk
*
fc
)
const
;
bool
verify
_chunk_in_free_list
(
Chunk
*
fc
)
const
;
// Stats verification
void
verify_stats
()
const
PRODUCT_RETURN
;
...
...
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录