In the Bourne shell it is possible to assign a variable the output (stdout) of a program. Expressions like
A=`expr $A + 1`
used to be very common. (Since many environments now use the Bash instead of the Bourne shell, this kind
of expressions is gradually disappearing).
The good news is that the scheduling server knows about the backticks. It treats them as if they were double
quotes, but it doesn’t remove them. Parameter substitution is still performed and the argument doesn’t
break at a white space.
So let’s try and see how it works. First of all we’ll need something to execute, so let’s calculate the primes less than 100. A shell script could look like this:
A=2;
primes="";
while [ "$A" -lt 100 ]; do
f=0;
for P in $primes; do
if [ `expr $A % $P -eq 0` ]; then
f=1;
break;
fi;
done;
if [ $f - eq 0 ]; then
primes="$primes $A";
echo $A;
fi;
A=`expr $A + 1`;
done
It’s easy to create a run program out of this, because no parameters from the scheduling system are used.
It’ll be sufficient to enclose the entire code within single quotes and to put a sh -c in front of it.
That doesn’t sound very challenging, so let’s make the upper bound (100) configurable by using a parameter
that is specified at submit time.
We start with a rough design of the run program that looks like this:
run program = sh -c ’
A=2;
primes="";
while [ "$A" -lt $TESTPARM ]; do
f=0;
for P in $primes; do
if [ `expr $A % $P` -eq 0 ]; then
f=1;
break;
fi;
done;
if [ $f -eq 0 ]; then
primes="$primes $A"; echo $A;
fi;
A=`expr $A + 1`;
done
,
It is basically the same as the script, except that it has been enclosed in quotes and the value 100 has been
replaced by $TESTPARM. It is evident that the run program in this form won’t print a list of primes. Since the parameter TESTPARM only occurs within single quotes, it won’t be touched by the server.
We’ll have to terminate the single quoted area, start a double quoted one and use TESTPARM, and then terminate the double quoted area and start a single quoted area again. In other words:
run program = sh -c ’
A=2;
primes="";
while [ "$A" -lt '"$TESTPARM"' ]; do
f=0;
for P in $primes; do
if [ `expr $A % $P` -eq 0 ]; then
f=1;
break;
fi;
done;
if [ $f -eq 0 ]; then
primes="$primes $A"; echo $A;
fi;
A=`expr $A + 1`;
done
,
Indeed, the output looks good:
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
Now we didn’t use the backticks in a way that the scheduling server would see them. In order to create an
example that uses backticks visible to the scheduling server, we’ll multiply TESTPARM by 4 and use the result
as an upper bound. So let’s try:
run program = sh -c "
M=`expr $TESTPARM \* 4`"’
A=2;
primes="";
while [ "$A" -lt $M ]; do
f=0;
for P in $primes; do
if [ `expr $A % $P` -eq 0 ]; then
f=1;
break;
fi;
done;
if [ $f -eq 0 ]; then
primes="$primes $A";
echo $A;
fi;
A=`expr $A + 1`;
done
’
Note the added double quotes just after the -c and which ends just after the backtick.
Part 1: Introduction and simple usage
Part 2: Advanced usage
Part 3: Backticks
Part 4: Other interpreters
Part 5: Circumventing limitations