root/trunk/tsuite/slow/run_parallel.pl

#!/usr/bin/perl

# I have written a little perl script that runs the test suite in
# parallel on suitable machines. The syntax is:
#
# run_parallel.pl cloudy.exe
#
# or
#
# run_parallel.pl cloudy.exe 16
#
# where the first parameter is the name of the Cloudy executable.
# If the parameter is completely omitted (or a "." is entered), it
# will default to "../../source/cloudy.exe". You can also supply the
# name of one of the sys_xxx directories, in which case the path will
# default to "../../source/sys_xxx/cloudy.exe". In all other cases
# cloudy.exe should  either be in your search path, or the full pathname
# should be used. The second number is the number of processors to use.
# It can be any number >= 0. The second number is optional and will
# default to the number of processosrs on your computer (this number is
# only correctly determined under Linux and Windows, it will be set to
# 1 on other systems).
#
# If the number of processors is set to 0, the script will exit after
# creating the Makefile (i.e., the test suite will not be run).
#
# NB NB - The script will first delete any remaining output from a
# previous run of the test suite by calling the script clean_tsuite.pl
# (this includes calls with the number of processors set to 0) !
#
# The script uses "gmake" (GNU make) to run the test cases. In case
# that doesn't exist, you can try replacing the two calls below with
# "make". If the version is not too old, that should work as well
# provided it supports the -j parameter for parallel execution.
#
# Peter van Hoof

if( -d "../../source/$ARGV[0]" ) {
    $exe = "../../source/$ARGV[0]/cloudy.exe";
}
else {
    $exe = "$ARGV[0]";
}

if( "$ARGV[1]" eq "" ) {
#     the following should work under Windows.
    $nproc = $ENV{'NUMBER_OF_PROCESSORS'};
    if( $nproc eq "" )
    {
#         this branch is for non-Windows
        if( -r "/proc/cpuinfo" )
        {
#             this branch is for Linux
            $nproc = 0;
            open( foo, "</proc/cpuinfo" );
            while( <foo> )
            {
                if( /^processor/ )
                {
                    ++$nproc;
                }
            }
            close( foo );
        }
        else
        {
#             we don't know how to determine the number of CPUs
            $nproc = 1;
        }
    }
}
else {
    $nproc = $ARGV[1];
}

# clean up first
if( -e "./clean_tsuite.pl" ) {
    system "./clean_tsuite.pl";
}
else {
    die "./clean_tsuite.pl not found!";
}

$all = "all: ";
$rules = "";
$i = 0;

# this funny sequence is to assure that the heavy jobs are upfront...
while( defined( $input = glob("h*.in [A-Za-gi-z]*.in") ) ) {
    $i++;
    $output = $input;
    $output2 = $input;
    $output =~ s/\.in/.out/gi;
    $output2 =~ s/\.in/.err/gi;
    $all = "$all$output ";
    if( $i%4 == 0 ) {
        $all = "$all\\\n\t";
    }
    $rules = "$rules$output: $input\n";
    $rules = "$rules\t$exe < $input > $output 2> $output2\n"
}
open( foo, ">Makefile" );
print foo $all;
print foo "\n";
print foo $rules;
close foo;

# if number of processors is 0 only create Makefile and exit
if( $nproc > 0 ) {
    print "\nNow I will run the test suite using $nproc processors\n\n";

#     this does the heavy lifting...
#     try make instead if gmake doesn't exist on your system
    system "gmake -i -j $nproc";

#     this was produced by the optimizers and is not really part of the test suite
#     its presence will fool the checkall.pl script....
    unlink "optimal.in";

    if( $nproc > 1 ) {
#         just in case func_trans_read was run before func_trans_punch was complete
        unlink "func_trans_read.out";
#         try make instead if gmake doesn't exist on your system
        system "gmake -i -j $nproc";
    }

#     now do the checking
    system "./checkall.pl";
}