add scripts for evaluations of my thesis

utah/scripts/jxyang/RunSafely.sh

@@ -0,0 +1,168 @@
+#!/bin/sh
+#
+# Program:  RunSafely.sh
+#
+# Synopsis: This script simply runs another program.  If the program works
+#           correctly, this script has no effect, otherwise it will do things
+#           like print a stack trace of a core dump.  It always returns
+#           "successful" so that tests will continue to be run.
+#
+#           This script funnels stdout and stderr from the program into the
+#           fourth argument specified, and outputs a <outfile>.time file which
+#           contains a timing of the program and the program's exit code.
+#          
+#           If the <exitok> parameter is 0 then this script always returns 0,
+#           regardless of the actual exit of the <program>.
+#           If the <exitok> parameter is non-zero then this script returns
+#           the exit code of the <program>. If there is an error in getting
+#           the <program>'s exit code, this script returns 99.
+#
+#           If optional parameters -r <remote host> -l <remote user> are
+#           specified, it execute the program remotely using rsh.
+#
+# Syntax: 
+#
+#   RunSafely.sh [-r <rhost>] [-l <ruser>]
+#                <timeout> <exitok> <infile> <outfile> <program> <args...>
+#
+#   where:
+#     <rhost>   is the remote host to execute the program
+#     <ruser>   is the username on the remote host
+#     <timeout> is the maximum number of seconds to let the <program> run
+#     <exitok>  is 1 if the program must exit with 0 return code
+#     <infile>  is a file from which standard input is directed
+#     <outfile> is a file to which standard output and error are directed
+#     <program> is the path to the program to run
+#     <args...> are the arguments to pass to the program.
+#
+if [ $# -lt 4 ]; then
+  echo "./RunSafely.sh <timeout> <exitok> <infile> <outfile> <program> <args...>"
+  exit 1
+fi
+
+DIR=${0%%`basename $0`}
+
+RHOST=
+RUSER=`id -un`
+FLAG=$1
+if [ $1 = "-r" ]; then
+  RHOST=$2
+  shift 2
+fi
+if [ $1 = "-l" ]; then
+  RUSER=$2
+  shift 2
+fi
+
+ULIMIT=$1
+EXITOK=$2
+INFILE=$3
+OUTFILE=$4
+PROGRAM=$5
+shift 5
+SYSTEM=`uname -s`
+
+ULIMITCMD=""
+case $SYSTEM in
+  CYGWIN*) 
+    ;;
+  Darwin*)
+    # Disable core file emission, the script doesn't find it anyway because it is put 
+    # into /cores.
+    ULIMITCMD="$ULIMITCMD ulimit -c 0;"
+    ULIMITCMD="$ULIMITCMD ulimit -t $ULIMIT;"
+    # To prevent infinite loops which fill up the disk, specify a limit on size of
+    # files being output by the tests. 10 MB should be enough for anybody. ;)
+    ULIMITCMD="$ULIMITCMD ulimit -f 10485760;"
+    ;;
+  *)
+    ULIMITCMD="$ULIMITCMD ulimit -t $ULIMIT;"
+    ULIMITCMD="$ULIMITCMD ulimit -c unlimited;"
+    # To prevent infinite loops which fill up the disk, specify a limit on size of
+    # files being output by the tests. 10 MB should be enough for anybody. ;)
+    ULIMITCMD="$ULIMITCMD ulimit -f 10485760;"
+
+    ULIMITCMD="$ULIMITCMD ulimit -m 2000000 -v 2000000;"
+    #ULIMITCMD="$ULIMITCMD ulimit -m 2000000 -v 2000000;"
+esac
+rm -f core core.*
+
+#
+# Run the command, timing its execution.
+# The standard output and standard error of $PROGRAM should go in $OUTFILE,
+# and the standard error of time should go in $OUTFILE.time. Note that the 
+# return code of the program is appended to the $OUTFILE on an "Exit Val ="
+# line.
+#
+# To get the time program and the specified program different output filenames,
+# we tell time to launch a shell which in turn executes $PROGRAM with the
+# necessary I/O redirection.
+#
+PWD=`pwd`
+COMMAND="$PROGRAM $*"
+if [ "$SYSTEM" = "Darwin" ]; then
+  COMMAND="${DIR}TimedExec.sh $ULIMIT $PWD $COMMAND"
+fi
+
+if [ "x$RHOST" = x ] ; then
+  ( sh -c "$ULIMITCMD time -p $COMMAND >$OUTFILE 2>&1 < $INFILE; echo exit \$?" ) 2>&1 \
+    | awk -- '\
+BEGIN     { cpu = 0.0; }
+/^user/   { cpu += $2; print; }
+/^sys/    { cpu += $2; print; }
+!/^user/ && !/^sys/  { print; }
+END       { printf("cpu time= %f\n", cpu); }' > ${OUTFILE}.time
+else
+  rm -f "$PWD/${PROGRAM}.command"
+  rm -f "$PWD/${PROGRAM}.remote"
+  rm -f "$PWD/${PROGRAM}.remote.time"
+  echo "$ULIMITCMD cd $PWD; (time -p ($COMMAND > $OUTFILE.remote 2>&1 < $INFILE;); echo exit $?) > $OUTFILE.remote.time 2>&1" > "$PWD/${PROGRAM}.command"
+  chmod +x "$PWD/${PROGRAM}.command"
+
+  ( rsh -l $RUSER $RHOST "ls $PWD/${PROGRAM}.command" ) > /dev/null 2>&1
+  ( rsh -l $RUSER $RHOST "$PWD/${PROGRAM}.command" )
+  cat $OUTFILE.remote.time | awk -- '\
+BEGIN     { cpu = 0.0; }
+/^user/   { cpu += $2; print; }
+/^sys/    { cpu += $2; print; }
+!/^user/ && !/^sys/  { print; }
+END       { printf("program %f\n", cpu); }' > ${OUTFILE}.time
+sleep 1
+cp -f $OUTFILE.remote $OUTFILE
+rm -f $OUTFILE.remote
+rm -f $OUTFILE.remote.time
+fi
+
+exitval=`grep '^exit ' $OUTFILE.time | sed -e 's/^exit //'`
+if [ -z "$exitval" ] ; then
+  exitval=99
+  echo "TEST $PROGRAM failed:  CAN'T GET EXIT CODE!"
+fi
+echo "exit $exitval" >> $OUTFILE
+
+if [ "$EXITOK" -ne 0 ] ; then
+  if test "$exitval" -ne 0 ; then
+    echo "test $PROGRAM failed:  EXIT != 0"
+  fi
+else
+  exitval=0
+fi
+
+if ls | egrep "^core" > /dev/null
+then
+    # If we are on a sun4u machine (UltraSparc), then the code we're generating
+    # is 64 bit code.  In that case, use gdb-64 instead of gdb.
+    myarch=`uname -m`
+    if [ "$myarch" = "sun4u" ]
+    then
+	GDB="gdb-64"
+    else
+	GDB=gdb
+    fi
+
+    corefile=`ls core* | head -n 1`
+    echo "where 100" > StackTrace.$$
+    $GDB -q -batch --command=StackTrace.$$ --core=$corefile $PROGRAM < /dev/null
+    rm -f StackTrace.$$ $corefile
+fi
+exit "$exitval"

