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
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
|
# 2005 November 30
#
# The author disclaims copyright to this source code. In place of
# a legal notice, here is a blessing:
#
# May you do good and not evil.
# May you find forgiveness for yourself and forgive others.
# May you share freely, never taking more than you give.
#
#***********************************************************************
#
# This file contains test cases focused on the two memory-management APIs,
# sqlite3_soft_heap_limit() and sqlite3_release_memory().
#
# $Id: malloc5.test,v 1.5 2006/01/09 09:59:49 danielk1977 Exp $
#---------------------------------------------------------------------------
# NOTES ON EXPECTED BEHAVIOUR
#
#---------------------------------------------------------------------------
set testdir [file dirname $argv0]
source $testdir/tester.tcl
db close
# Only run these tests if memory debugging is turned on.
if {[info command sqlite_malloc_stat]==""} {
puts "Skipping malloc tests: not compiled with -DSQLITE_MEMDEBUG..."
finish_test
return
}
# Skip these tests if OMIT_MEMORY_MANAGEMENT was defined at compile time.
ifcapable !memorymanage {
finish_test
return
}
sqlite3_enable_memory_management 1
sqlite3 db test.db
do_test malloc5-1.1 {
# Simplest possible test. Call sqlite3_release_memory when there is exactly
# one unused page in a single pager cache. This test case set's the
# value of the ::pgalloc variable, which is used in subsequent tests.
#
# Note: Even though executing this statement on an empty database
# modifies 2 pages (the root of sqlite_master and the new root page),
# the sqlite_master root (page 1) is never freed because the btree layer
# retains a reference to it for the entire transaction.
execsql {
BEGIN;
CREATE TABLE abc(a, b, c);
}
set ::pgalloc [sqlite3_release_memory]
expr $::pgalloc > 0
} {1}
do_test malloc5-1.2 {
# Test that the transaction started in the above test is still active.
# Because the page freed had been written to, freeing it required a
# journal sync and exclusive lock on the database file. Test the file
# appears to be locked.
sqlite3 db2 test.db
catchsql {
SELECT * FROM abc;
} db2
} {1 {database is locked}}
do_test malloc5-1.3 {
# Again call [sqlite3_release_memory] when there is exactly one unused page
# in the cache. The same amount of memory is required, but no journal-sync
# or exclusive lock should be established.
execsql {
COMMIT;
BEGIN;
SELECT * FROM abc;
}
sqlite3_release_memory
} $::pgalloc
do_test malloc5-1.4 {
# Database should not be locked this time.
catchsql {
SELECT * FROM abc;
} db2
} {0 {}}
do_test malloc5-1.5 {
# Manipulate the cache so that it contains two unused pages. One requires
# a journal-sync to free, the other does not.
execsql {
SELECT * FROM abc;
CREATE TABLE def(d, e, f);
}
sqlite3_release_memory 500
} $::pgalloc
do_test malloc5-1.6 {
# Database should not be locked this time. The above test case only
# requested 500 bytes of memory, which can be obtained by freeing the page
# that does not require an fsync().
catchsql {
SELECT * FROM abc;
} db2
} {0 {}}
do_test malloc5-1.7 {
# Release another 500 bytes of memory. This time we require a sync(),
# so the database file will be locked afterwards.
sqlite3_release_memory 500
} $::pgalloc
do_test malloc5-1.8 {
catchsql {
SELECT * FROM abc;
} db2
} {1 {database is locked}}
do_test malloc5-1.9 {
execsql {
COMMIT;
}
} {}
do_test malloc5-2.1 {
# Put some data in tables abc and def. Both tables are still wholly
# contained within their root pages.
execsql {
INSERT INTO abc VALUES(1, 2, 3);
INSERT INTO abc VALUES(4, 5, 6);
INSERT INTO def VALUES(7, 8, 9);
INSERT INTO def VALUES(10,11,12);
}
} {}
do_test malloc5-2.2 {
# Load the root-page for table def into the cache. Then query table abc.
# Halfway through the query call sqlite3_release_memory(). The goal of this
# test is to make sure we don't free pages that are in use (specifically,
# the root of table abc).
set nRelease 0
execsql {
BEGIN;
SELECT * FROM def;
}
set data [list]
db eval {SELECT * FROM abc} {
incr nRelease [sqlite3_release_memory]
lappend data $a $b $c
}
execsql {
COMMIT;
}
list $nRelease $data
} [list $pgalloc [list 1 2 3 4 5 6]]
do_test malloc5-3.1 {
# Simple test to show that if two pagers are opened from within this
# thread, memory is freed from both when sqlite3_release_memory() is
# called.
execsql {
BEGIN;
SELECT * FROM abc;
}
execsql {
SELECT * FROM sqlite_master;
BEGIN;
SELECT * FROM def;
} db2
sqlite3_release_memory
} [expr $::pgalloc * 2]
do_test malloc5-3.2 {
concat \
[execsql {SELECT * FROM abc; COMMIT}] \
[execsql {SELECT * FROM def; COMMIT} db2]
} {1 2 3 4 5 6 7 8 9 10 11 12}
db2 close
sqlite_malloc_outstanding -clearmaxbytes
# The following two test cases each execute a transaction in which
# 10000 rows are inserted into table abc. The first test case is used
# to ensure that more than 1MB of dynamic memory is used to perform
# the transaction.
#
# The second test case sets the "soft-heap-limit" to 100,000 bytes (0.1 MB)
# and tests to see that this limit is not exceeded at any point during
# transaction execution.
#
# Before executing malloc5-4.* we save the value of the current soft heap
# limit in variable ::soft_limit. The original value is restored after
# running the tests.
#
set ::soft_limit [sqlite3_soft_heap_limit -1]
do_test malloc5-4.1 {
execsql {BEGIN;}
execsql {DELETE FROM abc;}
for {set i 0} {$i < 10000} {incr i} {
execsql "INSERT INTO abc VALUES($i, $i, '[string repeat X 100]');"
}
execsql {COMMIT;}
set ::nMaxBytes [sqlite_malloc_outstanding -maxbytes]
expr $::nMaxBytes > 1000000
} {1}
do_test malloc5-4.2 {
sqlite3_release_memory
sqlite_malloc_outstanding -clearmaxbytes
sqlite3_soft_heap_limit 100000
execsql {BEGIN;}
for {set i 0} {$i < 10000} {incr i} {
execsql "INSERT INTO abc VALUES($i, $i, '[string repeat X 100]');"
}
execsql {COMMIT;}
set ::nMaxBytes [sqlite_malloc_outstanding -maxbytes]
expr $::nMaxBytes <= 100000
} {1}
do_test malloc5-4.3 {
# Check that the content of table abc is at least roughly as expected.
execsql {
SELECT count(*), sum(a), sum(b) FROM abc;
}
} [list 20000 [expr int(20000.0 * 4999.5)] [expr int(20000.0 * 4999.5)]]
# Restore the soft heap limit.
sqlite3_soft_heap_limit $::soft_limit
finish_test
catch {db close}
sqlite3_enable_memory_management 0
|
