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
|
#!/bin/sh
# config-scaling - reconfigure just the scaling parameter SYNC_MAX
#
# Hacked by Carl Staelin (staelin@hpl.hp.com).
# Copyright (c) 2002 Carl Staelin. GPLed software.
# $Id$
# Make sure we can find: ./cmd, df, and netstat
SCRIPTSDIR=${SCRIPTSDIR:-../../scripts}
PATH=.:${SCRIPTSDIR}:$PATH:/etc:/usr/etc:/sbin:/usr/sbin
export PATH
if [ ! -f $1 ]; then exit 1; fi
. $1
echo Using config in $1
OLD_SYNC_MAX=$SYNC_MAX
############################################################################
# Multiple copies
############################################################################
echo $L
cat<<EOF;
If you are running on an MP machine and you want to try running
multiple copies of lmbench in parallel, you can specify how many here.
Using this option will make the benchmark run 100x slower (sorry).
NOTE: WARNING! This feature is experimental and many results are
known to be incorrect or random!
EOF
AGAIN=Y
while [ $AGAIN = Y ]
do echo $ECHON "MULTIPLE COPIES [default 1] $ECHOC"
read SYNC_MAX
if [ "X$SYNC_MAX" != X ]
then case "$SYNC_MAX" in
[0-9]|[0-9][0-9]|[0-9][0-9][0-9])
AGAIN=N
;;
*) echo "Please enter a number between 1 and 999"
;;
esac
else AGAIN=N
SYNC_MAX=1
fi
done
if [ "X$LMBENCH_SCHED" = "X" ]
then
LMBENCH_SCHED=DEFAULT
AGAIN=Y
while [ "$AGAIN" = "Y" ]
do cat<<EOF
Options to control job placement
1) Allow scheduler to place jobs
2) Assign each benchmark process with any attendent child processes
to its own processor
3) Assign each benchmark process with any attendent child processes
to its own processor, except that it will be as far as possible
from other processes
4) Assign each benchmark and attendent processes to their own
processors
5) Assign each benchmark and attendent processes to their own
processors, except that they will be as far as possible from
each other and other processes
6) Custom placement: you assign each benchmark process with attendent
child processes to processors
7) Custom placement: you assign each benchmark and attendent
processes to processors
Note: some benchmarks, such as bw_pipe, create attendent child
processes for each benchmark process. For example, bw_pipe
needs a second process to send data down the pipe to be read
by the benchmark process. If you have three copies of the
benchmark process running, then you actually have six processes;
three attendent child processes sending data down the pipes and
three benchmark processes reading data and doing the measurements.
EOF
echo $ECHON "Job placement selection: $ECHOC"
read LMBENCH_SCHED
AGAIN=N
case "$LMBENCH_SCHED" in
1) LMBENCH_SCHED=DEFAULT;;
2) LMBENCH_SCHED=BALANCED;;
3) LMBENCH_SCHED=BALANCED_SPREAD;;
4) LMBENCH_SCHED=UNIQUE;;
5) LMBENCH_SCHED=UNIQUE_SPREAD;;
6) echo $ECHON "Please enter a space-separated list of CPU ids: $ECHOC"
read LMBENCH_SCHED
LMBENCH_SCHED="CUSTOM $LMBENCH_SCHED"
;;
7) echo $ECHON "Please enter a space-separated list of CPU ids: $ECHOC"
read LMBENCH_SCHED
LMBENCH_SCHED="CUSTOM_SPREAD $LMBENCH_SCHED"
;;
*) AGAIN=Y
;;
esac
done
fi
if [ `expr $SYNC_MAX \* $MB` -gt `expr $TOTAL_MEM / 2` ]
then
MB=`expr $TOTAL_MEM / $SYNC_MAX`
MB=`expr $MB / 2`
fi
C=$1
echo DISKS=\"$DISKS\" > $C
echo DISK_DESC=\"$DISK_DESC\" >> $C
echo OUTPUT=$OUTPUT >> $C
echo ENOUGH=$ENOUGH >> $C
echo FASTMEM=\"$FASTMEM\" >> $C
echo FILE=$FILE >> $C
echo FSDIR=$FSDIR >> $C
echo INFO=$INFO >> $C
echo LINE_SIZE=$LINE_SIZE >> $C
echo LOOP_O=$LOOP_O >> $C
echo MAIL=$MAIL >> $C
echo TOTAL_MEM=$TOTAL_MEM >> $C
echo MB=$MB >> $C
echo MHZ=\"$MHZ\" >> $C
echo MOTHERBOARD=\"$MOTHERBOARD\" >> $C
echo NETWORKS=\"$NETWORKS\" >> $C
echo OS=\"$OS\" >> $C
echo PROCESSORS=\"$PROCESSORS\" >> $C
echo REMOTE=\"$REMOTE\" >> $C
echo SLOWFS=\"$SLOWFS\" >> $C
echo SYNC_MAX=\"$SYNC_MAX\" >> $C
echo LMBENCH_SCHED=\"$LMBENCH_SCHED\" >> $C
echo TIMING_O=$TIMING_O >> $C
echo RSH=$RSH >> $C
echo RCP=$RCP >> $C
echo VERSION=$VERSION >> $C
echo BENCHMARK_HARDWARE=$BENCHMARK_HARDWARE >> $C
echo BENCHMARK_OS=$BENCHMARK_OS >> $C
echo BENCHMARK_SYSCALL=$BENCHMARK_SYSCALL >> $C
echo BENCHMARK_SELECT=$BENCHMARK_SELECT >> $C
echo BENCHMARK_SIG=$BENCHMARK_SIG >> $C
echo BENCHMARK_PROC=$BENCHMARK_PROC >> $C
echo BENCHMARK_CTX=$BENCHMARK_CTX >> $C
echo BENCHMARK_PAGEFAULT=$BENCHMARK_PAGEFAULT >> $C
echo BENCHMARK_FILE=$BENCHMARK_FILE >> $C
echo BENCHMARK_MMAP=$BENCHMARK_MMAP >> $C
echo BENCHMARK_PIPE=$BENCHMARK_PIPE >> $C
echo BENCHMARK_UNIX=$BENCHMARK_UNIX >> $C
echo BENCHMARK_UDP=$BENCHMARK_UDP >> $C
echo BENCHMARK_TCP=$BENCHMARK_TCP >> $C
echo BENCHMARK_CONNECT=$BENCHMARK_CONNECT >> $C
echo BENCHMARK_RPC=$BENCHMARK_RPC >> $C
echo BENCHMARK_HTTP=$BENCHMARK_HTTP >> $C
echo BENCHMARK_BCOPY=$BENCHMARK_BCOPY >> $C
echo BENCHMARK_MEM=$BENCHMARK_MEM >> $C
echo BENCHMARK_OPS=$BENCHMARK_OPS >> $C
exit 0
|
