Whamcloud - gitweb
b0dfdce6b7dbbcf7283aaf2b222ba9c1dabb6dc6
[fs/lustre-release.git] / lustre / tests / parallel-scale.sh
1 #!/bin/bash
2 #
3 #set -vx
4
5 LUSTRE=${LUSTRE:-$(cd $(dirname $0)/..; echo $PWD)}
6 . $LUSTRE/tests/test-framework.sh
7 init_test_env $@
8 . ${CONFIG:=$LUSTRE/tests/cfg/$NAME.sh}
9 init_logging
10
11 #              bug 20670 
12 ALWAYS_EXCEPT="parallel_grouplock $PARALLEL_SCALE_EXCEPT"
13
14 #
15 # compilbench
16 #
17 cbench_DIR=${cbench_DIR:-""}
18 cbench_IDIRS=${cbench_IDIRS:-4}
19 cbench_RUNS=${cbench_RUNS:-4}   # FIXME: wiki page requirements is 30, do we really need 30 ?
20
21 if [ "$SLOW" = "no" ]; then
22     cbench_IDIRS=2
23     cbench_RUNS=2
24 fi
25
26 #
27 # metabench
28 #
29 METABENCH=${METABENCH:-$(which metabench 2> /dev/null || true)}
30 mbench_NFILES=${mbench_NFILES:-30400}
31 [ "$SLOW" = "no" ] && mbench_NFILES=10000
32 MACHINEFILE=${MACHINEFILE:-$TMP/$(basename $0 .sh).machines}
33 # threads per client
34 mbench_THREADS=${mbench_THREADS:-4}
35
36 #
37 # simul
38 #
39 SIMUL=${SIMUL:=$(which simul 2> /dev/null || true)}
40 # threads per client
41 simul_THREADS=${simul_THREADS:-2}
42 simul_REP=${simul_REP:-20}
43 [ "$SLOW" = "no" ] && simul_REP=2
44
45 #
46 # connectathon
47 #
48 cnt_DIR=${cnt_DIR:-""}
49 cnt_NRUN=${cnt_NRUN:-10}
50 [ "$SLOW" = "no" ] && cnt_NRUN=2
51
52 #
53 # cascading rw
54 #
55 CASC_RW=${CASC_RW:-$(which cascading_rw 2> /dev/null || true)}
56 # threads per client
57 casc_THREADS=${casc_THREADS:-2}
58 casc_REP=${casc_REP:-300}
59 [ "$SLOW" = "no" ] && casc_REP=10
60
61 #
62 # IOR
63 #
64 IOR=${IOR:-$(which IOR 2> /dev/null || true)}
65 # threads per client
66 ior_THREADS=${ior_THREADS:-2}
67 ior_blockSize=${ior_blockSize:-6}       # Gb
68 ior_DURATION=${ior_DURATION:-30}        # minutes
69 [ "$SLOW" = "no" ] && ior_DURATION=5
70
71 #
72 # write_append_truncate
73 #
74 # threads per client
75 write_THREADS=${write_THREADS:-8}
76 write_REP=${write_REP:-10000}
77 [ "$SLOW" = "no" ] && write_REP=100
78
79 #
80 # write_disjoint
81 #
82 WRITE_DISJOINT=${WRITE_DISJOINT:-$(which write_disjoint 2> /dev/null || true)}
83 # threads per client
84 wdisjoint_THREADS=${wdisjoint_THREADS:-4}
85 wdisjoint_REP=${wdisjoint_REP:-10000}
86 [ "$SLOW" = "no" ] && wdisjoint_REP=100
87
88 #
89 # parallel_grouplock
90 #
91 #
92 PARALLEL_GROUPLOCK=${PARALLEL_GROUPLOCK:-$(which parallel_grouplock 2> /dev/null || true)}
93 parallel_grouplock_MINTASKS=${parallel_grouplock_MINTASKS:-5}
94
95 build_test_filter
96 check_and_setup_lustre
97
98 get_mpiuser_id $MPI_USER
99 MPI_RUNAS=${MPI_RUNAS:-"runas -u $MPI_USER_UID -g $MPI_USER_GID"}
100 $GSS_KRB5 && refresh_krb5_tgt $MPI_USER_UID $MPI_USER_GID $MPI_RUNAS
101
102 print_opts () {
103     local var
104
105     echo OPTIONS:
106
107     for i in $@; do
108         var=$i
109         echo "${var}=${!var}"
110     done
111     [ -e $MACHINEFILE ] && cat $MACHINEFILE
112 }
113
114 # Takes:
115 # 5 min * cbench_RUNS
116 #        SLOW=no     10 mins
117 #        SLOW=yes    50 mins
118 # Space estimation:
119 #        compile dir kernel-1 680MB
120 #        required space       680MB * cbench_IDIRS = ~7 Gb
121
122 test_compilebench() {
123     print_opts cbench_DIR cbench_IDIRS cbench_RUNS
124
125     [ x$cbench_DIR = x ] &&
126         { skip_env "compilebench not found" && return; }
127
128     [ -e $cbench_DIR/compilebench ] || \
129         { skip_env "No compilebench build" && return; }
130
131     local space=$(df -P $DIR | tail -n 1 | awk '{ print $4 }')
132     if [ $space -le $((680 * 1024 * cbench_IDIRS)) ]; then
133         cbench_IDIRS=$(( space / 680 / 1024))
134         [ $cbench_IDIRS = 0 ] && \
135             skip_env "Need free space atleast 680 Mb, have $space" && return
136
137         log free space=$space, reducing initial dirs to $cbench_IDIRS
138     fi
139     # FIXME:
140     # t-f _base needs to be modifyed to set properly tdir
141     # for new "test_foo" functions names
142     # local testdir=$DIR/$tdir
143     local testdir=$DIR/d0.compilebench
144     mkdir -p $testdir
145
146     local savePWD=$PWD
147     cd $cbench_DIR 
148     local cmd="./compilebench -D $testdir -i $cbench_IDIRS -r $cbench_RUNS --makej"
149
150     log "$cmd"
151
152     local rc=0
153     eval $cmd
154     rc=$?
155         
156     cd $savePWD
157     [ $rc = 0 ] || error "compilebench failed: $rc"
158     rm -rf $testdir
159 }
160 run_test compilebench "compilebench"
161
162 test_metabench() {
163     [ x$METABENCH = x ] &&
164         { skip_env "metabench not found" && return; }
165
166     local clients=$CLIENTS
167     [ -z $clients ] && clients=$(hostname)
168
169     num_clients=$(get_node_count ${clients//,/ })
170
171     # FIXME
172     # Need space estimation here.
173
174     generate_machine_file $clients $MACHINEFILE || return $?
175
176     print_opts METABENCH clients mbench_NFILES mbench_THREADS
177
178     local testdir=$DIR/d0.metabench
179     mkdir -p $testdir
180     # mpi_run uses mpiuser
181     chmod 0777 $testdir
182
183     # -C             Run the file creation tests.
184     # -S             Run the file stat tests.
185     # -c nfile       Number of files to be used in each test.
186     # -k             Cleanup.  Remove the test directories.
187     local cmd="$METABENCH -w $testdir -c $mbench_NFILES -C -S -k"
188     echo "+ $cmd"
189     mpi_run -np $((num_clients * $mbench_THREADS)) -machinefile ${MACHINEFILE} $cmd
190     local rc=$?
191     if [ $rc != 0 ] ; then
192         error "metabench failed! $rc"
193     fi
194     rm -rf $testdir
195 }
196 run_test metabench "metabench"
197
198 test_simul() {
199     if [ "$NFSCLIENT" ]; then
200         skip "skipped for NFSCLIENT mode"
201         return
202     fi
203
204     [ x$SIMUL = x ] &&
205         { skip_env "simul not found" && return; }
206
207     local clients=$CLIENTS
208     [ -z $clients ] && clients=$(hostname)
209
210     local num_clients=$(get_node_count ${clients//,/ })
211
212     # FIXME
213     # Need space estimation here.
214
215     generate_machine_file $clients $MACHINEFILE || return $?
216
217     print_opts SIMUL clients simul_REP simul_THREADS
218
219     local testdir=$DIR/d0.simul
220     mkdir -p $testdir
221     # mpi_run uses mpiuser
222     chmod 0777 $testdir
223
224     # -n # : repeat each test # times
225     # -N # : repeat the entire set of tests # times
226
227     local cmd="$SIMUL -d $testdir -n $simul_REP -N $simul_REP"
228
229     echo "+ $cmd"
230     mpi_run -np $((num_clients * $simul_THREADS)) -machinefile ${MACHINEFILE} $cmd
231
232     local rc=$?
233     if [ $rc != 0 ] ; then
234         error "simul failed! $rc"
235     fi
236     rm -rf $testdir
237 }
238 run_test simul "simul"
239
240 test_connectathon() {
241     print_opts cnt_DIR cnt_NRUN
242
243     [ x$cnt_DIR = x ] &&
244         { skip_env "connectathon dir not found" && return; }
245
246     [ -e $cnt_DIR/runtests ] || \
247         { skip_env "No connectathon runtests found" && return; }
248
249     local testdir=$DIR/d0.connectathon
250     mkdir -p $testdir
251
252     local savePWD=$PWD
253     cd $cnt_DIR
254
255     # -f      a quick functionality test
256     # -a      run basic, general, special, and lock tests
257     # -N numpasses - will be passed to the runtests script.  This argument
258     #         is optional.  It specifies the number of times to run
259     #         through the tests.
260
261     local cmd="./runtests -N $cnt_NRUN -a -f $testdir"
262
263     log "$cmd"
264
265     local rc=0
266     eval $cmd
267     rc=$?
268
269     cd $savePWD
270     [ $rc = 0 ] || error "connectathon failed: $rc"
271     rm -rf $testdir
272 }
273 run_test connectathon "connectathon"
274
275 test_ior() {
276     [ x$IOR = x ] &&
277         { skip_env "IOR not found" && return; }
278
279     local clients=$CLIENTS
280     [ -z $clients ] && clients=$(hostname)
281
282     local num_clients=$(get_node_count ${clients//,/ })
283
284     local space=$(df -P $DIR | tail -n 1 | awk '{ print $4 }')
285     echo "+ $ior_blockSize * 1024 * 1024 * $num_clients * $ior_THREADS "
286     if [ $((space / 2)) -le $(( ior_blockSize * 1024 * 1024 * num_clients * ior_THREADS)) ]; then
287         echo "+ $space * 9/10 / 1024 / 1024 / $num_clients / $ior_THREADS"
288         ior_blockSize=$(( space /2 /1024 /1024 / num_clients / ior_THREADS ))
289         [ $ior_blockSize = 0 ] && \
290             skip_env "Need free space more than ($num_clients * $ior_THREADS )Gb: $((num_clients*ior_THREADS *1024 *1024*2)), have $space" && return
291
292         echo "free space=$space, Need: $num_clients x $ior_THREADS x $ior_blockSize Gb (blockSize reduced to $ior_blockSize Gb)"
293     fi
294  
295     generate_machine_file $clients $MACHINEFILE || return $?
296
297     print_opts IOR ior_THREADS ior_DURATION MACHINEFILE
298
299     local testdir=$DIR/d0.ior
300     mkdir -p $testdir
301     # mpi_run uses mpiuser
302     chmod 0777 $testdir
303     if [ "$NFSCLIENT" ]; then
304         setstripe_nfsserver $testdir -c -1 || 
305             { error "setstripe on nfsserver failed" && return 1; } 
306     else
307         $LFS setstripe $testdir -c -1 ||
308             { error "setstripe failed" && return 2; }
309     fi
310     # 
311     # -b N  blockSize -- contiguous bytes to write per task  (e.g.: 8, 4k, 2m, 1g)"
312     # -o S  testFileName
313     # -t N  transferSize -- size of transfer in bytes (e.g.: 8, 4k, 2m, 1g)"
314     # -w    writeFile -- write file"
315     # -r    readFile -- read existing file"
316     # -T    maxTimeDuration -- max time in minutes to run tests"
317     # -k    keepFile -- keep testFile(s) on program exit
318     local cmd="$IOR -a POSIX -b ${ior_blockSize}g -o $testdir/iorData -t 2m -v -w -r -T $ior_DURATION -k"
319
320     echo "+ $cmd"
321     mpi_run -np $((num_clients * $ior_THREADS)) -machinefile ${MACHINEFILE} $cmd
322
323     local rc=$?
324     if [ $rc != 0 ] ; then
325         error "ior failed! $rc"
326     fi
327     rm -rf $testdir
328 }
329 run_test ior "ior"
330  
331 test_cascading_rw() {
332     if [ "$NFSCLIENT" ]; then
333         skip "skipped for NFSCLIENT mode"
334         return
335     fi
336
337     [ x$CASC_RW = x ] &&
338         { skip_env "cascading_rw not found" && return; }
339
340     local clients=$CLIENTS
341     [ -z $clients ] && clients=$(hostname)
342
343     num_clients=$(get_node_count ${clients//,/ })
344
345     # FIXME
346     # Need space estimation here.
347
348     generate_machine_file $clients $MACHINEFILE || return $?
349
350     print_opts CASC_RW clients casc_THREADS casc_REP MACHINEFILE
351
352     local testdir=$DIR/d0.cascading_rw
353     mkdir -p $testdir
354     # mpi_run uses mpiuser
355     chmod 0777 $testdir
356
357     # -g: debug mode 
358     # -n: repeat test # times
359
360     local cmd="$CASC_RW -g -d $testdir -n $casc_REP"
361
362     echo "+ $cmd"
363     mpi_run -np $((num_clients * $casc_THREADS)) -machinefile ${MACHINEFILE} $cmd
364
365     local rc=$?
366     if [ $rc != 0 ] ; then
367         error "cascading_rw failed! $rc"
368     fi
369     rm -rf $testdir
370 }
371 run_test cascading_rw "cascading_rw"
372
373 test_write_append_truncate() {
374     if [ "$NFSCLIENT" ]; then
375         skip "skipped for NFSCLIENT mode"
376         return
377     fi
378
379     # location is lustre/tests dir 
380     if ! which write_append_truncate > /dev/null 2>&1 ; then
381         skip_env "write_append_truncate not found"
382         return
383     fi
384
385     local clients=$CLIENTS
386     [ -z $clients ] && clients=$(hostname)
387
388     local num_clients=$(get_node_count ${clients//,/ })
389
390     # FIXME
391     # Need space estimation here.
392
393     generate_machine_file $clients $MACHINEFILE || return $?
394
395     local testdir=$DIR/d0.write_append_truncate
396     local file=$testdir/f0.wat
397
398     print_opts clients write_REP write_THREADS MACHINEFILE
399
400     mkdir -p $testdir
401     # mpi_run uses mpiuser
402     chmod 0777 $testdir
403
404     local cmd="write_append_truncate -n $write_REP $file"
405
406     echo "+ $cmd"
407     mpi_run -np $((num_clients * $write_THREADS)) -machinefile ${MACHINEFILE} $cmd
408
409     local rc=$?
410     if [ $rc != 0 ] ; then
411         error "write_append_truncate failed! $rc"
412         return $rc
413     fi
414     rm -rf $testdir
415 }
416 run_test write_append_truncate "write_append_truncate"
417
418 test_write_disjoint() {
419     if [ "$NFSCLIENT" ]; then
420         skip "skipped for NFSCLIENT mode"
421         return
422     fi
423
424     [ x$WRITE_DISJOINT = x ] &&
425         { skip_env "write_disjoint not found" && return; }
426
427     local clients=$CLIENTS
428     [ -z $clients ] && clients=$(hostname)
429
430     local num_clients=$(get_node_count ${clients//,/ })
431
432     # FIXME
433     # Need space estimation here.
434
435     generate_machine_file $clients $MACHINEFILE || return $?
436
437     print_opts WRITE_DISJOINT clients wdisjoint_THREADS wdisjoint_REP MACHINEFILE
438     local testdir=$DIR/d0.write_disjoint
439     mkdir -p $testdir
440     # mpi_run uses mpiuser
441     chmod 0777 $testdir
442
443     local cmd="$WRITE_DISJOINT -f $testdir/file -n $wdisjoint_REP"
444
445     echo "+ $cmd"
446     mpi_run -np $((num_clients * $wdisjoint_THREADS)) -machinefile ${MACHINEFILE} $cmd
447
448     local rc=$?
449     if [ $rc != 0 ] ; then
450         error "write_disjoint failed! $rc"
451     fi
452     rm -rf $testdir
453 }
454 run_test write_disjoint "write_disjoint"
455
456 test_parallel_grouplock() {
457     if [ "$NFSCLIENT" ]; then
458         skip "skipped for NFSCLIENT mode"
459         return
460     fi
461
462     [ x$PARALLEL_GROUPLOCK = x ] &&
463         { skip "PARALLEL_GROUPLOCK not found" && return; }
464
465     local clients=$CLIENTS
466     [ -z $clients ] && clients=$(hostname)
467
468     local num_clients=$(get_node_count ${clients//,/ })
469
470     generate_machine_file $clients $MACHINEFILE || return $?
471
472     print_opts clients parallel_grouplock_MINTASKS MACHINEFILE
473
474     local testdir=$DIR/d0.parallel_grouplock
475     mkdir -p $testdir
476     # mpi_run uses mpiuser
477     chmod 0777 $testdir
478
479     do_nodes $clients "lctl set_param llite.*.max_rw_chunk=0" ||
480         error "set_param max_rw_chunk=0 failed "
481
482     local cmd
483     local status=0
484     local subtest
485     for i in $(seq 12); do
486         subtest="-t $i"
487         local cmd="$PARALLEL_GROUPLOCK -g -v -d $testdir $subtest"
488         echo "+ $cmd"
489
490         mpi_run -np $parallel_grouplock_MINTASKS -machinefile ${MACHINEFILE} $cmd
491         local rc=$?
492         if [ $rc != 0 ] ; then
493             error_noexit "parallel_grouplock subtests $subtest failed! $rc"
494         else
495             echo "parallel_grouplock subtests $subtest PASS"
496         fi
497         let status=$((status + rc))
498         # clear debug to collect one log per one test
499         do_nodes $(comma_list $(nodes_list)) lctl clear
500      done
501     [ $status -eq 0 ] || error "parallel_grouplock status: $status"
502     rm -rf $testdir
503 }
504 run_test parallel_grouplock "parallel_grouplock"
505
506 statahead_NUMMNTPTS=${statahead_NUMMNTPTS:-5}
507 statahead_NUMFILES=${statahead_NUMFILES:-500000}
508
509 cleanup_statahead () {
510     trap 0
511
512     local clients=$1
513     local mntpt_root=$2
514     local num_mntpts=$3
515
516     for i in $(seq 0 $num_mntpts);do
517         zconf_umount_clients $clients ${mntpt_root}$i ||
518             error_exit "Failed to umount lustre on ${mntpt_root}$i"
519     done
520 }
521
522 test_statahead () {
523     if [[ -n $NFSCLIENT ]]; then
524         skip "Statahead testing is not supported on NFS clients."
525         return 0
526     fi
527
528     [ x$MDSRATE = x ] &&
529         { skip_env "mdsrate not found" && return; }
530
531     local clients=$CLIENTS
532     [ -z $clients ] && clients=$(hostname)
533
534     local num_clients=$(get_node_count ${clients//,/ })
535
536     generate_machine_file $clients $MACHINEFILE || return $?
537
538     print_opts MDSRATE clients statahead_NUMMNTPTS statahead_NUMFILES
539
540     # create large dir
541
542     # do not use default "d[0-9]*" dir name
543     # to avoid of rm $statahead_NUMFILES (500k) files in t-f cleanup
544     local dir=dstatahead
545     local testdir=$DIR/$dir
546
547     # cleanup only if dir exists
548     # cleanup only $statahead_NUMFILES number of files
549     # ignore the other files created by someone else
550     [ -d $testdir ] &&
551         mdsrate_cleanup $((num_clients * 32)) $MACHINEFILE $statahead_NUMFILES $testdir 'f%%d' --ignore
552
553     mkdir -p $testdir
554     # mpi_run uses mpiuser
555     chmod 0777 $testdir
556
557     local num_files=$statahead_NUMFILES
558
559     local IFree=$(inodes_available)
560     if [ $IFree -lt $num_files ]; then
561       num_files=$IFree
562     fi
563
564     cancel_lru_locks mdc
565
566     local cmd="${MDSRATE} ${MDSRATE_DEBUG} --mknod --dir $testdir --nfiles $num_files --filefmt 'f%%d'"    
567     echo "+ $cmd"
568     
569     mpi_run -np $((num_clients * 32)) -machinefile ${MACHINEFILE} $cmd
570
571     local rc=$?
572     if [ $rc != 0 ] ; then
573         error "mdsrate failed to create $rc"
574         return $rc
575     fi
576
577     local num_mntpts=$statahead_NUMMNTPTS
578     local mntpt_root=$TMP/mntpt/lustre
579     mntopts=${MNTOPTSTATAHEAD:-$MOUNTOPT}
580
581     echo "Mounting $num_mntpts lustre clients starts on $clients"
582     trap "cleanup_statahead $clients $mntpt_root $num_mntpts" EXIT ERR
583     for i in $(seq 0 $num_mntpts); do
584         zconf_mount_clients $clients ${mntpt_root}$i $mntopts ||
585             error_exit "Failed to mount lustre on ${mntpt_root}$i on $clients"
586     done
587
588     do_rpc_nodes $clients cancel_lru_locks mdc
589
590     do_rpc_nodes $clients do_ls $mntpt_root $num_mntpts $dir
591
592     mdsrate_cleanup $((num_clients * 32)) $MACHINEFILE $num_files $testdir 'f%%d' --ignore
593
594     # use rm instead of rmdir because of
595     # testdir could contain the files created by someone else,
596     # or by previous run where is num_files prev > num_files current
597     rm -rf $testdir
598     cleanup_statahead $clients $mntpt_root $num_mntpts
599 }
600
601 run_test statahead "statahead test, multiple clients"
602
603 equals_msg `basename $0`: test complete, cleaning up
604 check_and_cleanup_lustre
605 [ -f "$TESTSUITELOG" ] && cat $TESTSUITELOG && grep -q FAIL $TESTSUITELOG && exit 1 || true