source: doc/theses/colby_parsons_MMAth/benchmarks/actors/run

Last change on this file was 7c4416a, checked in by caparsons <caparson@…>, 11 months ago

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc
  • Property mode set to 100755
File size: 18.8 KB
Line 
1#!/bin/bash -
2
3false=0; true=1
4
5# Usage: arch [ hostname ] returns hostname, cores, startcore
6#
7#   Define machine architecture based on starting socket, CPUs (cores) per socket, number of
8#   sockets, has hyperthreading.
9
10start=0
11
12arch() {
13        hostname=${1:-`hostname`}                       # return value
14        hashyper=${true}                                        # assume machine has hyperthreads
15        if [ "${hostname}" = "plg2" ] ; then
16                startsocket=${start}
17                cps=16                                                  # coresPerSocket
18                sockets=2
19                hashyper=${false}                               # has no hyperthreads
20        elif [ "${hostname}" = "nasus" ] ; then
21                startsocket=${start}
22                cps=64                                                  # coresPerSocket
23                sockets=2
24        elif [ "${hostname}" = "pyke" ] ; then
25                startsocket=${start}
26                cps=24                                                  # coresPerSocket
27                sockets=2
28        elif [ "${hostname}" = "jax" ] ; then
29                startsocket=${start}
30                cps=24                                                  # coresPerSocket
31                sockets=4
32        else
33                echo "unsupported host" ${hostname}
34                exit 1
35        fi
36        cores=$(( ${cps} * ${sockets} ))
37        startcore=$(( ${startsocket} * ${cps} ))
38}
39
40# Usage: affinity (global cps, sockets, startsocket, hashyper, cores, startcore, wrap)
41#   returns taskset argument
42#
43#   This routine assumes hyperthreading has only 2 hyperthreads per core.
44#
45#   If hyperthread scanning is used: processor units are assigned across the low-number hyperthreads
46#   of the socket's cores. When the low-number hyperthreads are filled, the high-number hyperhtreads
47#   are assigned across the socket's cores. Then the next socket is assigned.
48#
49#   If hyperthread wrapping is used: processor units are assigned in low/high-number pairs of
50#   hyperthreads across the socket's cores. Then the next socket is assigned.
51
52wrap=${false}                                                   # set to control hyperthread assignment across socket cores
53
54affinity() {
55        if [ ${wrap} -eq ${true} -a ${hashyper} -eq ${false} ] ; then
56                echo "architecture does not support hyperthreading for wrapping"
57                exit 1
58        fi
59        taskset=""                                                      # return value
60        set -- $(( ${1} - 1 ))                          # decrement $1
61        if [ ${1} -eq 0 ] ; then taskset="${startcore}-${startcore}"; return; fi
62        if [ ${1} -ge $(( ${cps} * ( ${sockets} - ${startsocket} ) * ( ${hashyper} + 1 ) )) ] ; then # error
63                echo "not enough cores $(( ${cores} * ${sockets} )) for $(( ${1} + 1 )) starting at ${startcore}"
64                exit 1
65        fi
66        if [ ${hashyper} -eq ${false} ] ; then taskset="${startcore}-$(( ${1} + ${startcore} ))"; return; fi # no hyperthreads
67        start2=$(( ${startcore} + ${cores} ))
68        if [ ${wrap} -eq ${true} ] ; then       # hyperthread wrapping
69                end1=$(( ${1} / 2 + ${startcore} ))
70                end2=$(( ${end1} + ${cores} ))
71                if [ $(( ${1} % 2 )) -eq 0 ] ; then
72                        end2=$(( ${end2} - 1 ))
73                fi
74                taskset="${startcore}-${end1},${start2}-${end2}"
75        else                                                            # hyperthread scanning
76                if [ ${1} -lt ${cps} ] ; then taskset="${startcore}-$(( ${1} + ${startcore} ))"; return; fi
77                filled=$(( ${1} / ( ${cps} * 2 ) * ${cps} ))
78                modulus=$(( ${1} % ( ${cps} * 2 ) ))    # leftover cores added to saturated sockets
79                if [ ${modulus} -gt ${cps} ] ; then
80                        taskset="${startcore}-$(( ${startcore} + ${filled} + ${cps} - 1 )),${start2}-$(( ${start2} + ${filled} + ${modulus} % ${cps} ))"
81                else
82                        taskset="${startcore}-$(( ${startcore} + ${filled} + ${modulus} )),${start2}-$(( ${start2} + ${filled} - 1 ))"
83                fi
84        fi
85}
86
87#used for output formatting
88column_headers="proc\ttime (s)"
89
90# executor config
91batch='100'
92nRounds='400' #500
93
94# matrix config
95size='3072'
96
97# repeat config
98messages='100000'
99n_repeats='200' #200
100
101# balance config
102nOneRounds='2000'
103nMultiRounds='800'
104
105# static config
106n_static_sends='100000000'
107n_static_sends_slow='10000000'
108
109# dynamic config
110n_dynamic_sends='20000000'
111n_dynamic_sends_slow='2000000'
112
113numtimes=5
114
115# bench_cores='1 2 4 8 16 24 32'
116bench_cores='1 2 4 8 16 24 32 48'
117# bench_cores='48'
118
119# toggle missed gulp tracking config (overrides specified config)
120missed_gulps=${true}
121# missed_gulps=${false}
122
123# toggle mem collection config (overrides specified config)
124# outputs mem instead of time
125mem=${true}
126mem=${false}
127
128# toggle benchmarks
129executor=${true}
130matrix=${true}
131repeat=${true}
132balance=${true}
133static=${true}
134dynamic=${true}
135# executor=${false}
136# matrix=${false}
137# repeat=${false}
138# balance=${false}
139# static=${false}
140# dynamic=${false}
141
142# names=('Longest-Victim' 'No-Stealing' 'Random')
143# var_flags=('-D__STEAL=1 -DSEARCH=1' '' '-D__STEAL=1 -DRAND=1')
144
145# names=('CFA' 'CFA-EMPTY')
146# var_flags=('' '-DEMPTY')
147
148# names=('CFA')
149# var_flags=('-D__STEAL=1 -DSEARCH=1')
150
151# names=('CFA' 'CFA-STAT')
152# var_flags=('-D__STEAL=1 -DSEARCH=1' '-D__STEAL=1 -DSTATS')
153
154# names=()
155# var_flags=()
156
157names=('CFA')
158var_flags=('')
159
160runCAF=${true}
161runUCPP=${true}
162runPROTO=${true}
163runAKKA=${true}
164runCAF=${false}
165runUCPP=${false}
166runPROTO=${false}
167runAKKA=${false}
168
169if [ ${missed_gulps} -eq ${true} ] ; then
170    bench_cores='2 4 8 16 24 32 48'
171    column_headers="proc\tmissed\ttime (s)"
172    names=('CFA')
173    var_flags=('-D__STEAL=1 -DSEARCH=1 -DACTOR_STATS_QUEUE_MISSED')
174    runCAF=${false}
175    runUCPP=${false}
176    runPROTO=${false}
177    runAKKA=${false}
178    executor=${true}
179    matrix=${true}
180    repeat=${true}
181fi
182
183if [ ${mem} -eq ${true} ] ; then
184    bench_cores='48'
185    column_headers="proc\tmem (kB)"
186    names=('CFA')
187    var_flags=('-D__STEAL=1 -DSEARCH=1')
188    runCAF=${true}
189    runUCPP=${true}
190    runPROTO=${true}
191    runAKKA=${true}
192    executor=${true}
193    matrix=${false}
194    repeat=${false}
195    balance=${false}
196    static=${false}
197    dynamic=${false}
198fi
199
200cfa=~/cfa-cc/driver/cfa
201
202# Helpers to minimize code duplication
203
204# repeats a command ${numtimes}
205preprint=''
206repeat_command() {
207    t=1
208    while [ ${t} -le ${numtimes} ] ; do
209        echo -n -e ${preprint}
210        "${@}"
211        t=`expr ${t} + 1`
212    done
213}
214
215# prints the leading info for a given run of a variant
216print_header() {
217    echo ${1}':'
218    if [ ${mem} -eq ${false} ] ; then
219        echo -e $column_headers
220    fi
221}
222
223# runs the current benchmark with provided args
224# only works for standard-run benchmarks (not Akka)
225# must split into pre and post args to be able to supply val of p
226pre_args=''
227post_args=''
228single_run() {
229    affinity ${1}
230    preprint="${1}\t"
231    if [ ${mem} -eq ${true} ] ; then
232        repeat_command /usr/bin/time -f "%M" taskset -c ${taskset} ./a.${hostname} ${pre_args} ${1} ${post_args} > /dev/null
233    else
234        repeat_command taskset -c ${taskset} ./a.${hostname} ${pre_args} ${1} ${post_args}
235    fi
236}
237
238# runs the current bench for all processor vals
239# works for standard benchs that dont need to set a config file (not Akka or CAF)
240run_bench() {
241    for p in ${bench_cores} ; do
242        single_run ${p}
243    done
244}
245
246set_akka_parallelism() {
247    sed -i "s/parallelism-min = .*/parallelism-min = ${1}/g" application.conf
248    sed -i "s/parallelism-max = .*/parallelism-max = ${1}/g" application.conf
249}
250
251arch # get hostname
252
253# set up leading info for python script
254echo $numtimes
255echo $bench_cores
256
257for i in ${!names[@]}; do
258    echo -n ${names[$i]}" "
259done
260if [ ${runCAF} -eq ${true} ] ; then
261    echo -n 'CAF '
262fi # done CAF
263if [ ${runAKKA} -eq ${true} ] ; then
264    echo -n 'Akka '
265fi # done AKKA
266if [ ${runUCPP} -eq ${true} ] ; then
267    echo -n 'uC++ '
268fi # done UCPP
269if [ ${runPROTO} -eq ${true} ] ; then
270    echo -n 'ProtoActor '
271fi
272echo ""
273
274# done printing header info for output
275
276# cfa flags
277cfa_flags='-quiet -O3 -nodebug -DNDEBUG'
278
279# CAF flags
280prefixCAF='-O3 -Wall -std=c++17 -I/home/pabuhr/software/nasus/Actors/experiments/CAF/actor-framework/libcaf_core -I/home/pabuhr/software/nasus/Actors/experiments/CAF/actor-framework/libcaf_core/caf -I/home/pabuhr/software/nasus/Actors/experiments/CAF/actor-framework/build/libcaf_core -L/home/pabuhr/software/nasus/Actors/experiments/CAF/actor-framework/build/libcaf_core -L/home/pabuhr/software/nasus/Actors/experiments/CAF/actor-framework/build/libcaf_io'
281suffixCAF='-lcaf_io -lcaf_core -Wl,-rpath=CAF/actor-framework/build/libcaf_core'
282
283# AKKA flags
284sbtflags="--warn -J-Xmx32g"
285
286# UCPP flags
287UCPPflags="-quiet -g -Wall -Wextra -O3 -nodebug -DNDEBUG -multi"
288UCPP=~/ucpp/u++-7.0.0/bin/u++
289
290# run the benchmarks
291
292# /usr/bin/time -f "%Uu %Ss %Er %Mkb"
293if [ ${executor} -eq ${true} ] ; then
294    if [ ${mem} -eq ${false} ] ; then
295        echo "executor"
296    else
297        echo "mem"
298    fi
299    pre_args="40000 100 ${nRounds}"
300    post_args="${batch}"
301    cd cfa # CFA RUN
302    for i in ${!names[@]}; do
303        print_header ${names[$i]}
304        ${cfa} ${cfa_flags} ${var_flags[$i]} executor.cfa -o a.${hostname} > /dev/null 2>&1
305        run_bench
306        rm a.${hostname}
307    done
308    cd - > /dev/null # done CFA
309    if [ ${runCAF} -eq ${true} ] ; then # CAF RUN
310        cd caf
311        print_header 'CAF'
312        g++ ${prefixCAF} CAFExecutor.cpp ${suffixCAF} -o a.${hostname} > /dev/null 2>&1
313        for p in ${bench_cores} ; do
314            sed -i "s/max-threads = .*/max-threads = ${p}/g" caf-application.conf # set CAF parallelism
315            single_run ${p}
316        done
317        rm a.${hostname}
318        # set back parallelism
319        sed -i "s/max-threads = .*/max-threads = 1/g" caf-application.conf
320        cd - > /dev/null
321    fi # done CAF
322    if [ ${runAKKA} -eq ${true} ] ; then # AKKA RUN
323        cd akka/Executor
324        rm -rf project target                           # random out of memory errors without this
325        print_header 'Akka'
326        for p in ${bench_cores} ; do
327            set_akka_parallelism ${p}
328            affinity ${p}
329            if [ ${mem} -eq ${true} ] ; then
330                t=1
331                while [ ${t} -le ${numtimes} ] ; do
332                    /usr/bin/time -f "%M" taskset -c ${taskset} sbt ${sbtflags} "run ${pre_args} ${p} ${post_args} 1" 2>&1 | grep -v "SLF4J:" | grep -v "Slf4jLogger started" | sed -e "s/\x1b\[0J//" | grep -v "\."
333                    t=`expr ${t} + 1`
334                done
335            else
336                taskset -c ${taskset} sbt ${sbtflags} "run ${pre_args} ${p} ${post_args} ${numtimes}" 2>&1 | grep -v "SLF4J:" | grep -v "Slf4jLogger started" | sed -e "s/\x1b\[0J//"
337            fi
338           
339            sbt clean > /dev/null
340        done
341        # set back parallelism
342        set_akka_parallelism 1
343        cd - > /dev/null
344    fi # done AKKA
345    if [ ${runUCPP} -eq ${true} ] ; then # UCPP RUN
346        cd ucpp
347        print_header 'uC++'
348        ${UCPP} ${UCPPflags} uC++Executor.cc -o a.${hostname} > /dev/null 2>&1
349        run_bench
350        rm a.${hostname}
351        cd - > /dev/null
352    fi # done UCPP
353    if [ ${runPROTO} -eq ${true} ] ; then # PROTO RUN
354        print_header 'ProtoActor'
355        cd proto/Executor
356        go build -o a.${hostname} > /dev/null 2>&1
357        run_bench
358        rm a.${hostname}
359        cd - > /dev/null
360    fi # done PROTO
361    echo ""
362fi
363
364if [ ${matrix} -eq ${true} ] ; then
365    echo "matrix"
366    pre_args="${size} ${size} ${size}"
367    post_args=""
368    cd cfa
369    for i in ${!names[@]}; do
370        print_header ${names[$i]}
371        ${cfa} ${cfa_flags} ${var_flags[$i]} matrix.cfa -o a.${hostname} > /dev/null 2>&1
372        run_bench
373        rm a.${hostname}
374    done
375    cd - > /dev/null
376    if [ ${runCAF} -eq ${true} ] ; then # CAF RUN
377        cd caf
378        print_header 'CAF'
379        g++ ${prefixCAF} CAFMatrix.cpp ${suffixCAF} -o a.${hostname} > /dev/null 2>&1
380        for p in ${bench_cores} ; do
381            sed -i "s/max-threads = .*/max-threads = ${p}/g" caf-application.conf # set CAF parallelism
382            single_run ${p}
383        done
384        rm a.${hostname}
385
386        # set back parallelism
387        sed -i "s/max-threads = .*/max-threads = 1/g" caf-application.conf
388        cd - > /dev/null
389    fi # done CAF
390    if [ ${runAKKA} -eq ${true} ] ; then # AKKA RUN
391        cd akka/Matrix
392        rm -rf project target                           # random out of memory errors without this
393        print_header 'Akka'
394        for p in ${bench_cores} ; do
395            set_akka_parallelism ${p}
396            affinity ${p}
397            repeat_command taskset -c ${taskset} sbt ${sbtflags} "run ${pre_args} ${p}" 2>&1 | grep -v "SLF4J:" | grep -v "Slf4jLogger started" | sed -e "s/\x1b\[0J//"
398            sbt clean > /dev/null
399        done
400        # set back parallelism
401        set_akka_parallelism 1
402        cd - > /dev/null
403    fi # done AKKA
404    if [ ${runUCPP} -eq ${true} ] ; then # UCPP RUN
405        cd ucpp
406        print_header 'uC++'
407        ${UCPP} ${UCPPflags} uC++Matrix.cc -o a.${hostname} > /dev/null 2>&1
408        run_bench
409        rm a.${hostname}
410        cd - > /dev/null
411    fi # done UCPP
412    if [ ${runPROTO} -eq ${true} ] ; then # PROTO RUN
413        cd proto/Matrix
414        print_header 'ProtoActor'
415        go build -o a.${hostname} > /dev/null 2>&1
416        run_bench
417        rm a.${hostname}
418        cd - > /dev/null
419    fi # done PROTO
420    echo ""
421fi
422
423if [ ${repeat} -eq ${true} ] ; then
424    echo "repeat"
425    pre_args="${messages}"
426    post_args="${n_repeats}"
427    cd cfa
428    for i in ${!names[@]}; do
429        print_header ${names[$i]}
430        ${cfa} ${cfa_flags} ${var_flags[$i]} repeat.cfa -o a.${hostname} > /dev/null 2>&1
431        run_bench
432        rm a.${hostname}
433    done
434    cd - > /dev/null
435    if [ ${runCAF} -eq ${true} ] ; then # CAF RUN
436        cd caf
437        print_header 'CAF'
438        g++ ${prefixCAF} CAFRepeat.cpp ${suffixCAF} -o a.${hostname} > /dev/null 2>&1
439        for p in ${bench_cores} ; do
440            sed -i "s/max-threads = .*/max-threads = ${p}/g" caf-application.conf # set CAF parallelism
441            single_run ${p}
442        done
443        rm a.${hostname}
444
445        # set back parallelism
446        sed -i "s/max-threads = .*/max-threads = 1/g" caf-application.conf
447        cd - > /dev/null
448    fi # done CAF
449    if [ ${runAKKA} -eq ${true} ] ; then # AKKA RUN
450        cd akka/Repeat
451        rm -rf project target                           # random out of memory errors without this
452        print_header 'Akka'
453        for p in ${bench_cores} ; do
454            set_akka_parallelism ${p}
455            affinity ${p}
456            repeat_command taskset -c ${taskset} sbt ${sbtflags} "run ${pre_args} ${p} ${post_args}" 2>&1 | grep -v "SLF4J:" | grep -v "Slf4jLogger started" | sed -e "s/\x1b\[0J//"
457            sbt clean > /dev/null
458        done
459        # set back parallelism
460        set_akka_parallelism 1
461        cd - > /dev/null
462    fi # done AKKA
463    if [ ${runUCPP} -eq ${true} ] ; then # UCPP RUN
464        cd ucpp
465        print_header 'uC++'
466        ${UCPP} ${UCPPflags} uC++Repeat.cc -o a.${hostname} > /dev/null 2>&1
467        run_bench
468        rm a.${hostname}
469        cd - > /dev/null
470    fi # done UCPP
471    if [ ${runPROTO} -eq ${true} ] ; then # PROTO RUN
472        print_header 'ProtoActor'
473        cd proto/Repeat
474        go build -o a.${hostname} > /dev/null 2>&1
475        run_bench
476        rm a.${hostname}
477        cd - > /dev/null
478    fi # done PROTO
479    echo ""
480fi
481
482
483if [ ${static} -eq ${true} ] ; then
484    echo "static"
485    preprint=''
486    cd cfa
487    for i in ${!names[@]}; do
488        echo ${names[$i]}
489        ${cfa} ${cfa_flags} ${var_flags[$i]} static.cfa -o a.${hostname} > /dev/null 2>&1
490        repeat_command taskset -c ${startcore} ./a.${hostname} ${n_static_sends}
491        rm a.${hostname}
492    done
493    cd - > /dev/null
494    if [ ${runCAF} -eq ${true} ] ; then # CAF RUN
495        cd caf
496        echo 'CAF:'
497        g++ ${prefixCAF} CAFSendStatic.cpp ${suffixCAF} -o a.${hostname} > /dev/null 2>&1
498        sed -i "s/max-threads = .*/max-threads = 1/g" caf-application.conf # set CAF parallelism
499        repeat_command taskset -c ${startcore} ./a.${hostname} ${n_static_sends_slow}
500        rm a.${hostname}
501        cd - > /dev/null
502    fi # done CAF
503    if [ ${runAKKA} -eq ${true} ] ; then # AKKA RUN
504        cd akka/SendStatic
505        rm -rf project target                           # random out of memory errors without this
506        echo 'Akka:'
507        set_akka_parallelism 1
508        taskset -c ${startcore} sbt ${sbtflags} "run ${n_static_sends} ${numtimes}" 2>&1 | grep -v "SLF4J:" | grep -v "Slf4jLogger started" | sed -e "s/\x1b\[0J//"
509        cd - > /dev/null
510    fi # done AKKA
511    if [ ${runUCPP} -eq ${true} ] ; then # UCPP RUN
512        cd ucpp
513        echo 'uC++:'
514        ${UCPP} ${UCPPflags} uC++SendStatic.cc -o a.${hostname} > /dev/null 2>&1
515        repeat_command taskset -c ${startcore} ./a.${hostname} ${n_static_sends}
516        rm a.${hostname}
517        cd - > /dev/null
518    fi # done UCPP
519    if [ ${runPROTO} -eq ${true} ] ; then # PROTO RUN
520        cd proto/SendStatic
521        echo 'ProtoActor:'
522        go build -o a.${hostname} > /dev/null 2>&1
523        repeat_command taskset -c ${startcore} ./a.${hostname} ${n_static_sends}
524        rm a.${hostname}
525        cd - > /dev/null
526    fi # done PROTO
527    echo ""
528fi
529
530if [ ${dynamic} -eq ${true} ] ; then
531    echo "dynamic"
532    cd cfa
533    for i in ${!names[@]}; do
534        echo ${names[$i]}
535        ${cfa} ${cfa_flags} ${var_flags[$i]} dynamic.cfa -o a.${hostname} > /dev/null 2>&1
536        repeat_command taskset -c ${startcore} ./a.${hostname} ${n_dynamic_sends}
537        rm a.${hostname}
538    done
539    cd - > /dev/null
540    if [ ${runCAF} -eq ${true} ] ; then # CAF RUN
541        cd caf
542        echo 'CAF:'
543        g++ ${prefixCAF} CAFSendDynamic.cpp ${suffixCAF} -o a.${hostname} > /dev/null 2>&1
544        sed -i "s/max-threads = .*/max-threads = 1/g" caf-application.conf # set CAF parallelism
545        repeat_command taskset -c ${startcore} ./a.${hostname} ${n_dynamic_sends_slow}
546        rm a.${hostname}
547        cd - > /dev/null
548    fi # done CAF
549    if [ ${runAKKA} -eq ${true} ] ; then # AKKA RUN
550        cd akka/SendDynamic
551        rm -rf project target                           # random out of memory errors without this
552        echo 'Akka:'
553        set_akka_parallelism 1
554        taskset -c ${startcore} sbt ${sbtflags} "run ${n_dynamic_sends_slow} ${numtimes}" 2>&1 | grep -v "SLF4J:" | grep -v "Slf4jLogger started" | sed -e "s/\x1b\[0J//"
555        cd - > /dev/null
556    fi # done AKKA
557    if [ ${runUCPP} -eq ${true} ] ; then # UCPP RUN
558        cd ucpp
559        echo 'uC++:'
560        ${UCPP} ${UCPPflags} uC++SendDynamic.cc -o a.${hostname} > /dev/null 2>&1
561        repeat_command taskset -c ${startcore} ./a.${hostname} ${n_dynamic_sends}
562        rm a.${hostname}
563        cd - > /dev/null
564    fi # done UCPP
565    if [ ${runPROTO} -eq ${true} ] ; then # PROTO RUN
566        cd proto/SendDynamic
567        echo 'ProtoActor:'
568        go build -o a.${hostname} > /dev/null 2>&1
569        repeat_command taskset -c ${startcore} ./a.${hostname} ${n_dynamic_sends_slow}
570        rm a.${hostname}
571        cd - > /dev/null
572    fi # done PROTO
573    echo ""
574fi
575
576
577if [ ${balance} -eq ${true} ] ; then
578    cd cfa
579    echo "balance_one"
580    for i in ${!names[@]}; do
581        echo ${names[$i]}':'
582        echo -e $column_headers
583        ${cfa} ${cfa_flags} ${var_flags[$i]} balance.cfa -o a.${hostname} > /dev/null 2>&1
584        for p in ${bench_cores} ; do 
585            affinity ${p}
586            preprint="${p}\t"
587            repeat_command taskset -c ${taskset} ./a.${hostname} 32 32 ${nOneRounds} ${p}
588        done
589        rm a.${hostname}
590    done
591    echo ""
592    echo "balance_multi"
593    for i in ${!names[@]}; do
594        echo ${names[$i]}':'
595        echo -e $column_headers
596        ${cfa} ${cfa_flags} ${var_flags[$i]} -DMULTI balance.cfa -o a.${hostname} > /dev/null 2>&1
597        for p in ${bench_cores} ; do 
598            affinity ${p}
599            preprint="${p}\t"
600            repeat_command taskset -c ${taskset} ./a.${hostname} 32 32 ${nMultiRounds} ${p}
601        done
602        rm a.${hostname}
603    done
604    echo ""
605    cd - > /dev/null
606fi
607
Note: See TracBrowser for help on using the repository browser.