1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
|
discard """
outputsub: "Success!"
"""
# This is adapted from a benchmark written by John Ellis and Pete Kovac
# of Post Communications.
# It was modified by Hans Boehm of Silicon Graphics.
#
# This is no substitute for real applications. No actual application
# is likely to behave in exactly this way. However, this benchmark was
# designed to be more representative of real applications than other
# Java GC benchmarks of which we are aware.
# It attempts to model those properties of allocation requests that
# are important to current GC techniques.
# It is designed to be used either to obtain a single overall performance
# number, or to give a more detailed estimate of how collector
# performance varies with object lifetimes. It prints the time
# required to allocate and collect balanced binary trees of various
# sizes. Smaller trees result in shorter object lifetimes. Each cycle
# allocates roughly the same amount of memory.
# Two data structures are kept around during the entire process, so
# that the measured performance is representative of applications
# that maintain some live in-memory data. One of these is a tree
# containing many pointers. The other is a large array containing
# double precision floating point numbers. Both should be of comparable
# size.
#
# The results are only really meaningful together with a specification
# of how much memory was used. It is possible to trade memory for
# better time performance. This benchmark should be run in a 32 MB
# heap, though we don't currently know how to enforce that uniformly.
#
# Unlike the original Ellis and Kovac benchmark, we do not attempt
# measure pause times. This facility should eventually be added back
# in. There are several reasons for omitting it for now. The original
# implementation depended on assumptions about the thread scheduler
# that don't hold uniformly. The results really measure both the
# scheduler and GC. Pause time measurements tend to not fit well with
# current benchmark suites. As far as we know, none of the current
# commercial Java implementations seriously attempt to minimize GC pause
# times.
#
# Known deficiencies:
# - No way to check on memory use
# - No cyclic data structures
# - No attempt to measure variation with object size
# - Results are sensitive to locking cost, but we don't
# check for proper locking
#
import
strutils, times
type
PNode = ref TNode
TNode {.final, acyclic.} = object
left, right: PNode
i, j: int
proc newNode(L, r: sink PNode): PNode =
new(result)
result.left = L
result.right = r
const
kStretchTreeDepth = 18 # about 16Mb
kLongLivedTreeDepth = 16 # about 4Mb
kArraySize = 500000 # about 4Mb
kMinTreeDepth = 4
kMaxTreeDepth = 16
when not declared(withScratchRegion):
template withScratchRegion(body: untyped) = body
# Nodes used by a tree of a given size
proc treeSize(i: int): int = return ((1 shl (i + 1)) - 1)
# Number of iterations to use for a given tree depth
proc numIters(i: int): int =
return 2 * treeSize(kStretchTreeDepth) div treeSize(i)
# Build tree top down, assigning to older objects.
proc populate(iDepth: int, thisNode: PNode) =
if iDepth <= 0:
return
else:
new(thisNode.left)
new(thisNode.right)
populate(iDepth-1, thisNode.left)
populate(iDepth-1, thisNode.right)
# Build tree bottom-up
proc makeTree(iDepth: int): PNode =
if iDepth <= 0:
new(result)
else:
return newNode(makeTree(iDepth-1), makeTree(iDepth-1))
proc printDiagnostics() =
echo("Total memory available: " & formatSize(getTotalMem()) & " bytes")
echo("Free memory: " & formatSize(getFreeMem()) & " bytes")
proc timeConstruction(depth: int) =
var
root, tempTree: PNode
iNumIters: int
iNumIters = numIters(depth)
echo("Creating " & $iNumIters & " trees of depth " & $depth)
var t = epochTime()
for i in 0..iNumIters-1:
new(tempTree)
populate(depth, tempTree)
tempTree = nil
echo("\tTop down construction took " & $(epochTime() - t) & "msecs")
t = epochTime()
for i in 0..iNumIters-1:
tempTree = makeTree(depth)
tempTree = nil
echo("\tBottom up construction took " & $(epochTime() - t) & "msecs")
type
tMyArray = seq[float]
proc main() =
var
root, longLivedTree, tempTree: PNode
myarray: tMyArray
echo("Garbage Collector Test")
echo(" Stretching memory with a binary tree of depth " & $kStretchTreeDepth)
printDiagnostics()
var t = epochTime()
# Stretch the memory space quickly
withScratchRegion:
tempTree = makeTree(kStretchTreeDepth)
tempTree = nil
# Create a long lived object
echo(" Creating a long-lived binary tree of depth " &
$kLongLivedTreeDepth)
new(longLivedTree)
populate(kLongLivedTreeDepth, longLivedTree)
# Create long-lived array, filling half of it
echo(" Creating a long-lived array of " & $kArraySize & " doubles")
withScratchRegion:
newSeq(myarray, kArraySize)
for i in 0..kArraySize div 2 - 1:
myarray[i] = 1.0 / toFloat(i)
printDiagnostics()
var d = kMinTreeDepth
while d <= kMaxTreeDepth:
withScratchRegion:
timeConstruction(d)
inc(d, 2)
if longLivedTree == nil or myarray[1000] != 1.0/1000.0:
echo("Failed")
# fake reference to LongLivedTree
# and array to keep them from being optimized away
var elapsed = epochTime() - t
printDiagnostics()
echo("Completed in " & $elapsed & "s. Success!")
when declared(getMaxMem):
echo "Max memory ", formatSize getMaxMem()
when defined(GC_setMaxPause):
GC_setMaxPause 2_000
when defined(gcDestructors):
let mem = getOccupiedMem()
main()
when defined(gcDestructors):
doAssert getOccupiedMem() == mem
|