utah/scripts/jxyang/compilers.txt

@@ -0,0 +1,14 @@
+$COMPILER_HOME/gcc-320/bin/gcc-320
+$COMPILER_HOME/gcc-330/bin/gcc-330
+$COMPILER_HOME/gcc-340/bin/gcc-340
+$COMPILER_HOME/gcc-400/bin/gcc-400
+$COMPILER_HOME/gcc-410/bin/gcc-410
+$COMPILER_HOME/gcc-420/bin/gcc-420
+$COMPILER_HOME/gcc-430/bin/gcc-430
+$COMPILER_HOME/gcc-440/bin/gcc-440
+$COMPILER_HOME/gcc-450/bin/gcc-450
+#$COMPILER_HOME/llvm-gcc-25/bin/llvm-gcc-25
+$COMPILER_HOME/clang-26/bin/clang
+$COMPILER_HOME/clang-27/bin/clang
+$COMPILER_HOME/clang-28/bin/clang
+$COMPILER_HOME/clang-29/bin/clang

utah/scripts/jxyang/parallel_test.pl

@@ -0,0 +1,49 @@
+#!/usr/bin/perl -w
+ use strict;
+use warnings;
+#use Sys::CPU;
+
+sub usage () {
+    die "usage: parallel_test.pl <config-file> <csmith-option>\n";
+}
+
+my $CPUS = 2; #Sys::CPU::cpu_count();
+
+if (scalar (@ARGV) != 2 || !(-e $ARGV[0]) ) {
+    usage();
+}
+print "looks like we have $CPUS cpus\n";
+
+my $CONFIG_FILE = $ARGV[0];
+my $CSMITH_OPTION = $ARGV[1];
+my @ALT_OPTIONS = ();
+
+if ($CSMITH_OPTION =~ /--no-(.*)/) {
+    push @ALT_OPTIONS, $CSMITH_OPTION;
+    push @ALT_OPTIONS, "--$1";
+}
+# todo: for options like "max-block-depth 8", try to make
+# a list of alternative options including "max-block-depth 2",
+# "max-block-depth 4" etc if there is enough CPUs
+
+my $cpu_per_option = $CPUS / @ALT_OPTIONS;
+print "using $cpu_per_option CPU each for options: ";
+print @ALT_OPTIONS;
+print "\n";
+
+for (my $i=0; $i<@ALT_OPTIONS; $i++) {
+    $ALT_OPTIONS[$i] =~ /--(.*)/;
+    my $opt = $1;
+    $opt =~ s/ //g;
+    for (my $j=0; $j<$cpu_per_option; $j++) {
+	my $cpuid = $i * $cpu_per_option + $j;
+	my $dir = "work$cpuid";
+	system "rm -rf $dir";
+	system "mkdir $dir";
+	chdir $dir;
+	my $cmd = "nohup ../test.pl 0  ../$CONFIG_FILE $ALT_OPTIONS[$i] > ${opt}_output.txt 2>&1 &";
+	print "running $cmd on CPU $cpuid\n";
+	system $cmd;
+	chdir "..";
+    }
+}