← Back to branch summary

~ubuntu-branches/ubuntu/vivid/mariadb-5.5/vivid

« back to all changes in this revision

Viewing changes to storage/tokudb/ft-index/scripts/run.stress-tests.bash

  • Committer: Package Import Robot
  • Author(s): James Page, Otto Kekäläinen
  • Date: 2014-02-17 16:51:52 UTC
  • mfrom: (2.1.1 sid)
  • Revision ID: package-import@ubuntu.com-20140217165152-k315d3175g865kkx
Tags: 5.5.35-1
http://bugs.debian.org/737597
http://bugs.debian.org/733002
http://bugs.debian.org/734426
http://bugs.debian.org/735284
http://bugs.debian.org/736480
http://bugs.debian.org/732967
[ Otto Kekäläinen ]
* New upstream release, fixing the following security issues:
  - Buffer overflow in client/mysql.cc (Closes: #737597).
    - CVE-2014-0001
  - http://www.oracle.com/technetwork/topics/security/cpujan2014-1972949.html
    - CVE-2013-5891
    - CVE-2013-5908
    - CVE-2014-0386
    - CVE-2014-0393
    - CVE-2014-0401
    - CVE-2014-0402
    - CVE-2014-0412
    - CVE-2014-0420
    - CVE-2014-0437
* Upstream https://mariadb.atlassian.net/browse/MDEV-4902
  fixes compatibility with Bison 3.0 (Closes: #733002)
* Updated Russian debconf translation (Closes: #734426)
* Updated Japanese debconf translation (Closes: #735284)
* Updated French debconf translation (Closes: #736480)
* Renamed SONAME properly (Closes: #732967)

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/tokudb/ft-index/scripts/run.stress-tests.bash
 
1
#!/bin/bash
 
2
# $Id$
 
3
 
 
4
DOC=<<EOF
 
5
 
 
6
  PARAMETERS
 
7
 
 
8
    table size: small (2 000), medium (200 000), large (50 000 000)
 
9
 
 
10
    cachetable size: small (num_elements * 50), large (1 000 000 000)
 
11
 
 
12
    update threads: 1, random number <= 20
 
13
 
 
14
    point query threads: 1, random number <= 20
 
15
 
 
16
    recover-test_stress1, recover-test_stress2
 
17
 
 
18
  DATA
 
19
 
 
20
    currently running tests
 
21
 
 
22
    log of success/failure ("./recover-test_stress1.tdb --num_elements blah blah blah      PASS")
 
23
 
 
24
    if failed:
 
25
 
 
26
      parameters
 
27
 
 
28
      corefile
 
29
 
 
30
      stdout/stderr
 
31
 
 
32
      data directory
 
33
 
 
34
EOF
 
35
 
 
36
set -e
 
37
 
 
38
. /opt/intel/bin/compilervars.sh intel64
 
39
 
 
40
scriptname=$(basename "$0")
 
41
toku_toplevel=$(dirname $(dirname $(readlink -f "$PWD/$0")))
 
42
log=/tmp/run.stress-tests.log
 
43
savedir=/tmp/run.stress-tests.failures
 
44
 
 
45
usage() {
 
46
    echo "Usage: $scriptname" 1>&2
 
47
    echo "  [--toku_toplevel=<dir>]" 1>&2
 
48
    echo "  [--log=<file>]" 1>&2
 
49
    echo "  [--savedir=<dir>]" 1>&2
 
50
}
 
51
 
 
52
# parse the command line
 
53
while [ $# -gt 0 ] ; do
 
54
    arg=$1; shift
 
55
    if [[ $arg =~ --(.*)=(.*) ]] ; then
 
56
        ok=no
 
57
        for opt in toku_toplevel log savedir
 
58
        do
 
59
            if [[ ${BASH_REMATCH[1]} = $opt ]]
 
60
            then
 
61
                ok=yes
 
62
            fi
 
63
        done
 
64
        if [[ $ok = no ]]
 
65
        then
 
66
            usage; exit 1
 
67
        fi
 
68
        eval ${BASH_REMATCH[1]}=${BASH_REMATCH[2]}
 
69
    else
 
70
        usage; exit 1
 
71
    fi
 
72
done
 
73
 
 
74
src_tests="${toku_toplevel}/src/tests"
 
75
testnames=(test_stress1.tdb \
 
76
           test_stress5.tdb \
 
77
           test_stress6.tdb)
 
78
recover_testnames=(recover-test_stress1.tdb \
 
79
                   recover-test_stress2.tdb \
 
80
                   recover-test_stress3.tdb)
 
81
 
 
82
save_failure() {
 
83
    dir="$1"; shift
 
84
    out="$1"; shift
 
85
    envdir="$1"; shift
 
86
    rev=$1; shift
 
87
    exec="$1"; shift
 
88
    table_size=$1; shift
 
89
    cachetable_size=$1; shift
 
90
    num_ptquery=$1; shift
 
91
    num_update=$1; shift
 
92
    phase=$1; shift
 
93
    dest="${dir}/${exec}-${table_size}-${cachetable_size}-${num_ptquery}-${num_update}-${phase}-${rev}-$$"
 
94
    mkdir -p "$dest"
 
95
    mv $out "${dest}/output.txt"
 
96
    mv core* "${dest}/"
 
97
    mv $envdir "${dest}/"
 
98
}
 
99
 
 
100
running=no
 
101
 
 
102
run_test() {
 
103
    rev=$1; shift
 
104
    exec="$1"; shift
 
105
    table_size="$1"; shift
 
106
    cachetable_size="$1"; shift
 
107
    num_ptquery="$1"; shift
 
108
    num_update="$1"; shift
 
109
    mylog="$1"; shift
 
110
    mysavedir="$1"; shift
 
111
 
 
112
    rundir=$(mktemp -d ./rundir.XXXXXXXX)
 
113
    tmplog=$(mktemp)
 
114
 
 
115
    ulimit -c unlimited
 
116
    t0="$(date)"
 
117
    t1=""
 
118
    t2=""
 
119
    envdir="../${exec}-${table_size}-${cachetable_size}-${num_ptquery}-${num_update}-$$.dir"
 
120
    cd $rundir
 
121
    if LD_LIBRARY_PATH=../../../lib:$LD_LIBRARY_PATH \
 
122
        ../$exec -v --only_create --num_seconds 600 --envdir "$envdir" \
 
123
        --num_elements $table_size \
 
124
        --cachetable_size $cachetable_size &> $tmplog
 
125
    then
 
126
        rm -f $tmplog
 
127
        t1="$(date)"
 
128
        if LD_LIBRARY_PATH=../../../lib:$LD_LIBRARY_PATH \
 
129
            ../$exec -v --only_stress --num_seconds 600 --no-crash_on_update_failure --envdir "$envdir" \
 
130
            --num_elements $table_size \
 
131
            --cachetable_size $cachetable_size \
 
132
            --num_ptquery_threads $num_ptquery \
 
133
            --num_update_threads $num_update &> $tmplog
 
134
        then
 
135
            rm -f $tmplog
 
136
            t2="$(date)"
 
137
            echo "\"$exec\",$rev,$table_size,$cachetable_size,$num_ptquery,$num_update,$t0,$t1,$t2,PASS" | tee -a "$mylog"
 
138
        else
 
139
            save_failure "$mysavedir" $tmplog $envdir $rev $exec $table_size $cachetable_size $num_ptquery $num_update stress
 
140
            echo "\"$exec\",$rev,$table_size,$cachetable_size,$num_ptquery,$num_update,$t0,$t1,$t2,FAIL" | tee -a "$mylog"
 
141
        fi
 
142
    else
 
143
        save_failure "$mysavedir" $tmplog $envdir $rev $exec $table_size $cachetable_size $num_ptquery $num_update create
 
144
        echo "\"$exec\",$rev,$table_size,$cachetable_size,$num_ptquery,$num_update,$t0,$t1,$t2,FAIL" | tee -a "$mylog"
 
145
    fi
 
146
    cd ..
 
147
    rm -rf $rundir "$envdir"
 
148
}
 
149
 
 
150
loop_test() {
 
151
    rev=$1; shift
 
152
    exec="$1"; shift
 
153
    table_size="$1"; shift
 
154
    cachetable_size="$1"; shift
 
155
    mylog="$1"; shift
 
156
    mysavedir="$1"; shift
 
157
 
 
158
    ptquery_rand=0
 
159
    update_rand=0
 
160
    while [[ $running = "yes" ]]
 
161
    do
 
162
        num_ptquery=1
 
163
        num_update=1
 
164
        if [[ $ptquery_rand -gt 1 ]]
 
165
        then
 
166
            (( num_ptquery = $RANDOM % 16 ))
 
167
        fi
 
168
        if [[ $update_rand -gt 0 ]]
 
169
        then
 
170
            (( num_update = $RANDOM % 16 ))
 
171
        fi
 
172
        (( ptquery_rand = (ptquery_rand + 1) % 4 ))
 
173
        (( update_rand = (update_rand + 1) % 2 ))
 
174
        run_test $rev $exec $table_size $cachetable_size $num_ptquery $num_update $mylog $mysavedir
 
175
    done
 
176
}
 
177
 
 
178
run_recover_test() {
 
179
    rev=$1; shift
 
180
    exec="$1"; shift
 
181
    table_size="$1"; shift
 
182
    cachetable_size="$1"; shift
 
183
    num_ptquery="$1"; shift
 
184
    num_update="$1"; shift
 
185
    mylog="$1"; shift
 
186
    mysavedir="$1"; shift
 
187
 
 
188
    rundir=$(mktemp -d ./rundir.XXXXXXXX)
 
189
    tmplog=$(mktemp)
 
190
 
 
191
    ulimit -c unlimited
 
192
    t0="$(date)"
 
193
    t1=""
 
194
    t2=""
 
195
    envdir="../${exec}-${table_size}-${cachetable_size}-${num_ptquery}-${num_update}-$$.dir"
 
196
    cd $rundir
 
197
    if ! LD_LIBRARY_PATH=../../../lib:$LD_LIBRARY_PATH \
 
198
        ../$exec -v --test --num_seconds 600 --no-crash_on_update_failure --envdir "$envdir" \
 
199
        --num_elements $table_size \
 
200
        --cachetable_size $cachetable_size \
 
201
        --num_ptquery_threads $num_ptquery \
 
202
        --num_update_threads $num_update &> $tmplog
 
203
    then
 
204
        rm -f $tmplog
 
205
        t1="$(date)"
 
206
        if LD_LIBRARY_PATH=../../../lib:$LD_LIBRARY_PATH \
 
207
            ../$exec -v --recover --envdir "$envdir" \
 
208
            --num_elements $table_size \
 
209
            --cachetable_size $cachetable_size &> $tmplog
 
210
        then
 
211
            rm -f $tmplog
 
212
            t2="$(date)"
 
213
            echo "\"$exec\",$rev,$table_size,$cachetable_size,$num_ptquery,$num_update,$t0,$t1,$t2,PASS" | tee -a "$mylog"
 
214
        else
 
215
            save_failure "$mysavedir" $tmplog $envdir $rev $exec $table_size $cachetable_size $num_ptquery $num_update recover
 
216
            echo "\"$exec\",$rev,$table_size,$cachetable_size,$num_ptquery,$num_update,$t0,$t1,$t2,FAIL" | tee -a "$mylog"
 
217
        fi
 
218
    else
 
219
        save_failure "$mysavedir" $tmplog $envdir $rev $exec $table_size $cachetable_size $num_ptquery $num_update test
 
220
        echo "\"$exec\",$rev,$table_size,$cachetable_size,$num_ptquery,$num_update,$t0,$t1,$t2,FAIL" | tee -a "$mylog"
 
221
    fi
 
222
    cd ..
 
223
    rm -rf $rundir "$envdir"
 
224
}
 
225
 
 
226
loop_recover_test() {
 
227
    rev=$1; shift
 
228
    exec="$1"; shift
 
229
    table_size="$1"; shift
 
230
    cachetable_size="$1"; shift
 
231
    mylog="$1"; shift
 
232
    mysavedir="$1"; shift
 
233
 
 
234
    ptquery_rand=0
 
235
    update_rand=0
 
236
    while [[ $running = "yes" ]]
 
237
    do
 
238
        num_ptquery=1
 
239
        num_update=1
 
240
        if [[ $ptquery_rand -gt 1 ]]
 
241
        then
 
242
            (( num_ptquery = $RANDOM % 16 ))
 
243
        fi
 
244
        if [[ $update_rand -gt 0 ]]
 
245
        then
 
246
            (( num_update = $RANDOM % 16 ))
 
247
        fi
 
248
        (( ptquery_rand = (ptquery_rand + 1) % 4 ))
 
249
        (( update_rand = (update_rand + 1) % 2 ))
 
250
        run_recover_test $rev $exec $table_size $cachetable_size $num_ptquery $num_update $mylog $mysavedir
 
251
    done
 
252
}
 
253
 
 
254
declare -a pids=(0)
 
255
i=0
 
256
 
 
257
savepid() {
 
258
    pids[$i]=$1
 
259
    (( i = i + 1 ))
 
260
}
 
261
 
 
262
killchildren() {
 
263
    kill ${pids[@]} || true
 
264
    for exec in ${testnames[@]} ${recover_testnames[@]}
 
265
    do
 
266
        pkill -f $exec || true
 
267
    done
 
268
}
 
269
 
 
270
trap killchildren INT TERM EXIT
 
271
 
 
272
mkdir -p $log
 
273
mkdir -p $savedir
 
274
 
 
275
while true
 
276
do
 
277
    (cd $toku_toplevel; \
 
278
        svn update; \
 
279
        make CC=icc DEBUG=0 HAVE_CILK=0 clean fastbuild; \
 
280
        make CC=icc DEBUG=0 HAVE_CILK=0 -C src/tests ${testnames[@]} ${recover_testnames[@]})
 
281
 
 
282
    cd $src_tests
 
283
 
 
284
    rev=$(svn info ../.. | awk '/Revision/ { print $2 }')
 
285
 
 
286
    running=yes
 
287
 
 
288
    for exec in ${testnames[@]}
 
289
    do
 
290
        for table_size in 2000 200000 50000000
 
291
        do
 
292
            (( small_cachetable = table_size * 50 ))
 
293
            suffix="${exec}-${table_size}-${small_cachetable}-$$"
 
294
            touch "${log}/${suffix}"
 
295
            loop_test $rev $exec $table_size $small_cachetable "${log}/${suffix}" "${savedir}/${suffix}" & savepid $!
 
296
 
 
297
            suffix="${exec}-${table_size}-1000000000-$$"
 
298
            touch "${log}/${suffix}"
 
299
            loop_test $rev $exec $table_size 1000000000 "${log}/${suffix}" "${savedir}/${suffix}" & savepid $!
 
300
        done
 
301
    done
 
302
 
 
303
    for exec in ${recover_testnames[@]}
 
304
    do
 
305
        for table_size in 2000 200000 50000000
 
306
        do
 
307
            (( small_cachetable = table_size * 50 ))
 
308
            suffix="${exec}-${table_size}-${small_cachetable}-$$"
 
309
            touch "${log}/${suffix}"
 
310
            loop_recover_test $rev $exec $table_size $small_cachetable "${log}/${suffix}" "${savedir}/${suffix}" & savepid $!
 
311
 
 
312
            suffix="${exec}-${table_size}-1000000000-$$"
 
313
            touch "${log}/${suffix}"
 
314
            loop_recover_test $rev $exec $table_size 1000000000 "${log}/${suffix}" "${savedir}/${suffix}" & savepid $!
 
315
        done
 
316
    done
 
317
 
 
318
    sleep 1d
 
319
 
 
320
    running=no
 
321
 
 
322
    killchildren
 
323
 
 
324
    wait ${pids[@]} || true
 
325
 
 
326
    idx=0
 
327
    for pid in ${pids[@]}
 
328
    do
 
329
        pids[$idx]=0
 
330
        (( idx = idx + 1 ))
 
331
    done
 
332
done