source: CIVL/examples/omp/dataracebench-1.3.2/scripts/test-harness.sh

main
Last change on this file was ea777aa, checked in by Alex Wilton <awilton@…>, 3 years ago

Moved examples, include, build_default.properties, common.xml, and README out from dev.civl.com into the root of the repo.

git-svn-id: ​svn://vsl.cis.udel.edu/civl/trunk@5704 fb995dde-84ed-4084-dfe6-e5aef3e2452c
  • Property mode set to 100755
File size: 26.2 KB
Line 
1#!/usr/bin/env bash
2
3# Copyright (c) 2017, Lawrence Livermore National Security, LLC.
4# Produced at the Lawrence Livermore National Laboratory
5# Written by Chunhua Liao, Pei-Hung Lin, Joshua Asplund,
6# Markus Schordan, and Ian Karlin
7# (email: liao6@llnl.gov, lin32@llnl.gov, asplund1@llnl.gov,
8# schordan1@llnl.gov, karlin1@llnl.gov)
9# LLNL-CODE-732144
10# All rights reserved.
11#
12# This file is part of DataRaceBench. For details, see
13# https://github.com/LLNL/dataracebench. Please also see the LICENSE file
14# for our additional BSD notice
15#
16# Redistribution of Backstroke and use in source and binary forms, with
17# or without modification, are permitted provided that the following
18# conditions are met:
19#
20# * Redistributions of source code must retain the above copyright
21# notice, this list of conditions and the disclaimer below.
22#
23# * Redistributions in binary form must reproduce the above copyright
24# notice, this list of conditions and the disclaimer (as noted below)
25# in the documentation and/or other materials provided with the
26# distribution.
27#
28# * Neither the name of the LLNS/LLNL nor the names of its contributors
29# may be used to endorse or promote products derived from this
30# software without specific prior written permission.
31#
32# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
33# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
34# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
35# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
36# DISCLAIMED. IN NO EVENT SHALL LAWRENCE LIVERMORE NATIONAL
37# SECURITY, LLC, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE
38# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
39# OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
40# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
41# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
42# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
43# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
44# IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
45# THE POSSIBILITY OF SUCH DAMAGE.
46
47CSV_HEADER="tool,id,filename,haverace,threads,dataset,races,elapsed-time(seconds),used-mem(KBs),compile-return,runtime-return"
48TESTS=($(grep -l main micro-benchmarks/*.c micro-benchmarks/*.cpp))
49FORTRANTESTS=($(find micro-benchmarks-fortran -iregex ".*\.F[0-9]*" -o -iregex ".*\.for"))
50OUTPUT_DIR="results"
51LOG_DIR="$OUTPUT_DIR/log"
52EXEC_DIR="$OUTPUT_DIR/exec"
53LOGFILE="$LOG_DIR/dataracecheck.log"
54LANGUAGE="default"
55
56
57MEMCHECK=${MEMCHECK:-"/usr/bin/time"}
58TIMEOUTCMD=${TIMEOUTCMD:-"timeout"}
59VALGRIND=${VALGRIND:-"valgrind"}
60VALGRIND_COMPILE_C_FLAGS="-g -std=c99 -fopenmp"
61VALGRIND_COMPILE_CPP_FLAGS="-g -fopenmp"
62
63CLANG=${CLANG:-"clang"}
64TSAN_COMPILE_FLAGS="-fopenmp -fsanitize=thread -g"
65
66ARCHER=${ARCHER:-"clang-archer"}
67ARCHER_COMPILE_FLAGS="-larcher"
68
69INSPECTOR=${INSPECTOR:-"inspxe-cl"}
70ICC_COMPILE_FLAGS="-O0 -fopenmp -std=c99 -qopenmp-offload=host"
71ICPC_COMPILE_FLAGS="-O0 -fopenmp -qopenmp-offload=host"
72
73ROMP_CPP_COMPILE_FLAGS="-g -std=c++11 -fopenmp -lomp"
74ROMP_C_COMPILE_FLAGS="-g -fopenmp -lomp"
75
76FORTRAN_LINK_FLAGS="-ffree-line-length-none -fopenmp -c -fsanitize=thread"
77FORTRAN_COMPILE_FLAGS="-fopenmp -fsanitize=thread -lgfortran"
78IFORT_FORTRAN_FLAGS="-free -qopenmp -qopenmp-offload=host -Tf"
79POLYFLAG="micro-benchmarks/utilities/polybench.c -I micro-benchmarks -I micro-benchmarks/utilities -DPOLYBENCH_NO_FLUSH_CACHE -DPOLYBENCH_TIME -D_POSIX_C_SOURCE=200112L"
80FPOLYFLAG="-Imicro-benchmarks-fortran micro-benchmarks-fortran/utilities/fpolybench.o"
81VARLEN_PATTERN='[[:alnum:]]+-var-[[:alnum:]]+\.c'
82RACES_PATTERN='[[:alnum:]]+-[[:alnum:]]+-yes\.c'
83CPP_PATTERN='[[:alnum:]]+\.cpp'
84F_PATTERN='[[:alnum:]]+\.f95'
85F_VARLEN_PATTERN='[[:alnum:]]+-var-[[:alnum:]]+\.f95'
86F_RACES_PATTERN='[[:alnum:]]+-[[:alnum:]]+-yes\.f95'
87
88usage () {
89 echo
90 echo "Usage: $0 [--help] [OPTIONS]"
91 echo " --help : Show usage and options"
92 echo
93 echo "OPTIONS:"
94 echo " -x tool : Add the specified tool to test set."
95 echo " Value can be one of: gnu, clang, intel, helgrind, tsan-clang, tsan-gcc, archer, inspector, inspector-max-resources, romp."
96 echo " -n iterations : Run each setting the specified number of iterations."
97 echo " -t threads : Add the specified number of threads as a testcase."
98 echo " -d size : Add a specific dataset size to the varlen test suite."
99 echo " -s minutes : Add a specific timeout minutes."
100 echo " -l language : Add a specific language test"
101 echo " -c customized : Add a customized test list"
102 echo
103}
104
105valid_tool_name () {
106 case "$1" in
107 gnu) return 0 ;;
108 clang) return 0 ;;
109 intel) return 0 ;;
110 helgrind) return 0 ;;
111 archer) return 0 ;;
112 tsan-clang) return 0 ;;
113 tsan-gcc) return 0 ;;
114 inspector) return 0 ;;
115 inspector-max-resources) return 0 ;;
116 romp) return 0;;
117 *) return 1 ;;
118 esac
119}
120
121valid_language_name () {
122 case "$1" in
123 c/c++) return 0 ;;
124 C/C++) return 0 ;;
125 c) return 0 ;;
126 C) return 0 ;;
127 c++) return 0 ;;
128 C++) return 0 ;;
129 fortran) return 0 ;;
130 Fortran) return 0 ;;
131 FORTRAN) return 0 ;;
132 *) return 1 ;;
133 esac
134}
135
136check_return_code () {
137 case "$1" in
138 11) echo "Seg Fault"; testreturn=11 ;;
139 124) echo "Executime timeout";testreturn=124 ;;
140 139) echo "Seg Fault"; testreturn=11 ;;
141 *) testreturn=0 ;;
142 esac
143}
144
145if [[ "$1" == "--help" ]]; then
146 usage && exit 0;
147fi
148
149mkdir -p "$OUTPUT_DIR"
150mkdir -p "$LOG_DIR"
151mkdir -p "$EXEC_DIR"
152
153TOOLS=()
154DATASET_SIZES=()
155THREADLIST=()
156ITERATIONS=0
157TIMEOUTMIN="5"
158# Parse options
159while getopts "n:t:x:d:s:l:c:" opt; do
160 case $opt in
161 x) if valid_tool_name "${OPTARG}"; then TOOLS+=(${OPTARG});
162 else echo "Invalid tool name ${OPTARG}" && usage && exit 1
163 fi ;;
164 n) if [[ ${OPTARG} -gt 0 ]]; then ITERATIONS=${OPTARG};
165 else echo "Number of iterations must be greater than 0"
166 fi ;;
167 t) if [[ ${OPTARG} -gt 1 ]]; then THREADLIST+=(${OPTARG})
168 else echo "Number of threads must be greater than 1" && usage && exit 1;
169 fi ;;
170 d) if [[ ${OPTARG} -gt 1 ]]; then DATASET_SIZES+=(${OPTARG})
171 else echo "Dataset size must be greater than 1" && usage && exit 1;
172 fi ;;
173 s) if [[ ${OPTARG} -gt 0 ]]; then TIMEOUTMIN=(${OPTARG})
174 else echo "timeout must be greater than 0" && usage && exit 1;
175 fi ;;
176 l) if valid_language_name "${OPTARG}"; then LANGUAGE=${OPTARG};
177 else echo "Invalid language name ${OPTARG}" && help && exit 1;
178 fi ;;
179 c) if [[ ${OPTARG} -eq 1 ]]; then
180 if [[ "$LANGUAGE" == "c" || "$LANGUAGE" == "C" || "$LANGUAGE" == "c++" || "$LANGUAGE" == "C++" ]]; then
181 TEST=($(cat list.def));
182 for tests in "${TEST[@]}"; do
183 CTEST+=("micro-benchmarks/$tests")
184 done
185 TESTS=("${CTEST[@]}")
186 else
187 TEST=($(cat list.def));
188 for tests in "${TEST[@]}"; do
189 CTEST+=("micro-benchmarks-fortran/$tests")
190 done
191
192 FORTRANTESTS=("${CTEST[@]}")
193 fi
194 fi;;
195 esac
196done
197
198# Set default values
199if [[ ! ${#TOOLS[@]} -gt 0 ]]; then
200 echo "Default tool set will be used: gnu, clang, intel helgrind, tsan-clang, tsan-gcc, archer, inspector-max-resources."
201 TOOLS=( 'gnu' 'clang' 'intel' 'helgrind' 'tsan-clang' 'tsan-gcc' 'archer' 'inspector-max-resources' )
202else
203 echo "Tools: ${TOOLS[*]}";
204fi
205
206if [[ ! ${#DATASET_SIZES[@]} -gt 0 ]]; then
207 echo "Default dataset sizes will be used: 32, 64, 128, 256, 512, 1024."
208 DATASET_SIZES=('32' '64' '128' '256' '512' '1024')
209else
210 echo "Dataset sizes: ${DATASET_SIZES[*]}";
211fi
212
213if [[ ! ${#THREADLIST[@]} -gt 0 ]]; then
214 echo "Default thread counts will be used: 3, 36, 45, 72, 90, 180, 256."
215 THREADLIST=('3' '36' '45' '72' '90' '180' '256')
216else
217 echo "Thread counts: ${THREADLIST[*]}";
218fi
219
220if [[ ! $ITERATIONS -gt 0 ]]; then
221 echo "Default number of iterations will be used: 3"
222 ITERATIONS=3
223else
224 echo "Iterations: ${ITERATIONS}";
225fi
226
227if [[ ! $TIMEOUTMIN -gt 0 ]]; then
228 echo "Default timeout will be 5 minutes"
229 TIMEOUTMIN=5
230else
231 echo "Timeout minutes: ${TIMEOUTMIN}";
232fi
233
234if [[ -e "$LOGFILE" ]]; then rm "$LOGFILE"; fi
235
236# Increase stack size - Fixes crashes in some analyses
237ULIMITS=$(ulimit -s)
238ulimit -s unlimited
239
240TOOL_INDEX=0
241TEST_INDEX=0
242THREAD_INDEX=0
243SIZE_INDEX=0
244ITER=1
245
246cleanup () {
247 ulimit -s "$ULIMITS"
248 if [[ -e $exname ]]; then rm "$exname"; fi
249 echo "EXITING"
250 echo "--------------------------" >> "$LOGFILE"
251 echo "Unfinished tests:" >> "$LOGFILE"
252 for tool in "${TOOLS[@]:$TOOL_INDEX}"; do
253 if [[ $TEST_INDEX -eq 0 && $THREAD_INDEX -eq 0 && $SIZE_INDEX -eq 0 && $ITER -eq 1 ]]; then
254 echo "$tool,all,all,all,$ITERATIONS" >> "$LOGFILE"
255 else
256 for test in "${TESTS[@]:$TEST_INDEX}"; do
257 if [[ $THREAD_INDEX -eq 0 && $SIZE_INDEX -eq 0 && $ITER -eq 1 ]]; then
258 echo "$tool,\"$test\",all,all,$ITERATIONS" >> "$LOGFILE"
259 else
260 for thread in "${THREADLIST[@]:$THREAD_INDEX}"; do
261 if [[ $SIZE_INDEX -eq 0 && $ITER -eq 1 ]]; then
262 echo "$tool,\"$test\",$thread,all,$ITERATIONS" >> "$LOGFILE"
263 else
264 for size in "${SIZES[@]:$SIZE_INDEX}"; do
265 if [[ $ITER -eq 1 ]]; then echo "$tool,\"$test\",$thread,${size:-"N/A"},$ITERATIONS" >> "$LOGFILE"
266 else echo "$tool,\"$test\",$thread,all,$((ITERATIONS - ITER + 1))" >> "$LOGFILE"; ITER=1; fi
267 done
268 SIZE_INDEX=0
269 fi
270 done
271 THREAD_INDEX=0
272 fi
273 done
274 TEST_INDEX=0
275 fi
276 done
277 exit 1
278}
279
280trap cleanup SIGINT SIGTERM
281
282if [[ "$LANGUAGE" == "c" || "$LANGUAGE" == "C" || "$LANGUAGE" == "c++" || "$LANGUAGE" == "C++" ]]; then
283
284for tool in "${TOOLS[@]}"; do
285
286 MEMLOG="$LOG_DIR/$tool.memlog"
287 file="$OUTPUT_DIR/$tool.csv"
288 echo "Saving to: $file and $MEMLOG"
289 [ -e "$file" ] && rm "$file"
290 echo "$CSV_HEADER" >> "$file"
291
292 runtime_flags=''
293 case "$tool" in
294 'inspector-max-resources')
295 runtime_flags+=" -collect ti3 -knob scope=extreme -knob stack-depth=16 -knob use-maximum-resources=true"
296 tool='inspector'
297 ;;
298 'inspector')
299 runtime_flags+=" -collect ti2"
300 ;;
301 esac
302
303 TEST_INDEX=0
304 for test in "${TESTS[@]}"; do
305 echo "test is $test"
306 additional_compile_flags=''
307 if [[ "$test" =~ $RACES_PATTERN ]]; then haverace=true; else haverace=false; fi
308 if [[ "$test" =~ $VARLEN_PATTERN ]]; then SIZES=("${DATASET_SIZES[@]}"); else SIZES=(''); fi
309 testname=$(basename $test)
310 id=${testname#DRB}
311 id=${id%%-*}
312 echo "$test has $testname and ID=$id"
313
314 # Compile
315 exname="$EXEC_DIR/$(basename "$test").$tool.out"
316 rompexec="$exname.inst"
317 logname="$(basename "$test").$tool.log"
318 if [[ -e "$LOG_DIR/$logname" ]]; then rm "$LOG_DIR/$logname"; fi
319 if grep -q 'PolyBench' "$test"; then additional_compile_flags+=" $POLYFLAG"; fi
320
321 if [[ "$test" =~ $CPP_PATTERN ]]; then
322 echo "testing C++ code:$test"
323 case "$tool" in
324 gnu) g++ -g -fopenmp $additional_compile_flags $test -o $exname -lm ;;
325 clang) clang++ -fopenmp -g $additional_compile_flags $test -o $exname -lm ;;
326 intel) icpc $ICPC_COMPILE_FLAGS $additional_compile_flags $test -o $exname -lm ;;
327 helgrind) g++ $VALGRIND_COMPILE_CPP_FLAGS $additional_compile_flags $test -o $exname -lm ;;
328 archer) clang-archer++ $ARCHER_COMPILE_FLAGS $additional_compile_flags $test -o $exname -lm ;;
329 tsan-clang) clang++ $TSAN_COMPILE_FLAGS $additional_compile_flags $test -o $exname -lm ;;
330 tsan-gcc) g++ $TSAN_COMPILE_FLAGS $additional_compile_flags $test -o $exname -lm ;;
331 inspector) icpc $ICPC_COMPILE_FLAGS $additional_compile_flags $test -o $exname -lm ;;
332 romp) g++ $ROMP_CPP_COMPILE_FLAGS $additional_compile_flags $test -o $exname -lm;
333 echo $exname
334 InstrumentMain --program=$exname;
335 esac
336 else
337 case "$tool" in
338 gnu) gcc -g -std=c99 -fopenmp $additional_compile_flags $test -o $exname -lm ;;
339 clang) clang -fopenmp -g $additional_compile_flags $test -o $exname -lm ;;
340 intel) icc $ICC_COMPILE_FLAGS $additional_compile_flags $test -o $exname -lm ;;
341 helgrind) gcc $VALGRIND_COMPILE_C_FLAGS $additional_compile_flags $test -o $exname -lm ;;
342 archer) clang-archer $ARCHER_COMPILE_FLAGS $additional_compile_flags $test -o $exname -lm ;;
343 tsan-clang) clang $TSAN_COMPILE_FLAGS $additional_compile_flags $test -o $exname -lm ;;
344 tsan-gcc) gcc $TSAN_COMPILE_FLAGS $additional_compile_flags $test -o $exname -lm ;;
345 inspector) icc $ICC_COMPILE_FLAGS $additional_compile_flags $test -o $exname -lm ;;
346 romp) gcc $ROMP_C_COMPILE_FLAGS $additional_compile_flags $test -o $exname -lm;
347 echo $exname
348 InstrumentMain --program=$exname;
349 esac
350 fi
351 compilereturn=$?;
352 echo "compile return code: $compilereturn";
353
354 THREAD_INDEX=0
355 for thread in "${THREADLIST[@]}"; do
356 echo "Testing $test: with $thread threads"
357 export OMP_NUM_THREADS=$thread
358 SIZE_INDEX=0
359 for size in "${SIZES[@]}"; do
360 # Sanity check
361 if [[ ! -e "$exname" ]]; then
362 echo "$tool,$id,\"$testname\",$haverace,$thread,${size:-"N/A"},,,,$compilereturn," >> "$file";
363 echo "Executable for $testname with $thread threads and input size $size is not available" >> "$LOGFILE";
364 elif { "./$exname $size"; } 2>&1 | grep -Eq 'Segmentation fault'; then
365 echo "$tool,$id,\"$testname\",$haverace,$thread,${size:-"N/A"},,,,$compilereturn," >> "$file";
366 echo "Seg fault found in $testname with $thread threads and input size $size" >> "$LOGFILE";
367 else
368 ITER_INDEX=1
369 for ITER in $(seq 1 "$ITERATIONS"); do
370 echo -e "***** Log $ITER_INDEX for $testname with $thread threads and input size $size *****" >> "$LOG_DIR/$logname"
371 start=$(date +%s%6N)
372 case "$tool" in
373 gnu)
374 #races=$($TIMEOUTCMD $TIMEOUTMIN"m" $MEMCHECK -f "%M" -o "$MEMLOG" "./$exname" $size 2>&1 | tee -a "$LOG_DIR/$logname" | grep -ce 'Possible data race') ;;
375 ;&
376 clang)
377 #races=$($MEMCHECK -f "%M" -o "$MEMLOG" "./$exname" $size 2>&1 | tee -a "$LOG_DIR/$logname" | grep -ce 'Possible data race') ;;
378 ;&
379 intel)
380 #races=$($MEMCHECK -f "%M" -o "$MEMLOG" "./$exname" $size 2>&1 | tee -a "$LOG_DIR/$logname" | grep -ce 'Possible data race') ;;
381 $TIMEOUTCMD $TIMEOUTMIN"m" $MEMCHECK -f "%M" -o "$MEMLOG" "./$exname" $size &> tmp.log;
382 check_return_code $?;
383 echo "testname return $testreturn";
384 races="",
385 cat tmp.log >> "$LOG_DIR/$logname" || >tmp.log ;;
386 helgrind)
387# races=$($MEMCHECK -f "%M" -o "$MEMLOG" $VALGRIND --tool=helgrind "./$exname" $size 2>&1 | tee -a "$LOG_DIR/$logname" | grep -ce 'Possible data race') ;;
388 $TIMEOUTCMD $TIMEOUTMIN"m" $MEMCHECK -f "%M" -o "$MEMLOG" $VALGRIND --tool=helgrind "./$exname" $size &> tmp.log;
389 check_return_code $?;
390 echo "testname return $testreturn"
391 races=$(grep -ce 'Possible data race' tmp.log)
392 cat tmp.log >> "$LOG_DIR/$logname" || >tmp.log ;;
393 archer)
394 $TIMEOUTCMD $TIMEOUTMIN"m" $MEMCHECK -f "%M" -o "$MEMLOG" "./$exname" $size &> tmp.log;
395 check_return_code $?;
396 echo "testname return $testreturn"
397 races=$(grep -ce 'WARNING: ThreadSanitizer: data race' tmp.log)
398 cat tmp.log >> "$LOG_DIR/$logname" || >tmp.log ;;
399 tsan-clang)
400# races=$($MEMCHECK -f "%M" -o "$MEMLOG" "./$exname" $size 2>&1 | tee -a "$LOG_DIR/$logname" | grep -ce 'WARNING: ThreadSanitizer: data race') ;;
401 $TIMEOUTCMD $TIMEOUTMIN"m" $MEMCHECK -f "%M" -o "$MEMLOG" env TSAN_OPTIONS="ignore_noninstrumented_modules=1" "./$exname" $size &> tmp.log;
402 check_return_code $?;
403 echo "testname return $testreturn"
404 races=$(grep -ce 'WARNING: ThreadSanitizer: data race' tmp.log)
405 cat tmp.log >> "$LOG_DIR/$logname" || >tmp.log ;;
406 tsan-gcc)
407# races=$($MEMCHECK -f "%M" -o "$MEMLOG" "./$exname" $size 2>&1 | tee -a "$LOG_DIR/$logname" | grep -ce 'WARNING: ThreadSanitizer: data race') ;;
408 $TIMEOUTCMD $TIMEOUTMIN"m" $MEMCHECK -f "%M" -o "$MEMLOG" "./$exname" $size &> tmp.log;
409 check_return_code $?;
410 echo "testname return $testreturn"
411 races=$(grep -ce 'WARNING: ThreadSanitizer: data race' tmp.log)
412 cat tmp.log >> "$LOG_DIR/$logname" || >tmp.log ;;
413 inspector)
414# races=$($MEMCHECK -f "%M" -o "$MEMLOG" $INSPECTOR $runtime_flags -- "./$exname" $size 2>&1 | tee -a "$LOG_DIR/$logname" | grep 'Data race' | sed -E 's/[[:space:]]*([[:digit:]]+).*/\1/') ;;
415 $TIMEOUTCMD $TIMEOUTMIN"m" $MEMCHECK -f "%M" -o "$MEMLOG" $INSPECTOR $runtime_flags -- "./$exname" $size &> tmp.log;
416 check_return_code $?;
417 echo "testname return $testreturn";
418 races=$(grep 'Data race' tmp.log | sed -E 's/[[:space:]]*([[:digit:]]+).*/\1/');
419 cat tmp.log >> "$LOG_DIR/$logname" || >tmp.log ;;
420 romp)
421 $TIMEOUTCMD $TIMEOUTMIN"m" $MEMCHECK -f "%M" -o "$MEMLOG" "./$rompexec" $size &> tmp.log;
422 check_return_code $?;
423 echo "testname return $testreturn"
424 races=$(grep -ce 'data race found:' tmp.log)
425 cat tmp.log >> "$LOG_DIR/$logname" || >tmp.log ;;
426 #races=$("./$exname" $size 2>&1 | tee -a "$LOG_DIR/$logname" | grep -ce 'race found!') ;;
427 esac
428 end=$(date +%s%6N)
429 elapsedtime=$(echo "scale=3; ($end-$start)/1000000"|bc)
430 mem=$(cat $MEMLOG)
431 echo "$tool,$id,\"$testname\",$haverace,$thread,${size:-"N/A"},${races:-0},$elapsedtime,$mem,$compilereturn,$testreturn" >> "$file"
432 ITER_INDEX=$((ITER_INDEX+1))
433 done
434 fi
435 SIZE_INDEX=$((SIZE_INDEX+1))
436 done
437 THREAD_INDEX=$((THREAD_INDEX+1))
438 done
439 TEST_INDEX=$((TEST_INDEX+1))
440 #if [[ -e $exname ]]; then rm "$exname"; fi
441 done
442 TOOL_INDEX=$((TOOL_INDEX+1))
443done
444
445elif [[ "$LANGUAGE" == "fortran" || "$LANGUAGE" == "FORTRAN" ]]; then
446
447for tool in "${TOOLS[@]}"; do
448
449 MEMLOG="$LOG_DIR/$tool.memlog"
450 file="$OUTPUT_DIR/$tool.csv"
451 echo "Saving to: $file and $MEMLOG"
452 [ -e "$file" ] && rm "$file"
453 echo "$CSV_HEADER" >> "$file"
454
455 runtime_flags=''
456 case "$tool" in
457 'inspector-max-resources')
458 runtime_flags+=" -collect ti3 -knob scope=extreme -knob stack-depth=16 -knob use-maximum-resources=true"
459 tool='inspector'
460 ;;
461 'inspector')
462 runtime_flags+=" -collect ti2"
463 ;;
464 esac
465
466 TEST_INDEX=0
467 for test in "${FORTRANTESTS[@]}"; do
468 additional_compile_flags=''
469 if [[ "$test" =~ $F_RACES_PATTERN ]]; then haverace=true; else haverace=false; fi
470 if [[ "$test" =~ $F_VARLEN_PATTERN ]]; then SIZES=("${DATASET_SIZES[@]}"); else SIZES=(''); fi
471 testname=$(basename $test)
472 id=${testname#DRB}
473 id=${id%%-*}
474 echo "$test has $testname and ID=$id"
475
476 # Compile
477 linkname="$EXEC_DIR/$testname.o"
478 exname="$EXEC_DIR/$(basename "$test").$tool.out"
479 rompexec="$exname.inst"
480 logname="$(basename "$test").$tool.log"
481 linklib=" "
482 if [[ -e "$LOG_DIR/$logname" ]]; then rm "$LOG_DIR/$logname"; fi
483 if grep -q 'PolyBench' "$test"; then additional_compile_flags+=" $FPOLYFLAG";gcc -c micro-benchmarks-fortran/utilities/fpolybench.c -o micro-benchmarks-fortran/utilities/fpolybench.o ; linklib+="micro-benchmarks-fortran/utilities/fpolybench.o"; fi
484
485 echo "testing Fortran code:$test"
486 case "$tool" in
487 gnu) gfortran -fopenmp -lomp $additional_compile_flags $test -o $exname -lm ;;
488 intel) ifort $IFORT_FORTRAN_FLAGS $test -o $exname -lm ;;
489 tsan-clang) gfortran $FORTRAN_LINK_FLAGS $additional_compile_flags $test -o $linkname;
490 clang $FORTRAN_COMPILE_FLAGS $linkname $linklib -o $exname -lm;;
491 tsan-gcc) gfortran -fopenmp -fsanitize=thread $additional_compile_flags $test -o $exname -lm ;;
492 archer) gfortran $FORTRAN_LINK_FLAGS $additional_compile_flags $test -o $linkname;
493 clang-archer $FORTRAN_COMPILE_FLAGS $linkname $linklib -o $exname $ARCHER_COMPILE_FLAGS -lm;;
494 inspector) ifort $IFORT_FORTRAN_FLAGS $test -o $exname -lm ;;
495 romp) gfortran -fopenmp -lomp -ffree-line-length-none $additional_compile_flags $test -o $exname -lm;
496 echo $exname
497 InstrumentMain --program=$exname;;
498 esac
499 compilereturn=$?;
500 echo "compile return code: $compilereturn";
501
502 THREAD_INDEX=0
503 for thread in "${THREADLIST[@]}"; do
504 echo "Testing $test: with $thread threads"
505 export OMP_NUM_THREADS=$thread
506 SIZE_INDEX=0
507 for size in "${SIZES[@]}"; do
508 # Sanity check
509 if [[ ! -e "$exname" ]]; then
510 echo "$tool,$id,\"$testname\",$haverace,$thread,${size:-"N/A"},,,,$compilereturn," >> "$file";
511 echo "Executable for $testname with $thread threads and input size $size is not available" >> "$LOGFILE";
512 elif { "./$exname $size"; } 2>&1 | grep -Eq 'Segmentation fault'; then
513 echo "$tool,$id,\"$testname\",$haverace,$thread,${size:-"N/A"},,,,$compilereturn," >> "$file";
514 echo "Seg fault found in $testname with $thread threads and input size $size" >> "$LOGFILE";
515 else
516 ITER_INDEX=1
517 for ITER in $(seq 1 "$ITERATIONS"); do
518 echo -e "***** Log $ITER_INDEX for $testname with $thread threads and input size $size *****" >> "$LOG_DIR/$logname"
519 start=$(date +%s%6N)
520 case "$tool" in
521 gnu)
522 #races=$($TIMEOUTCMD $TIMEOUTMIN"m" $MEMCHECK -f "%M" -o "$MEMLOG" "./$exname" $size 2>&1 | tee -a "$LOG_DIR/$logname" | grep -ce 'Possible data race') ;;
523 ;&
524 clang)
525 #races=$($MEMCHECK -f "%M" -o "$MEMLOG" "./$exname" $size 2>&1 | tee -a "$LOG_DIR/$logname" | grep -ce 'Possible data race') ;;
526 ;&
527 intel)
528 #races=$($MEMCHECK -f "%M" -o "$MEMLOG" "./$exname" $size 2>&1 | tee -a "$LOG_DIR/$logname" | grep -ce 'Possible data race') ;;
529 $TIMEOUTCMD $TIMEOUTMIN"m" $MEMCHECK -f "%M" -o "$MEMLOG" "./$exname" $size &> tmp.log;
530 check_return_code $?;
531 echo "testname return $testreturn";
532 races="",
533 cat tmp.log >> "$LOG_DIR/$logname" || >tmp.log ;;
534 helgrind)
535# races=$($MEMCHECK -f "%M" -o "$MEMLOG" $VALGRIND --tool=helgrind "./$exname" $size 2>&1 | tee -a "$LOG_DIR/$logname" | grep -ce 'Possible data race') ;;
536 $TIMEOUTCMD $TIMEOUTMIN"m" $MEMCHECK -f "%M" -o "$MEMLOG" $VALGRIND --tool=helgrind "./$exname" $size &> tmp.log;
537 check_return_code $?;
538 echo "testname return $testreturn"
539 races=$(grep -ce 'Possible data race' tmp.log)
540 cat tmp.log >> "$LOG_DIR/$logname" || >tmp.log ;;
541 archer)
542 $TIMEOUTCMD $TIMEOUTMIN"m" $MEMCHECK -f "%M" -o "$MEMLOG" "./$exname" $size &> tmp.log;
543 check_return_code $?;
544 echo "testname return $testreturn"
545 races=$(grep -ce 'WARNING: ThreadSanitizer: data race' tmp.log)
546 cat tmp.log >> "$LOG_DIR/$logname" || >tmp.log ;;
547 tsan-clang)
548# races=$($MEMCHECK -f "%M" -o "$MEMLOG" "./$exname" $size 2>&1 | tee -a "$LOG_DIR/$logname" | grep -ce 'WARNING: ThreadSanitizer: data race') ;;
549 $TIMEOUTCMD $TIMEOUTMIN"m" $MEMCHECK -f "%M" -o "$MEMLOG" env TSAN_OPTIONS="ignore_noninstrumented_modules=1" "./$exname" $size &> tmp.log;
550 check_return_code $?;
551 echo "testname return $testreturn"
552 races=$(grep -ce 'WARNING: ThreadSanitizer: data race' tmp.log)
553 cat tmp.log >> "$LOG_DIR/$logname" || >tmp.log ;;
554 tsan-gcc)
555# races=$($MEMCHECK -f "%M" -o "$MEMLOG" "./$exname" $size 2>&1 | tee -a "$LOG_DIR/$logname" | grep -ce 'WARNING: ThreadSanitizer: data race') ;;
556 $TIMEOUTCMD $TIMEOUTMIN"m" $MEMCHECK -f "%M" -o "$MEMLOG" "./$exname" $size &> tmp.log;
557 check_return_code $?;
558 echo "testname return $testreturn"
559 races=$(grep -ce 'WARNING: ThreadSanitizer: data race' tmp.log)
560 cat tmp.log >> "$LOG_DIR/$logname" || >tmp.log ;;
561 inspector)
562# races=$($MEMCHECK -f "%M" -o "$MEMLOG" $INSPECTOR $runtime_flags -- "./$exname" $size 2>&1 | tee -a "$LOG_DIR/$logname" | grep 'Data race' | sed -E 's/[[:space:]]*([[:digit:]]+).*/\1/') ;;
563 $TIMEOUTCMD $TIMEOUTMIN"m" $MEMCHECK -f "%M" -o "$MEMLOG" $INSPECTOR $runtime_flags -- "./$exname" $size &> tmp.log;
564 check_return_code $?;
565 echo "testname return $testreturn";
566 races=$(grep 'Data race' tmp.log | sed -E 's/[[:space:]]*([[:digit:]]+).*/\1/');
567 cat tmp.log >> "$LOG_DIR/$logname" || >tmp.log ;;
568 romp)
569 $TIMEOUTCMD $TIMEOUTMIN"m" $MEMCHECK -f "%M" -o "$MEMLOG" "./$rompexec" $size &> tmp.log;
570 check_return_code $?;
571 echo "testname return $testreturn"
572 races=$(grep -ce 'data race found:' tmp.log)
573 cat tmp.log >> "$LOG_DIR/$logname" || >tmp.log ;;
574 #races=$("./$exname" $size 2>&1 | tee -a "$LOG_DIR/$logname" | grep -ce 'race found!') ;;
575 esac
576 end=$(date +%s%6N)
577 elapsedtime=$(echo "scale=3; ($end-$start)/1000000"|bc)
578 mem=$(cat $MEMLOG)
579 echo "$tool,$id,\"$testname\",$haverace,$thread,${size:-"N/A"},${races:-0},$elapsedtime,$mem,$compilereturn,$testreturn" >> "$file"
580 ITER_INDEX=$((ITER_INDEX+1))
581 done
582 fi
583 SIZE_INDEX=$((SIZE_INDEX+1))
584 done
585 THREAD_INDEX=$((THREAD_INDEX+1))
586 done
587 TEST_INDEX=$((TEST_INDEX+1))
588 #if [[ -e $exname ]]; then rm "$exname"; fi
589 done
590 TOOL_INDEX=$((TOOL_INDEX+1))
591done
592fi
593for tool in "${TOOLS[@]}"; do
594 python3 scripts/metric.py $OUTPUT_DIR/$tool.csv
595done
596[ ! -f *.mod ] || rm *.mod
597[ ! -d r*ti3 ] || rm -rf r*ti3
598[ ! -f micro-benchmarks-fortran/utilities/fpolybench.o ] || rm micro-benchmarks-fortran/utilities/fpolybench.o
599[ ! -f micro-benchmarks/utilities/polybench.o ] || rm micro-benchmarks/utilities/polybench.o
600ulimit -s "$ULIMITS"
Note: See TracBrowser for help on using the repository browser.