-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathapp.gd
More file actions
172 lines (140 loc) · 4.81 KB
/
app.gd
File metadata and controls
172 lines (140 loc) · 4.81 KB
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
# Performance comparison using a Dictionary as an Array
extends Node
const ITEM_COUNT := 100_000_000
const ITEM_COUNT_DISPLAY := "100,000,000"
var start_time:int
var start_mem:int
var ordered:Array
var packed_ordered:PackedInt64Array
var ordered_iter_time:int
var random:Array
var packed_random:PackedInt64Array
var random_iter_time:int
func _ready() -> void:
# pause the main loop (probably not necessary, but no reason not to)
get_tree().paused = true
# display processor and memory info
print("%s %s Cores" % [OS.get_processor_name(), OS.get_processor_count()])
var m := OS.get_memory_info()
print("%s mb Physical Memory, %s mb Available, %s mb Free\n" % [m.physical / 1_000_000, m.available / 1_000_000, m.free / 1_000_000])
# create two arrays of size ITEM_COUNT, one ordered, one randomized (for repeatable random ordering)
ordered = range(ITEM_COUNT)
packed_ordered = PackedInt64Array(ordered)
random = ordered.duplicate()
random.shuffle()
packed_random = PackedInt64Array(random)
test_begin("Iterate the ordered array")
for i:int in ordered:
pass
ordered_iter_time = Time.get_ticks_usec() - start_time
test_end()
test_begin("Iterate the packed ordered array")
for i:int in packed_ordered:
pass
test_end()
test_begin("Iterate the random array")
for i:int in random:
pass
random_iter_time = Time.get_ticks_usec() - start_time
test_end()
test_begin("Iterate the packed random array")
for i:int in packed_random:
pass
test_end()
test_begin("Array: add %s elements in order via append()" % [ITEM_COUNT_DISPLAY])
var a1:Array[int]
for i:int in ordered:
a1.append(i)
test_end(ordered_iter_time)
a1.clear()
test_begin("Array: add %s elements in order, preallocate with resize()" % [ITEM_COUNT_DISPLAY])
var a2:Array[int]
a2.resize(ITEM_COUNT)
for i:int in ordered:
a2[i] = i
test_end(ordered_iter_time)
a2.clear()
test_begin("Array: add %s elements in random order, dynamically extend with resize()" % [ITEM_COUNT_DISPLAY])
var a3:Array[int]
for i:int in random:
if a3.size() < i + 1:
a3.resize(i + 1)
a3[i] = i
test_end(random_iter_time)
a3.clear()
test_begin("Array: add %s elements in random order, preallocate with resize()" % [ITEM_COUNT_DISPLAY])
var a4:Array[int]
a4.resize(ITEM_COUNT)
for i:int in random:
a4[i] = i
test_end(random_iter_time)
test_begin("Array: access all %s elements in order" % [ITEM_COUNT_DISPLAY])
for i:int in ordered:
var n := a4[i]
test_end(ordered_iter_time)
test_begin("Array: access all %s elements in random order" % [ITEM_COUNT_DISPLAY])
for i:int in random:
var n := a4[i]
test_end(random_iter_time)
test_begin("PackedInt64Array: add %s elements in order via append()" % [ITEM_COUNT_DISPLAY])
var p1:PackedInt64Array
for i:int in ordered:
p1.append(i)
test_end(ordered_iter_time)
p1.clear()
test_begin("PackedInt64Array: add %s elements in order, preallocate with resize()" % [ITEM_COUNT_DISPLAY])
var p2:PackedInt64Array
p2.resize(ITEM_COUNT)
for i:int in ordered:
p2[i] = i
test_end(ordered_iter_time)
p2.clear()
test_begin("PackedInt64Array: add %s elements in random order, dynamically extend with resize()" % [ITEM_COUNT_DISPLAY])
var p3:PackedInt64Array
for i:int in random:
if p3.size() < i + 1:
p3.resize(i + 1)
p3[i] = i
test_end(random_iter_time)
p3.clear()
test_begin("PackedInt64Array: add %s elements in random order, preallocate with resize()" % [ITEM_COUNT_DISPLAY])
var p4:PackedInt64Array
p4.resize(ITEM_COUNT)
for i:int in random:
p4[i] = i
test_end(random_iter_time)
test_begin("PackedInt64Array: access all %s elements in order" % [ITEM_COUNT_DISPLAY])
for i:int in ordered:
var n := p4[i]
test_end(ordered_iter_time)
test_begin("PackedInt64Array: access all %s elements in random order" % [ITEM_COUNT_DISPLAY])
for i:int in random:
var n := p4[i]
test_end(random_iter_time)
test_begin("Dictionary: add %s elements in order" % [ITEM_COUNT_DISPLAY])
var d1:Dictionary
for i:int in ordered:
d1[i] = i
test_end(ordered_iter_time)
test_begin("Dictionary: add %s elements in random order" % [ITEM_COUNT_DISPLAY])
var d2:Dictionary
for i:int in random:
d2[i] = i
test_end(random_iter_time)
d2.clear()
test_begin("Dictionary: access all %s elements in order" % [ITEM_COUNT_DISPLAY])
for i:int in ordered:
var n:int = d1[i]
test_end(ordered_iter_time)
test_begin("Dictionary: access all %s elements in random order" % [ITEM_COUNT_DISPLAY])
for i:int in random:
var n:int = d1[i]
test_end(random_iter_time)
func test_begin(msg:String) -> void:
print(msg)
start_time = Time.get_ticks_usec()
start_mem = OS.get_static_memory_usage()
func test_end(iter_time:int = 0) -> void:
var time := (Time.get_ticks_usec() - start_time - iter_time) / 1_000_000.0
var mem := (OS.get_static_memory_usage() - start_mem) / 1_000_000.0
print("done: time = %s sec, mem = %s mb\n" % [time, mem])