Reorganisation of the source tree

Most of the other users of the fptools build system have migrated to
Cabal, and with the move to darcs we can now flatten the source tree
without losing history, so here goes.

The main change is that the ghc/ subdir is gone, and most of what it
contained is now at the top level.  The build system now makes no
pretense at being multi-project, it is just the GHC build system.

No doubt this will break many things, and there will be a period of
instability while we fix the dependencies.  A straightforward build
should work, but I haven't yet fixed binary/source distributions.
Changes to the Building Guide will follow, too.

1 files changed, 2114 insertions, 0 deletions

diff --git a/utils/parallel/gran-extr.pl b/utils/parallel/gran-extr.pl
new file mode 100644
index 0000000000..509da499d6
--- /dev/null
+++ b/utils/parallel/gran-extr.pl
@@ -0,0 +1,2114 @@
+#!/usr/local/bin/perl
+##############################################################################
+# Last modified: Time-stamp: <Sat Oct 28 1995 23:49:48 Stardate: [-31]6509.75 hwloidl>
+#                                                      (C) Hans Wolfgang Loidl
+#
+# Usage: gran-extr [options] [<sim-file>]
+#
+# Takes a file <sim-file> generated by running the GrAnSim simulator and 
+# produces data files that should be used as input for gnuplot.
+# This script produces figures for:
+#   runtime of tasks
+#   percentage of communication
+#   heap allocation
+#   number of created sparks
+#   cumulative no. of tasks over runtime
+# Furthermore, it computes the correlation between runtime and heap allocation.
+#
+# Options:
+#  -g <file>  ... filename of granularity file to be produced; should end with
+#                .dat; -global and -local will be automatically inserted for 
+#                other versions. 
+#  -c <file> ... filename of communication file to be produced; should end with
+#                .dat; -global and -local will be automatically inserted for 
+#                other versions. 
+#  -s <file> ... filename of sparked-threads file to be produced; should end w/
+#                .dat; -global and -local will be automatically inserted for 
+#                other versions. 
+#  -a <file> ... filename of heap alloc. file to be produced; should end with
+#                .dat;
+#  -f <file> ... filename of communication time file to be produced; 
+#                should end with .dat;
+#  -p <file> ... filename of GNUPLOT file that is prouced and executed.
+#  -G <LIST> ... provide a list of boundaries for the Intervals used in the 
+#                granularity figure; must be a Perl list e.g. (10, 20, 50)
+#                this is interpreted as being open to left and right.
+#  -C <LIST> ... provide a list of boundaries for the Intervals used in the 
+#                communication figure; must be a Perl list e.g. (10, 20, 50)
+#                this is interpreted as being closed to left and right.
+#  -S <LIST> ... provide a list of boundaries for the Intervals used in the 
+#                sparked-threads figure; must be a Perl list e.g. (10, 20, 50)
+#                this is interpreted as being closed to left and right.
+#  -A <LIST> ... provide a list of boundaries for the Intervals used in the 
+#                heap alloc figure; must be a Perl list e.g. (10, 20, 50)
+#                this is interpreted as being closed to left and right.
+#  -F <LIST> ... provide a list of boundaries for the Intervals used in the 
+#                comm. time figure; must be a Perl list e.g. (10, 20, 50)
+#                this is interpreted as being open to left and right.
+#  -l <int>  ... left margin in the produced figures.
+#  -r <int>  ... right margin in the produced figures.
+#  -x <int>  ... enlargement of figure along x-axis.
+#  -y <int>  ... enlargement of figure along y-axis.
+#  -e <int>  ... thickness of impulses in figure.
+#  -i <rat>  ... set the gray level of the impulses to <rat>; <rat> must be
+#                between 0 and 1 with 0 meaning black. 
+#  -k <n>    ... number of klusters (oops, clusters, I mean ;)
+#  -P        ... print percentage of threads rather than absolute number of 
+#                threads on the y axis
+#  -t <file> ... use template <file> for interval settings and file names
+#                Syntax of a line in the template file:
+#                 <flag>: <arg>
+#  -T        ... use smart xtics rather than GNUPLOT default x-axis naming.
+#  -L        ... use logarithmic scale for all figures.
+#  -W        ... print warnings
+#  -m        ... generate monchrome output
+#  -h        ... help; print this text.
+#  -v        ... verbose mode.
+#
+##############################################################################
+
+# ----------------------------------------------------------------------------
+# Command line processing and initialization
+# ----------------------------------------------------------------------------
+
+require "getopts.pl";
+
+&Getopts('hvWTPDmt:L:g:f:c:s:a:p:G:F:C:S:A:l:r:x:y:e:i:k:');  
+
+do process_options();
+
+$OPEN_INT = 1;
+$CLOSED_INT = 0;
+
+if ( $opt_v ) {
+    do print_verbose_message ();
+}
+
+# ----------------------------------------------------------------------------
+# The real thing
+# ----------------------------------------------------------------------------
+
+open(INPUT,"<$input") || die "Couldn't open input file $input";
+
+do skip_header();
+
+$tot_total_rt = 0;
+$tot_rt = 0;
+$tot_bt = 0;
+$tot_ft = 0;
+$tot_it = 0;
+$gum_style_gr = 0;
+
+$line_no = 0;
+while (<INPUT>) {
+    next                     if /^--/;     # Comment lines start with --
+    next		     if /^\s*$/;   # Skip empty lines
+    $line_no++;
+    @fields = split(/[:,]/,$_);
+    $has_end = 0;
+
+    foreach $elem (@fields) {
+      foo : {
+        $pe = $1, $end = $2 , last foo   if $elem =~ /^\s*PE\s+(\d+)\s+\[(\d+)\].*$/;
+        $tn = $1, $has_end = 1  , last foo   if $elem =~ /^\s*END\s+(\w+).*$/;
+	# $tn = $1	, last foo   if $elem =~ /^\s*TN\s+(\w+).*$/;
+	$sn = $1	, last foo   if $elem =~ /^\s*SN\s+(\d+).*$/;
+        $start = $1     , last foo   if $elem =~ /^\s*ST\s+(\d+).*$/;
+        $is_global = $1 , last foo   if $elem =~ /^\s*EXP\s+(T|F).*$/;
+        $bbs = $1       , last foo   if $elem =~ /^\s*BB\s+(\d+).*$/;
+        $ha = $1        , last foo   if $elem =~ /^\s*HA\s+(\d+).*$/;
+        $rt = $1        , last foo   if $elem =~ /^\s*RT\s+(\d+).*$/;
+        $bt = $1, $bc = $2 , last foo if $elem =~ /^\s*BT\s+(\d+)\s+\((\d+)\).*$/;
+        $ft = $1, $fc = $2 , last foo if $elem =~ /^\s*FT\s+(\d+)\s+\((\d+)\).*$/;
+        $lsp = $1        , last foo   if $elem =~ /^\s*LS\s+(\d+).*$/;
+        $gsp = $1        , last foo   if $elem =~ /^\s*GS\s+(\d+).*$/;
+        $my = $1        , last foo   if $elem =~ /^\s*MY\s+(T|F).*$/;
+      }
+    }
+
+    next unless $has_end == 1;
+
+    $total_rt = $end - $start;
+    $ready_time = $total_rt - $rt - $bt - $ft;
+
+    # ------------------------------------------------------------------------
+    # Accumulate runtime, block time, fetch time and ready time over all threads
+    # ------------------------------------------------------------------------
+
+    $tot_total_rt += $total_rt;
+    $tot_rt += $rt;
+    $tot_bt += $bt;
+    $tot_ft += $ft;
+    $tot_it += $ready_time;
+
+    # ------------------------------------------------------------------------
+    # Gather statistics about `load' on the PEs
+    # ------------------------------------------------------------------------
+
+    print "WARNING: ready time of thread is <0: $ready_time\n" if $pedantic && ($ready_time <0);
+    $pe_load[$pe] += $ready_time;
+
+    if ( $opt_D ) {
+	print "Adding $ready_time to the load time of PE no. $pe yielding $pe_load[$pe]\n";
+    }
+
+    # ------------------------------------------------------------------------
+    # Gather statistics about the size of a spark site
+    # ------------------------------------------------------------------------
+
+    $site_size[$sn] += $rt;
+
+    if ( $opt_D ) {
+	print "Adding $rt to the size of site $sn yielding $site_size[$sn]\n";
+    }
+
+    # ------------------------------------------------------------------------
+    # Gather statistics about pure exec time
+    # ------------------------------------------------------------------------
+
+    push(@all_rts,$rt);
+    $sum_rt += $rt;
+    $max_rt = $rt  if $rt > $max_rt;
+
+    $index = do get_index_open_int($rt,@exec_times);
+    $exec_class[$index]++;
+
+    if ( $is_global eq 'T' ) {
+	$exec_global_class[$index]++;
+    } else {
+	$exec_local_class[$index]++;
+    }
+
+    # ------------------------------------------------------------------------
+    # Gather statistics about communication time (absolute time rather than %)
+    # ------------------------------------------------------------------------
+    
+    # Note: Communicatin time is fetch time
+
+    push(@all_fts,$ft);
+    $sum_ft += $ft;
+    $max_ft = $ft  if $ft > $max_ft;
+
+    $index = do get_index_open_int($ft,@fetch_times);
+    $fetch_class[$index]++;
+
+    if ( $is_global eq 'T' ) {
+	$fetch_global_class[$index]++;
+    } else {
+	$fetch_local_class[$index]++;
+    }
+
+    # ------------------------------------------------------------------------
+    # Gather statistics about communication percentage
+    # ------------------------------------------------------------------------
+
+    $comm_perc = ( $total_rt == 0 ? 100 : (100 * $ft)/$total_rt );
+
+    push(@all_comm_percs,$comm_perc); 
+    $sum_comm_perc += $comm_perc;
+    $max_comm_perc = $comm_perc  if $comm_perc > $max_comm_perc;
+
+    $index = do get_index_closed_int( $comm_perc, @comm_percs );
+    if ( $index != -1 ) {
+      $comm_class[$index]++;
+    } else {
+      print "WARNING: value " . $comm_perc . " not in range (t_rt=$total_rt; ft=$ft)\n" if $pedantic;
+      $outside++;
+    }
+
+    if ( $is_global eq 'T' ) {
+      if ( $index != -1 ) {
+	$comm_global_class[$index]++;
+      } else {
+        $outside_global++;
+      }
+    } else {
+      if ( $index != -1 ) {
+	$comm_local_class[$index]++;
+      } else {
+        $outside_local++;
+      }
+    }
+
+    # ------------------------------------------------------------------------
+    # Gather statistics about locally sparked threads
+    # ------------------------------------------------------------------------
+
+    push(@all_local_sparks,$lsp);
+    $sum_local_sp += $lsp;
+    $max_local_sp = $lsp  if $lsp > $max_local_sp;
+
+    $index = do get_index_open_int($lsp,@sparks);
+    $spark_local_class[$index]++;
+
+    # ------------------------------------------------------------------------
+    # Gather statistics about globally sparked threads
+    # ------------------------------------------------------------------------
+
+    push(@all_global_sparks,$gsp);
+    $sum_global_sp += $gsp;
+    $max_global_sp = $gsp  if $gsp > $max_global_sp;
+
+    $index = do get_index_open_int($gsp,@sparks);
+    $spark_global_class[$index]++;
+
+    # ------------------------------------------------------------------------
+    # Add the above two entries to get the total number of sparks
+    # ------------------------------------------------------------------------
+
+    $sp = $lsp + $gsp;
+
+    push(@all_sparks,$sp);
+    $sum_sp += $sp;
+    $max_sp = $sp  if $sp > $max_sp;
+
+    $index = do get_index_open_int($sp,@sparks);
+    $spark_class[$index]++;
+
+    # ------------------------------------------------------------------------
+    # Gather statistics about heap allocations
+    # ------------------------------------------------------------------------
+
+    push(@all_has,$ha);
+    $sum_ha += $ha;
+    $max_ha = $ha  if $ha > $max_ha;
+
+    $index = do get_index_open_int($ha,@has);
+    $ha_class[$index]++;
+
+    # do print_line($start,$end,$is_global,$bbs,$ha,$rt,$bt,$bc,$ft,$fc,$my);
+}
+
+print STDERR "You don't want to engage me for a file with just $line_no lines, do you?(N)\n" , exit (-1)         if $line_no <= 1;
+
+# ----------------------------------------------------------------------------
+
+do write_pie_chart();
+
+# ----------------------------------------------------------------------------
+# Statistics
+# ----------------------------------------------------------------------------
+
+if ( $opt_D ) {
+  print "Lengths:\n" .
+        "   all_rts: $#all_rts;\n" .
+        "   all_comm_percs: $#all_comm_percs;\n" .
+        "   all_sparks: $#all_sparks; \n" . 
+        "   all_local_sparks: $#all_local_sparks; \n" .
+        "   all_global_sparks: $#all_global_sparks; \n" . 
+        "   all_has: $#all_has\n" .
+	"   all_fts: $#all_fts;\n";
+
+
+  print "No of elems in all_rts: $#all_rts with sum $sum_rt\n";
+  print "No of elems in all_comm_percs: $#all_rts with sum $sum_comm_perc\n";
+  print "No of elems in all_has: $#all_has with sum $sum_ha\n";
+  print "No of elems in all_fts: $#all_fts with sum $sum_ft\n";
+
+}
+
+do do_statistics($line_no);
+
+# Just for debugging
+# ..................
+
+if ( $opt_D ) {
+  open(FILE,">LOG") || die "Couldn't open file LOG\n";
+  printf FILE "All total runtimes (\@all_rts:)\n";
+  printf FILE "[";
+  printf FILE join(", ",@all_rts);
+  printf FILE "]\n";
+  printf FILE "  Mean, std. dev: $mean_rt, $std_dev_rt\n";
+  printf FILE 70 x "-" . "\n";
+  printf FILE "All  communication times (\@all_fts:)\n";
+  printf FILE "[";
+  printf FILE join(", ",@all_fts);
+  printf FILE "]\n";
+  printf FILE "  Mean, std. dev: $mean_ft, $std_dev_ft\n";
+  printf FILE 70 x "-" . "\n";
+  printf FILE "All communication percentages (\@all_comm_percs:)\n";
+  printf FILE "[";
+  printf FILE join(", ",@all_comm_percs);
+  printf FILE "]\n";
+  printf FILE "  Mean, std. dev: $mean_comm_perc,$std_dev_comm_perc\n";
+  printf FILE 70 x "-" . "\n";
+  printf FILE "All  sparks  (\@all_sparks:)\n";
+  printf FILE "[";
+  printf FILE join(", ",@all_sparks);
+  printf FILE "]\n";
+  printf FILE "  Mean, std. dev: $mean_spark,$std_dev_spark\n";
+  printf FILE 70 x "-" . "\n";
+  printf FILE "All local sparks  (\@all_local_sparks:)\n";
+  printf FILE "[";
+  printf FILE join(", ",@all_local_sparks);
+  printf FILE "]\n";
+  printf FILE "  Mean, std. dev: $mean_local_spark,$std_dev_local_spark\n";
+  printf FILE 70 x "-" . "\n";
+  printf FILE "All global sparks  (\@all_global_sparks:)\n";
+  printf FILE "[";
+  printf FILE join(", ",@all_global_sparks);
+  printf FILE "]\n";
+  printf FILE "  Mean, std. dev: $mean_global_spark,$std_dev_global_spark\n";
+  printf FILE 70 x "-" . "\n";
+  printf FILE "All local sparks  (\@all_has:)\n";
+  printf FILE "[";
+  printf FILE join(", ",@all_has);
+  printf FILE "]\n";
+  printf FILE "  Mean, std. dev: $mean_ha,$std_dev_ha\n";
+  printf FILE 70 x "-" . "\n";
+
+
+  printf FILE ("CORR of runtime and heap alloc:  %f\n",$c_exec_ha);
+  printf FILE ("CORR of runtime and no. of sparks:  %f\n",$c_exec_sp);
+  printf FILE ("CORR of heap alloc and no. sparks:  %f\n",$c_ha_sp);
+  printf FILE ("CORR of runtime and local sparks:  %f\n",$c_exec_lsp);
+  printf FILE ("CORR of runtime and global sparks:  %f\n",$c_exec_gsp);
+  printf FILE ("CORR of heap alloc and local sparks:  %f\n",$c_ha_lsp);
+  printf FILE ("CORR of heap alloc and global sparks:  %f\n",$c_ha_gsp);
+  printf FILE ("CORR of runtime and communication time:  %f\n",$c_exec_ft);
+  printf FILE ("CORR of heap alloc and communication time:  %f\n",$c_ha_ft);
+  printf FILE ("CORR of local sparks and communication time:  %f\n",$c_lsp_ft);
+  printf FILE ("CORR of global_sparks and communication time:  %f\n",$c_gsp_ft);
+  close FILE;
+}
+
+if ( $opt_P ) {
+  do percentify($line_no,*exec_class);
+  do percentify($line_no,*exec_global_class);
+  do percentify($line_no,*exec_local_class);
+  do percentify($line_no,*comm_class);
+  do percentify($line_no,*comm_global_class);
+  do percentify($line_no,*comm_local_class);
+  do percentify($line_no,*spark_local_class);
+  do percentify($line_no,*spark_global_class);
+  do percentify($line_no,*ha_class);
+  do percentify($line_no,*ft_class);
+}
+
+# Produce cumulative RT graph and other (more or less) nice graphs
+# ................................................................
+
+do sort_and_cum();
+
+# ----------------------------------------------------------------------------
+
+open(IV,">INTERVALS") || die "Couldn't open file INTERVALS\n";
+do write_interval(IV, 'G', &guess_interval(@all_rts));
+do write_interval(IV, 'C', 0, int($mean_comm_perc), 
+                           int($mean_comm_perc+$std_dev_comm_perc), 50);
+do write_interval(IV, 'S', &guess_interval(@all_sparks));
+do write_interval(IV, 'A', &guess_interval(@all_has));
+close(IV);
+
+# ----------------------------------------------------------------------------
+# Print results to STDOUT (mainly for testing)
+# ----------------------------------------------------------------------------
+
+if ( $opt_v ) {
+    do print_general_info();
+}
+
+# ----------------------------------------------------------------------------
+# Write results to data files to be processed by GNUPLOT
+# ----------------------------------------------------------------------------
+
+do write_data($gran_file_name, $OPEN_INT, $logscale{'g'}, $#exec_times+1,
+              @exec_times, @exec_class);
+
+do write_data($gran_global_file_name, $OPEN_INT, $logscale{'g'}, $#exec_times+1,
+              @exec_times, @exec_global_class);
+
+do write_data($gran_local_file_name, $OPEN_INT, $logscale{'g'}, $#exec_times+1,
+              @exec_times, @exec_local_class);
+
+do write_data($comm_file_name, $CLOSED_INT, $logscale{'c'}, $#comm_percs+1,
+              @comm_percs, @comm_class);
+
+do write_data($comm_global_file_name, $CLOSED_INT, $logscale{'c'}, $#comm_percs+1,
+              @comm_percs, @comm_global_class);
+
+do write_data($comm_local_file_name, $CLOSED_INT, $logscale{'c'}, $#comm_percs+1,
+              @comm_percs, @comm_local_class);
+
+do write_data($spark_file_name, $OPEN_INT, $logscale{'s'}, $#sparks+1,
+              @sparks, @spark_class);
+
+do write_data($spark_local_file_name, $OPEN_INT, $logscale{'s'}, $#sparks+1,
+              @sparks, @spark_local_class);
+
+do write_data($spark_global_file_name, $OPEN_INT, $logscale{'s'}, $#sparks+1,
+              @sparks, @spark_global_class);
+
+do write_data($ha_file_name, $OPEN_INT, $logscale{'a'}, $#has+1,
+              @has, @ha_class);
+
+do write_data($ft_file_name, $OPEN_INT, $logscale{'g'}, $#fetch_times+1,
+              @fetch_times, @fetch_class);
+
+
+# ----------------------------------------------------------------------------
+# Run GNUPLOT over the data files and create figures
+# ----------------------------------------------------------------------------
+
+do gnu_plotify($gp_file_name); 
+
+print "Script finished successfully!\n";
+
+exit 0;
+
+# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+# ----------------------------------------------------------------------------
+# Basic Operations on the intervals
+# ----------------------------------------------------------------------------
+
+sub get_index_open_int {
+    local ($value,@list) = @_;
+    local ($index,$right);
+
+    # print "get_index: searching for index of" . $value;
+    # print " in " . join(':',@list);
+
+      $index = 0;
+      $right = $list[$index];
+      while ( ($value >= $right) && ($index < $#list) ) {
+  	$index++;
+        $right = $list[$index];
+      }
+    
+      return ( ($index == $#list) && ($value > $right) ) ? $index+1 : $index;
+}
+
+# ----------------------------------------------------------------------------
+
+sub get_index_closed_int {
+    local ($value,@list) = @_;
+    local ($index,$right);
+
+      if ( ($value < $list[0]) || ($value > $list[$#list]) ) {
+	  return ( -1 );
+      }
+
+      $index = 0;
+      $left = $list[$index];
+      while ( ($left <= $value) && ($index < $#list) ) {
+  	$index++;
+        $left = $list[$index];
+      }
+      return ( $index-1 );
+}
+
+# ----------------------------------------------------------------------------
+# Write operations
+# ----------------------------------------------------------------------------
+
+sub write_data {
+    local ($file_name, $open_int, $logaxes, $n, @rest) = @_;
+    local (@times) = splice(@rest,0,$n);
+    local (@class) = @rest;
+
+    open(GRAN,">$file_name") || die "Couldn't open file $file_name for output";
+
+    if ( $open_int == $OPEN_INT ) {
+
+      for ($i=0, 
+           $left = ( index($logaxes,"x") != -1 ? int($times[0]/2) : 0 ), 
+           $right = 0; 
+           $i < $n; 
+           $i++, $left = $right) {
+         $right = $times[$i];
+         print GRAN int(($left+$right)/2) . "  " . 
+                    ($class[$i] eq "" ? "0" : $class[$i]) . "\n"; 
+      }
+      print GRAN $times[$n-1]+(($times[$n-1]-$times[$n-2])/2) . "  " . 
+                 ($class[$n] eq "" ? "0" : $class[$n]) . "\n";
+
+     } else {
+
+      print GRAN ( (index($logaxes,"x") != -1) && ($times[0] == 0 ? int($times[1]/2) : ($times[$1] + $times[0])/2 ) .  "  " . $class[0] . "\n");
+      for ($i=1; $i < $n-2; $i++) {
+         $left = $times[$i];
+         $right = $times[$i+1];
+         print(GRAN ($left+$right)/2 . "  " . 
+                    ($class[$i] eq "" ? "0" : $class[$i]) . "\n"); 
+      }
+      print GRAN ($times[$n-1]+$times[$n-2])/2 . "  " . $class[$n-2]  if $n >= 2;
+    }
+
+    close(GRAN);
+}
+
+# ----------------------------------------------------------------------------
+
+sub write_array {
+    local ($file_name,$n,@list) = @_;
+
+    open(FILE,">$file_name") || die "$file_name: $!";
+    for ($i=0; $i<=$#list; $i++) {
+	print FILE $i . "  " .  ( $list[$i] eq "" ? "0" : $list[$i] ) . "\n";
+    }
+
+    if ( $opt_D ) {
+	print "write_array: (" . join(", ",1 .. $#list) . ")\n for file $file_name returns: \n (0, $#list, &list_max(@list)\n";
+    } 
+
+    return ( (0, $#list, &list_max(@list), 
+              "(" . join(", ",1 .. $#list) . ")\n") );
+}
+
+# ----------------------------------------------------------------------------
+
+sub write_cumulative_data {
+    local ($file_name1,$file_name2,@list) = @_;
+    local (@ns, @elems, @xtics, $i, $j, $n, $elem, $max_clust, $xtics_str,
+           $xstart, $xend, $file_name0);
+    local ($CLUST_SZ) = $no_of_clusters;
+
+    @ns = ();
+    @elems = ();
+    $file_name0 = $file_name1;
+    $file_name0 =~ s/\.dat$//;
+    $file_name0 .= "0.dat";
+    open(CUMM,">$file_name1") || die "Couldn't open file $file_name1 (error $!)\n";
+    open(CUMM0,">$file_name0") || die "Couldn't open file $file_name0 (error $!)\n";
+
+    print CUMM "1  0\n" unless $list[0] <= 1;
+    print CUMM0 "1  0\n" unless $list[0] <= 1;;
+
+    for ($i=0; $i <= $#list; $i++) {
+	$elem = $list[$i];
+        print CUMM ($elem) . "  " . int( (100 * ($i)) / ($#list+1) ) . "\n"  unless $elem == 0;
+        print CUMM0 ($elem) . "  " . $i . "\n" unless $elem == 0;;
+	for ($n=1; $i < $#list && $list[$i+1] == $elem; $i++, $n++) { }
+
+        print CUMM "$elem  " . int( (100 * ($i+1)) / ($#list+1) ) . "\n";
+        print CUMM0 "$elem  " . ($i+1) . "\n";
+	
+
+        if ( $opt_D ) {
+	    print "\n--> Insert: n:  $n (elem $elem) in the above lists yields: \n  ";
+        }
+
+        # inlined version of do insert_elem($elem, $n, $#exs, @exs, @ns)
+	for ($j=0; $j<=$#ns && $ns[$j]>$n; $j++) { }
+	if ( $j > $#ns ) {
+	    push(@ns,$n);
+	    push(@elems,$elem);
+	} else {
+	    splice(@ns,$j,0,$n);           # insert $n at pos $j and move the
+	    splice(@elems,$j,0,$elem);     # rest of the array to the right
+	}
+
+        if ( $opt_D ) {
+	    print "[" . join(", ",@ns) . "]" . "\n and \n" . 
+		  "[" . join(", ",@elems) . "]\n";
+        }
+      
+    }
+
+    close(CUMM);
+    close(CUMM0);
+
+    open(CLUSTERS_ALL,">" . (&dirname($file_name2)) . "CL-" .
+	              &basename($file_name2)) 
+        || die "Couldn't open file CL-$file_name2 (error $!)\n";
+    for ($i=0; $i <= $#ns; $i++) {
+	print CLUSTERS_ALL "$elems[$i]  $ns[$i]\n";
+    }
+    close(CLUSTERS_ALL);
+
+    # Interesting are only the first parts of the list (clusters!)
+    splice(@elems, $CLUST_SZ);
+    splice(@ns, $CLUST_SZ);
+
+    open(CLUSTERS,">$file_name2") || die "Couldn't open file $file_name2 (error $!)\n";
+
+    $xstart = &list_min(@elems);
+    $xend =   &list_max(@elems);
+    $step = ($xend - $xstart) / ( $CLUST_SZ == 1 ? 1 : ($CLUST_SZ-1));
+
+    @xtics = ();
+    for ($i=0, $x=$xstart; $i <= $#ns; $i++, $x+=$step) {
+	print CLUSTERS "$x  $ns[$i]\n";
+	push(@xtics,"\"$elems[$i]\" $x");
+    }
+    close(CLUSTERS);
+
+    $max_clust = $ns[0];
+    $xtics_str = "(" . join(", ",@xtics) . ")\n";
+
+    return ( ($xstart, $xend, $max_clust, $xtics_str) );
+}
+
+# ----------------------------------------------------------------------------
+
+sub get_xtics {
+    local ($open_int, @list) = @_;
+
+    local ($str);
+
+    if ( $open_int == $OPEN_INT ) { 
+      $last = pop(@list);
+      $str = "( \">0\" 0";
+      foreach $x (@list) {
+	  $str .= ", \">$x\" $x";
+      }
+      $str .= ", \"Large\" $last)\n";
+    } else { 
+      $left = shift(@list);
+      $right = shift(@list)  if $#list >= 0;
+      $last  = pop(@list)    if $#list >= 0;
+      $str = "( \"$left-$right\" " . $left;
+      $left = $right;
+      foreach $right (@list) {
+	  $str .= ", \"$left-$right\" " . ($left+$right)/2;
+	  $left = $right;
+      }
+      $str .= ", \"$left-$last\" " . $last .")\n"   unless $last eq "";
+    }
+    return $str;
+}
+
+# ----------------------------------------------------------------------------
+
+sub print_line {
+    local ($start,$end,$is_global,$bbs,$ha,$rt,$bt,$bc,$ft,$fc,$my) = @_;
+
+    printf("START: %u, END: %u  ==> tot_exec: %u\n",
+           $start,$end,$end-$start);
+    printf("  BASIC_BLOCKS: %u, HEAP_ALLOCATIONS: %u \n",$bbs,$ha);
+    printf("  TOT_EXEC: %u = RUN_TIME %u + BLOCK_TIME %u + FETCH_TIME %u\n",
+           $end-$start,$rt,$bt,$ft);
+    printf("  BLOCK_TIME %u / BLOCK_COUNT %u; FETCH_TIME %u / FETCH_COUNT %u\n",
+	   $bt,$bc,$ft,$fc);
+    printf("  %s  %s\n",
+           $is_global eq 'T' ? "GLOBAL" : "LOCAL",
+           $my eq 'T' ? "MANDATORY" : "NOT MANDATORY"); 
+}
+           
+# ----------------------------------------------------------------------------
+
+sub gnu_plotify {
+  local ($gp_file_name) = @_;
+
+  local (@open_xrange,@closed_xrang,@spark_xrange,@ha_xrange, @ft_range,
+         $exec_xtics,$comm_perc_xtics,$spark_xtics,$has_xtics,
+	 $cumu0_rts_file, $cumu0_has_file, $cumu0_fts_file);
+
+ $cumu0_rts_file = $cumulat_rts_file_name;
+ $cumu0_rts_file =~ s/\.dat$//;
+ $cumu0_rts_file .= "0.dat";
+
+ $cumu0_has_file = $cumulat_has_file_name;
+ $cumu0_has_file =~ s/\.dat$//;
+ $cumu0_has_file .= "0.dat";
+
+ $cumu0_fts_file = $cumulat_fts_file_name;
+ $cumu0_fts_file =~ s/\.dat$//;
+ $cumu0_fts_file .= "0.dat";
+
+ $cumu0_cps_file = $cumulat_cps_file_name;
+ $cumu0_cps_file =~ s/\.dat$//;
+ $cumu0_cps_file .= "0.dat";
+
+  @open_xrange = &range($OPEN_INT,$logscale{'g'},@exec_times);
+  @closed_xrange = &range($CLOSED_INT,$logscale{'c'},@comm_percs);
+  @spark_xrange = &range($OPEN_INT,$logscale{'s'},@sparks);
+  @ha_xrange = &range($OPEN_INT,$logscale{'a'},@has);
+  @ft_xrange = &range($OPEN_INT,$logscale{'f'},@fts);
+
+  $exec_xtics = $opt_T ? &get_xtics($OPEN_INT,@exec_times) : "" ;
+  $comm_perc_xtics = $opt_T ? &get_xtics($CLOSED_INT,@comm_percs) : "";
+  $spark_xtics = $opt_T ? &get_xtics($OPEN_INT,@sparks) : "";
+  $has_xtics = $opt_T ? &get_xtics($OPEN_INT,@has) : "";
+  $fts_xtics = $opt_T ? &get_xtics($OPEN_INT,@fts) : "";
+
+  open(GP_FILE,">$gp_file_name") || 
+      die "Couldn't open gnuplot file $gp_file_name for output\n";
+
+  if ( $opt_m ) {
+      print GP_FILE "set term postscript \"Roman\" 20\n";
+  } else {
+      print GP_FILE "set term postscript color \"Roman\" 20\n";
+  }
+
+  do write_gp_record(GP_FILE,
+                     $gran_file_name, &dat2ps_name($gran_file_name),
+                     "Granularity (pure exec. time)", $ylabel, $logscale{'g'},
+                     @open_xrange,$max_rt_class,$exec_xtics);
+  do write_gp_record(GP_FILE,
+                     $gran_global_file_name, &dat2ps_name($gran_global_file_name),
+                     "Granularity (pure exec. time) of exported threads",
+                     $ylabel, $logscale{'g'},
+                     @open_xrange,$max_rt_global_class,$exec_xtics);
+  do write_gp_record(GP_FILE,
+                     $gran_local_file_name, &dat2ps_name($gran_local_file_name),
+                     "Granularity (pure exec. time) of not exported threads",
+                     $ylabel,$logscale{'g'},
+                     @open_xrange,$max_rt_local_class,$exec_xtics);
+
+  do write_gp_record(GP_FILE,
+                     $comm_file_name, &dat2ps_name($comm_file_name),
+                     "% of communication",$ylabel,$logscale{'c'},
+                     @closed_xrange,$max_comm_perc_class,$comm_perc_xtics);
+  do write_gp_record(GP_FILE,
+                     $comm_global_file_name, &dat2ps_name($comm_global_file_name),
+                     "% of communication of exported threads",$ylabel,$logscale{'c'},
+                     @closed_xrange,$max_comm_perc_global_class,$comm_perc_xtics);
+  do write_gp_record(GP_FILE,
+                     $comm_local_file_name, &dat2ps_name($comm_local_file_name),
+                     "% of communication of not exported threads",$ylabel,$logscale{'c'},
+                     @closed_xrange,$max_comm_perc_local_class,$comm_perc_xtics);
+  do write_gp_record(GP_FILE,
+                     $ft_file_name, &dat2ps_name($ft_file_name),
+                     "Communication time", $ylabel, $logscale{'g'},
+                     @open_xrange,$max_ft_class,$fts_xtics);
+
+
+  do write_gp_record(GP_FILE,
+                     $spark_file_name, &dat2ps_name($spark_file_name),
+                     "No. of sparks created", $ylabel, $logscale{'s'},
+                     @spark_xrange,$max_spark_class,$spark_xtics);
+
+  do write_gp_record(GP_FILE,
+                     $spark_local_file_name, &dat2ps_name($spark_local_file_name),
+                     "No. of sparks created (parLocal)", $ylabel, $logscale{'s'},
+                     @spark_xrange,$max_spark_local_class,$spark_xtics);
+
+  do write_gp_record(GP_FILE,
+                     $spark_global_file_name, &dat2ps_name($spark_global_file_name),
+                     "No. of sparks created (parGlobal)", $ylabel, $logscale{'s'},
+                     @spark_xrange,$max_spark_global_class,$spark_xtics);
+
+  do write_gp_record(GP_FILE,
+                     $ha_file_name, &dat2ps_name($ha_file_name),
+                     "Heap Allocations (words)", $ylabel, $logscale{'a'},
+                     @ha_xrange,$max_ha_class,$has_xtics);
+
+  do write_gp_lines_record(GP_FILE,
+                           $cumulat_rts_file_name, &dat2ps_name($cumulat_rts_file_name),
+                           "Cumulative pure exec. times","% of threads",
+			   $logscale{'Cg'},
+                           $xend_cum_rts, $yend_cum_rts,""); 
+                           # $xtics_cluster_rts as last arg?
+
+  do write_gp_lines_record(GP_FILE,
+                           $cumulat_has_file_name, &dat2ps_name($cumulat_has_file_name),
+                           "Cumulative heap allocations","% of threads",
+			   $logscale{'Ca'},
+                           $xend_cum_has, $yend_cum_has,"");
+                           #  $xtics_cluster_has as last arg?
+
+  do write_gp_lines_record(GP_FILE,
+                           $cumu0_rts_file, &dat2ps_name($cumu0_rts_file),
+                           "Cumulative pure exec. times","Number of threads",
+			   $logscale{'Cg'},
+                           $xend_cum_rts, $yend_cum0_rts,""); 
+                           # $xtics_cluster_rts as last arg?
+
+  do write_gp_lines_record(GP_FILE,
+                           $cumu0_has_file, &dat2ps_name($cumu0_has_file),
+                           "Cumulative heap allocations","Number of threads",
+			   $logscale{'Ca'},
+                           $xend_cum_has, $yend_cum0_has,"");
+                           #  $xtics_cluster_has as last arg?
+
+  do write_gp_lines_record(GP_FILE,
+                           $cumulat_fts_file_name, &dat2ps_name($cumulat_fts_file_name),
+                           "Cumulative communication times","% of threads",
+			   $logscale{'Cg'},
+                           $xend_cum_fts, $yend_cum_fts,""); 
+                           # $xtics_cluster_rts as last arg?
+
+  do write_gp_lines_record(GP_FILE,
+                           $cumu0_fts_file, &dat2ps_name($cumu0_fts_file),
+                           "Cumulative communication times","Number of threads",
+			   $logscale{'Cg'},
+                           $xend_cum_fts, $yend_cum0_fts,""); 
+                           # $xtics_cluster_rts as last arg?
+
+  do write_gp_lines_record(GP_FILE,
+                           $cumulat_cps_file_name, &dat2ps_name($cumulat_cps_file_name),
+                           "Cumulative communication percentages","% of threads",
+			   "",  # No logscale here !
+                           $xend_cum_cps, $yend_cum_cps,""); 
+                           # $xtics_cluster_rts as last arg?
+
+  do write_gp_lines_record(GP_FILE,
+                           $cumu0_cps_file, &dat2ps_name($cumu0_cps_file),
+                           "Cumulative communication percentages","Number of threads",
+			   "",  # No logscale here !
+                           $xend_cum_cps, $yend_cum0_cps,""); 
+                           # $xtics_cluster_rts as last arg?
+
+  do write_gp_record(GP_FILE,
+                     $clust_rts_file_name, &dat2ps_name($clust_rts_file_name),
+                     "Pure exec. time", "No. of threads", $logscale{'CG'},
+                     $xstart_cluster_rts,$xend_cluster_rts,$max_cluster_rts,$xtics_cluster_rts);
+
+  do write_gp_record(GP_FILE,
+                     $clust_has_file_name, &dat2ps_name($clust_has_file_name),
+                     "Pure exec. time", "No. of threads", $logscale{'CA'},
+                     $xstart_cluster_has,$xend_cluster_has,$max_cluster_has,$xtics_cluster_has);
+
+  do write_gp_record(GP_FILE,
+                     $clust_fts_file_name, &dat2ps_name($clust_fts_file_name),
+                     "Communication time", "No. of threads", $logscale{'CG'},
+                     $xstart_cluster_fts,$xend_cluster_fts,$max_cluster_fts,$xtics_cluster_rts);
+
+
+  do write_gp_simple_record(GP_FILE,
+                     $pe_file_name, &dat2ps_name($pe_file_name),
+                     "Processing Elements (PEs)", "Ready Time (not running)", 
+                     $logscale{'Yp'},$xstart_pe,$xend_pe,$max_pe,$xtics_pe);
+
+  do write_gp_simple_record(GP_FILE,
+                     $sn_file_name, &dat2ps_name($sn_file_name),
+                     "Spark sites", "Pure exec. time", 
+                     $logscale{'Ys'},$xstart_sn,$xend_sn,$max_sn,$xtics_sn);
+
+  close GP_FILE;
+
+  print "Gnu plotting figures ...\n";
+  system "gnuplot $gp_file_name";
+
+  print "Extending thickness of impulses ...\n";
+  do gp_ext($gran_file_name,
+            $gran_global_file_name,
+	    $gran_local_file_name,
+	    $comm_file_name,
+	    $comm_global_file_name,
+	    $comm_local_file_name,
+	    $spark_file_name,
+	    $spark_local_file_name,
+	    $spark_global_file_name,
+	    $ha_file_name,
+	    $ft_file_name,
+	    $clust_fts_file_name,
+	    $clust_rts_file_name,
+	    $clust_has_file_name,
+            $pe_file_name,
+	    $sn_file_name
+  );
+
+
+}
+
+# ----------------------------------------------------------------------------
+
+sub gp_ext {
+    local (@file_names) = @_;
+    local ($file_name);
+    local ($ps_file_name);
+    local ($prg);
+
+    #$prg = system "which gp-ext-imp";
+    #print "  Using script $prg for impuls extension\n";
+    $prg = $ENV{GRANDIR} ? $ENV{GRANDIR} . "/bin/gp-ext-imp" 
+	                 : $ENV{HOME} . "/bin/gp-ext-imp" ;
+    if ( $opt_v ) {
+	print "    (using script $prg)\n";
+    }
+
+    foreach $file_name (@file_names) {
+	$ps_file_name = &dat2ps_name($file_name);
+        system "$prg -w $ext_size -g $gray " . 
+               $ps_file_name  . " " . 
+               $ps_file_name . "2" ;
+        system "mv " . $ps_file_name . "2 " . $ps_file_name;
+    }
+}
+
+# ----------------------------------------------------------------------------
+
+sub write_gp_record {
+    local ($file,$in_file,$out_file,$xlabel,$ylabel,$logaxes,
+           $xstart,$xend,$ymax,$xtics) = @_;
+
+    if ( $xstart >= $xend ) {
+	print ("WARNING: empty xrange [$xstart:$xend] changed to [$xstart:" . $xstart+1 . "]\n")        if ( $pedantic || $opt_v );
+	$xend = $xstart + 1;	
+    }
+
+    if ( $ymax <=0 ) {
+	$ymax = 2;
+	print "WARNING: empty yrange changed to [0:$ymax]\n"   if ( $pedantic || $opt_v );
+    }
+
+    $str = "set size " . $xsize . "," . $ysize . "\n" .
+           "set xlabel \"" . $xlabel . "\"\n" .
+           "set ylabel \"" . $ylabel . "\"\n" .
+           ($xstart eq "" ? "" 
+                          : "set xrange [" . int($xstart) .":" . int($xend) . "]\n") .
+           ($ymax eq "" ? "" 
+                        : "set yrange [" . (index($logaxes,"y") != -1 ? 1 : 0) . 
+                          ":" . &list_max(2,int($ymax+$ymax/5)) . "]\n") .
+           ($xtics ne "" ? "set xtics $xtics" : "") . 
+	   "set tics out\n" .
+           "set border\n" .
+           "set title \"$nPEs PEs\"\n" .
+	   "set nokey \n" .
+           "set nozeroaxis\n" .
+	   "set format xy \"%g\"\n" .
+           (index($logaxes,"x") != -1 ? 
+               "set logscale x\n" : 
+               "set nologscale x\n") .
+           (index($logaxes,"y") != -1 ? 
+               "set logscale y\n" : 
+               "set nologscale y\n") .
+           "set output \"" . $out_file . "\"\n" .
+	   "plot \"" . $in_file . "\" with impulses\n\n";
+    print $file $str;
+}
+
+# ----------------------------------------------------------------------------
+
+sub write_gp_lines_record {
+    local ($file,$in_file,$out_file,$xlabel,$ylabel,$logaxes,
+           $xend,$yend,$xtics) = @_;
+
+    local ($str);
+
+    $str = "set xlabel \"" . $xlabel . "\"\n" .
+           "set ylabel \"" . $ylabel . "\"\n" .
+	   "set xrange [" . ( index($logaxes,"x") != -1 ? 1 : 0 ) . ":$xend]\n" .
+	   "set yrange [" . ( index($logaxes,"y") != -1 ? 1 : 0 ) . ":$yend]\n" .
+           "set border\n" .
+           "set nokey\n" .
+           ( $xtics ne "" ? "set xtics $xtics" : "" ) .
+           (index($logaxes,"x") != -1 ? 
+               "set logscale x\n" : 
+               "set nologscale x\n") .
+           (index($logaxes,"y") != -1 ? 
+               "set logscale y\n" : 
+               "set nologscale y\n") .
+           "set nozeroaxis\n" .
+	   "set format xy \"%g\"\n" .
+           "set output \"" . $out_file . "\"\n" .
+	   "plot \"" . $in_file . "\" with lines\n\n";
+    print $file $str;
+}
+
+
+# ----------------------------------------------------------------------------
+
+sub write_gp_simple_record {
+    local ($file,$in_file,$out_file,$xlabel,$ylabel,$logaxes,
+           $xstart,$xend,$ymax,$xtics) = @_;
+
+    $str = "set size " . $xsize . "," . $ysize . "\n" .
+           "set xlabel \"" . $xlabel . "\"\n" .
+           "set ylabel \"" . $ylabel . "\"\n" .
+           ($xstart eq "" ? "" 
+                          : "set xrange [" . int($xstart) .":" . int($xend) . "]\n") .
+           ($ymax eq "" ? "" 
+                        : "set yrange [" . (index($logaxes,"y") != -1 ? 1 : 0) . 
+                          ":" . &list_max(2,int($ymax+$ymax/5)) . "]\n") .
+           ($xtics ne "" ? "set xtics $xtics" : "") . 
+           "set border\n" .
+           "set nokey\n" .
+	   "set tics out\n" .
+           "set nozeroaxis\n" .
+	   "set format xy \"%g\"\n" .
+           (index($logaxes,"x") != -1 ? 
+               "set logscale x\n" : 
+               "set nologscale x\n") .
+           (index($logaxes,"y") != -1 ? 
+               "set logscale y\n" : 
+               "set nologscale y\n") .
+           "set output \"" . $out_file . "\"\n" .
+	   "plot \"" . $in_file . "\" with impulses\n\n";
+    print $file $str;
+}
+
+# ----------------------------------------------------------------------------
+
+sub dat2ps_name {
+    local ($dat_name) = @_;
+
+    $dat_name =~ s/\.dat$/\.ps/;
+    return ($dat_name);
+}
+
+# ----------------------------------------------------------------------------
+
+sub range {
+    local ($open_int, $logaxes, @ints) = @_;
+
+    local ($range, $left_margin, $right_margin);
+
+    $range = $ints[$#ints]-$ints[0];
+    $left_margin = 0; # $range/10;
+    $right_margin = 0; # $range/10;
+
+    if ( $opt_D ) {
+       print "\n==> Range: logaxes are $logaxes i.e. " . 
+	   (index($logaxes,"x") != -1 ? "matches x axis\n" 
+	                              : "DOESN'T match x axis\n"); 
+    }
+    if ( index($logaxes,"x") != -1 ) {
+	if ( $open_int == $OPEN_INT ) {
+	    return ( ($ints[0]/2-$left_margin, 
+		      $ints[$#ints]+($ints[$#ints]-$ints[$#ints-1])/2+$right_margin) );
+	} else {
+	    return ( ( &list_max(1,$ints[0]-$left_margin), 
+		       $ints[$#ints]+($ints[$#ints]-$ints[$#ints-1])/2+$right_margin) );
+	}
+    } else {
+	if ( $open_int == $OPEN_INT ) {
+	    return ( ($ints[0]/2-$left_margin, 
+		      $ints[$#ints]+($ints[$#ints]-$ints[$#ints-1])/2+$right_margin) );
+	} else {
+	    return ( ($ints[0]-$left_margin, 
+		      $ints[$#ints]+($ints[$#ints]-$ints[$#ints-1])/2+$right_margin) );
+	}
+    }
+}
+
+# ----------------------------------------------------------------------------
+
+sub percentify {
+    local ($sum,*classes) = @_;
+
+    for ($i=0; $i<=$#classes; $i++) {
+	$classes[$i] = (100 * $classes[$i]) / $sum;
+    }
+}
+
+# ----------------------------------------------------------------------------
+# ToDo: get these statistics functions from "stat.pl"
+# ----------------------------------------------------------------------------
+
+sub mean_std_dev {
+    local ($sum,@list) = @_;
+
+    local ($n, $s, $s_);
+
+    #print "\nmean_std_dev: sum is $sum ; list has length $#list";
+
+    $n = $#list+1;
+    $mean_value = $sum/$n;
+
+    $s_ = 0;
+    foreach $x (@list) {
+	$s_ += $x;
+        $s += ($mean_value - $x) ** 2;  
+    }
+    if ( $sum != $s_ ) {
+      print "ERROR in mean_std_dev: provided sum is wrong  " .
+            "(provided: $sum; computed: $s_)\n"; 
+      print " list_sum: " . &list_sum(@list) . "\n";
+      exit (2);
+    }
+
+    return ( ($mean_value, sqrt($s / ($n - 1)) ) );
+}
+
+# ----------------------------------------------------------------------------
+
+sub _mean_std_dev {
+    return ( &mean_std_dev(&list_sum(@_), @_) );
+}
+
+# ----------------------------------------------------------------------------
+# Compute covariance of 2 vectors, having their sums precomputed.
+# Input: $n   ... number of all elements in @list_1 as well as in @list_2
+#                 (i.e. $n = $#list_1+1 = $#list_2+1).
+#        $mean_1 ... mean value of all elements in @list_1
+#        @list_1 ... list of integers; first vector
+#        $mean_2 ... mean value of all elements in @list_2
+#        @list_2 ... list of integers; first vector
+# Output: covariance of @list_1 and @list_2 
+# ----------------------------------------------------------------------------
+
+sub cov {
+    local ($n, $mean_1, @rest) = @_;
+    local (@list_1) = splice(@rest,0,$n);
+    local ($mean_2, @list_2) = @rest;
+
+    local ($i,$s,$s_1,$s_2);
+
+    for ($i=0; $i<$n; $i++) {
+	$s_1 += $list_1[$i];
+	$s_2 += $list_2[$i];
+	$s += ($mean_1 - $list_1[$i]) * ($mean_2 - $list_2[$i]);
+    }
+    if ( $mean_1 != ($s_1/$n) ) {
+      print "ERROR in cov: provided mean value is wrong " . 
+            "(provided: $mean_1; computed: " . ($s_1/$n) . ")\n"; 
+      exit (2);
+    }
+    if ( $mean_2 != ($s_2/$n) ) {
+      print "ERROR in cov: provided mean value is wrong " .
+            "(provided: $mean_2; computed: " . ($s_2/$n) . ")\n"; 
+      exit (2);
+    }
+    return ( $s / ($n - 1) ) ;
+}
+
+# ----------------------------------------------------------------------------
+# Compute correlation of 2 vectors, having their sums precomputed.
+# Input: $n   ... number of all elements in @list_1 as well as in @list_2
+#                 (i.e. $n = $#list_1+1 = $#list_2+1).
+#        $sum_1 ... sum of all elements in @list_1
+#        @list_1 ... list of integers; first vector
+#        $sum_2 ... sum of all elements in @list_2
+#        @list_2 ... list of integers; first vector
+# Output: correlation of @list_1 and @list_2 
+# ----------------------------------------------------------------------------
+
+sub corr {
+    local ($n, $sum_1, @rest) = @_;
+    local (@list_1) = splice(@rest,0,$n);
+    local ($sum_2, @list_2) = @rest;
+       
+    local ($mean_1,$mean_2,$std_dev_1,$std_dev_2);
+
+    if ( $opt_D ) {
+      print "\ncorr: n=$n  sum_1=$sum_1  sum_2=$sum_2\n";
+      print "     list_sum of list_1=" . &list_sum(@list_1) . 
+              "   list_sum of list_2=" . &list_sum(@list_2) . "\n";
+      print "     len of list_1=$#list_1  len of list_2=$#list_2\n";
+    }
+
+    ($mean_1, $std_dev_1) = &mean_std_dev($sum_1,@list_1);
+    ($mean_2, $std_dev_2) = &mean_std_dev($sum_2,@list_2);
+
+    if ( $opt_D ) {
+      print "corr: $mean_1, $std_dev_1; $mean_2, $std_dev_2\n";
+    }
+
+    return ( ($std_dev_1 * $std_dev_2) == 0  ?
+               0 : 
+               &cov($n, $mean_1, @list_1, $mean_2, @list_2) / 
+	       ( $std_dev_1 * $std_dev_2 ) );
+}
+
+# ----------------------------------------------------------------------------
+
+sub list_sum {
+    local (@list) = @_;
+
+    local ($sum);
+
+    foreach $x (@list) {
+	$sum += $x;
+    }
+
+    return ($sum);
+}
+
+# ----------------------------------------------------------------------------
+
+sub list_max {
+    local (@list) = @_;
+
+    local ($max) = shift;
+
+    foreach $x (@list) {
+	$max = $x  if $x > $max;
+    }
+
+    return ($max);
+}
+
+# ----------------------------------------------------------------------------
+
+sub list_min {
+    local (@list) = @_;
+
+    local ($min) = shift;
+
+    foreach $x (@list) {
+	$min = $x  if $x < $min;
+    }
+
+    return ($min);
+}
+
+# ----------------------------------------------------------------------------
+
+sub guess_interval {
+    local (@list) = @_ ;
+
+    local ($min,$max,$sum,$mean,$std_dev,@intervals);
+
+    $min = &list_min(@list);
+    $max = &list_max(@list);
+    $sum = &list_sum(@list);
+    ($mean, $std_dev) = &mean_std_dev($sum,@list);
+
+    @intervals = (int($mean-$std_dev),int($mean-$std_dev/2),int($mean),
+                  int($mean+$std_dev/2),int($mean+$std_dev));
+
+    while ($#intervals>=0 && $intervals[0]<0) {
+	shift(@intervals);
+    }
+
+    return (@intervals);
+}
+
+# ----------------------------------------------------------------------------
+
+sub write_interval {
+    local ($file,$flag,@intervals) = @_;
+
+    printf $file "$flag: (" . join(", ",@intervals) . ")\n";
+}
+ 
+# ----------------------------------------------------------------------------
+
+sub read_template {
+
+    if ( $opt_v ) {
+	print "Reading settings from template file $templ_file_name ...\n";
+    }
+
+    open(TEMPLATE,$templ_file_name) || die "Couldn't open file $templ_file_name";
+    while (<TEMPLATE>) {
+      next if /^\s*$/ || /^--/;
+      if (/^\s*G[:,;.\s]+([^\n]+)$/) {
+	  $list_str = $1;
+          $list_str =~ s/[\(\)\[\]]//g;
+          @exec_times = split(/[,;. ]+/, $list_str);
+      } elsif (/^\s*F[:,;.\s]+([^\n]+)$/) {
+	  $list_str = $1;
+          $list_str =~ s/[\(\)\[\]]//g;
+          @fetch_times = split(/[,;. ]+/, $list_str);
+      } elsif (/^\s*A[:,;.\s]+([^\n]+)$/) {
+	  $list_str = $1;
+          $list_str =~ s/[\(\)\[\]]//g;
+          @has = split(/[,;. ]+/, $list_str);
+      } elsif (/^\s*C[:,;.\s]+([^\n]+)$/) {
+	  $list_str = $1;
+          $list_str =~ s/[\(\)\[\]]//g;
+          @comm_percs = split(/[,;. ]+/, $list_str);
+      } elsif (/^\s*S[:,;.\s]+([^\n]+)$/) {
+	  $list_str = $1;
+          $list_str =~ s/[\(\)\[\]]//g;
+          @sparks = split(/[,;. ]+/, $list_str);
+      } elsif (/^\s*g[:,;.\s]+([\S]+)$/) {
+         ($gran_file_name,$gran_global_file_name, $gran_local_file_name) = 
+           &mk_global_local_names($1);
+      } elsif (/^\s*f[:,;.\s]+([\S]+)$/) {
+         ($ft_file_name,$ft_global_file_name, $ft_local_file_name) = 
+           &mk_global_local_names($1);
+      } elsif (/^\s*c[:,;.\s]+([\S]+)$/) {
+         ($comm_file_name, $comm_global_file_name, $comm_local_file_name) = 
+           &mk_global_local_names($1);
+      } elsif (/^\s*s[:,;.\s]+([\S]+)$/) {
+         ($spark_file_name, $spark_global_file_name, $spark_local_file_name) = 
+           &mk_global_local_names($1);
+      } elsif (/^\s*a[:,;.\s]+([\S]+)$/) {
+         ($ha_file_name, $ha_global_file_name, $ha_local_file_name) = 
+           &mk_global_local_names($1);
+      } elsif (/^\s*p[:,;.\s]+([\S]+)$/) {
+         $gp_file_name = $1;
+	 $ps_file_name = &dat2ps_name($gp_file_name);
+
+      } elsif (/^\s*Xcorr[:,;.\s]+([\S]+)$/) {
+         $corr_file_name = $1;
+      } elsif (/^\s*Xcumulat-rts[:,;.\s]+([\S]+)$/) {
+         $cumulat_rts_file_name = $1;
+      } elsif (/^\s*Xcumulat-has[:,;.\s]+([\S]+)$/) {
+         $cumulat_has_file_name = $1;
+      } elsif (/^\s*Xcumulat-fts[:,;.\s]+([\S]+)$/) {
+         $cumulat_fts_file_name = $1;
+      } elsif (/^\s*Xcumulat-cps[:,;.\s]+([\S]+)$/) {
+         $cumulat_cps_file_name = $1;
+      } elsif (/^\s*Xclust-rts[:,;.\s]+([\S]+)$/) {
+         $clust_rts_file_name = $1;
+      } elsif (/^\s*Xclust-has[:,;.\s]+([\S]+)$/) {
+         $clust_has_file_name = $1;
+      } elsif (/^\s*Xclust-fts[:,;.\s]+([\S]+)$/) {
+         $clust_fts_file_name = $1;
+      } elsif (/^\s*Xclust-cps[:,;.\s]+([\S]+)$/) {
+         $clust_cps_file_name = $1;
+      } elsif (/^\s*Xpe[:,;.\s]+([\S]+)$/) {
+         $pe_file_name = $1;
+      } elsif (/^\s*Xsn[:,;.\s]+([\S]+)$/) {
+         $sn_file_name = $1;
+
+      } elsif (/^\s*XRTS[:,;.\s]+([\S]+)$/) {
+	  $rts_file_name = $1;
+      } elsif (/^\s*XHAS[:,;.\s]+([\S]+)$/) {
+	  $has_file_name = $1;
+      } elsif (/^\s*XFTS[:,;.\s]+([\S]+)$/) {
+	  $fts_file_name = $1;
+      } elsif (/^\s*XLSPS[:,;.\s]+([\S]+)$/) {
+	  $lsps_file_name = $1;
+      } elsif (/^\s*XGSPS[:,;.\s]+([\S]+)$/) {
+	  $gsps_file_name = $1;
+      } elsif (/^\s*XCPS[:,;.\s]+([\S]+)$/) {
+	  $cps_file_name = $1;
+      } elsif (/^\s*XCCPS[:,;.\s]+([\S]+)$/) {
+	  $ccps_file_name = $1;
+
+      } elsif (/^\s*\-[:,;.\s]+([\S]+)$/) {
+         $input = $1;
+      } elsif (/^\s*L[:,;\s]+(.*)$/) {
+	 $str = $1;
+	 %logscale = ('g',"xy",'a',"xy",'Cg',"xy",'Ca',"xy",'Yp',"y",'Ys',"y") , next  if $str eq ".";
+         $str =~ s/[\(\)\[\]]//g;
+         %logscale = split(/[,;. ]+/, $str);
+      } elsif (/^\s*i[:,;.\s]+([\S]+)$/) {
+	 $gray = $1;
+      } elsif (/^\s*k[:,;.\s]+([\S]+)$/) {
+	 $no_of_clusters = $1;
+      } elsif (/^\s*e[:,;.\s]+([\S]+)$/) {
+	 $ext_size = $1;
+      } elsif (/^\s*v.*$/) {
+	 $verbose = 1;
+      } elsif (/^\s*T.*$/) {
+	 $opt_T = 1;
+      } elsif (/^\s*m.*$/) {
+	 $opt_m = 1;
+     }
+  }
+  close(TEMPLATE);
+}      
+
+# ----------------------------------------------------------------------------
+
+sub mk_global_local_names { 
+    local ($file_name) = @_;
+
+    $file_name .= ".dat" unless $file_name =~ /\.dat$/;
+    $global_file_name = $file_name; 
+    $global_file_name =~ s/\.dat/\-global\.dat/ ;
+    $local_file_name = $file_name; 
+    $local_file_name =~ s/\.dat/\-local\.dat/ ;
+
+    return ( ($file_name, $global_file_name, $local_file_name) );
+}
+
+# ----------------------------------------------------------------------------
+
+# ----------------------------------------------------------------------------
+
+sub pre_process {
+    local ($lines) = @_;
+
+    local (@all_rts, @all_comm_percs, @all_sparks, @all_local_sparks, 
+           @all_global_sparks, @all_has, @fields,
+           $line_no, $elem, $total_rt, $comm_perc,
+           $pe, $start, $end, $is_global, $bbs, $ha, $rt, $bt, $ft, 
+           $lsp, $gsp, $my);
+
+    if ( $opt_v ) {
+	print "Preprocessing file $input ... \n";
+    }
+
+    open(INPUT,"<$input") || die "Couldn't open input file $input";
+
+    do skip_header();
+
+    $line_no = 0;
+    while (<INPUT>) {
+	$line_no++;
+	last  if $line_no > $lines;
+	
+	@fields = split(/,/,$_);
+	
+	foreach $elem (@fields) {
+	    foo : {
+		$pe = $1        , last foo   if $elem =~ /^\s*PE\s+(\d+).*$/;
+		$start = $1     , last foo   if $elem =~ /^\s*ST\s+(\d+).*$/;
+		$end = $1       , last foo   if $elem =~ /^\s*END\s+(\d+).*$/;
+		$is_global = $1 , last foo   if $elem =~ /^\s*GBL\s+(T|F).*$/;
+		$bbs = $1       , last foo   if $elem =~ /^\s*BB\s+(\d+).*$/;
+		$ha = $1        , last foo   if $elem =~ /^\s*HA\s+(\d+).*$/;
+		$rt = $1        , last foo   if $elem =~ /^\s*RT\s+(\d+).*$/;
+		$bt = $1, $bc = $2 , last foo if $elem =~ /^\s*BT\s+(\d+)\s+\((\d+)\).*$/;
+		$ft = $1, $fc = $2 , last foo if $elem =~ /^\s*FT\s+(\d+)\s+\((\d+)\).*$/;
+		$lsp = $1        , last foo   if $elem =~ /^\s*LS\s+(\d+).*$/;
+		$gsp = $1        , last foo   if $elem =~ /^\s*GS\s+(\d+).*$/;
+		$my = $1        , last foo   if $elem =~ /^\s*MY\s+(T|F).*$/;
+	    }
+	}
+
+	$total_rt = $end - $start;
+	$comm_perc = ( $total_rt == 0 ? 100 : (100 * $ft)/$total_rt );
+	$sp = $lsp + $gsp;
+	
+	push(@all_rts,$rt);
+	
+	push(@all_comm_percs,$comm_perc); 
+	
+	push(@all_sparks,$sp);
+	push(@all_local_sparks,$lsp);
+	push(@all_global_sparks,$gsp);
+	
+	push(@all_has,$ha);
+    }
+
+    close(INPUT);
+
+    @exec_times = &guess_interval(@all_rts);
+    @sparks     = &guess_interval(@all_sparks);
+    @has        = &guess_interval(@all_has);
+
+    ($m,$std_dev) = &_mean_std_dev(@all_comm_percs);
+    @comm_percs = (0, int($m), int($std_dev), 100)       unless int($m) == 0;
+    @comm_percs = (0, 1, 2, 5, 10, 50, 100)              if     int($m) == 0;
+}
+
+# ----------------------------------------------------------------------------
+
+sub process_options {
+    if ( $opt_h ) {                      
+	open(ME,$0) || die "Can't open myself ($0)";
+	$n = 0;
+	while (<ME>) {
+	    last if $_ =~ /^$/;
+	    print $_;
+	    $n++;
+	}
+	close(ME);
+	
+	# system "cat $0 | awk 'BEGIN { n = 0; } \
+	#                             /^$/ { print n; \
+	#                                    exit; } \
+	#                                  { n++; }'"
+	exit ;
+    }
+
+    if ( $opt_W ) {
+	$pedantic = 1;
+    } else {
+	$pedantic = 0;
+    }
+
+    $input = $#ARGV == -1 ? "-" : $ARGV[0] ;
+    
+    if ( $#ARGV != 0 ) {
+	#print "Usage: gran-extr [options] <sim-file>\n";
+	#print "Use -h option to get details\n";
+	#exit 1;
+	
+    }
+    
+    
+    if ( ! $opt_t ) {
+	do pre_process(20);
+    }
+    
+    if ( $opt_g ) {
+	($gran_file_name, $gran_global_file_name, $gran_local_file_name) =       
+	    do mk_global_local_names($opt_g);
+    } else {
+	$gran_file_name = "gran.dat";
+	$gran_global_file_name = "gran-global.dat";
+	$gran_local_file_name = "gran-local.dat";
+    }
+    
+    if ( $opt_c ) {
+	($comm_file_name, $comm_global_file_name, $comm_local_file_name) =       
+	    do mk_global_local_names($opt_c);
+    } else {
+	$comm_file_name = "comm.dat";
+	$comm_global_file_name = "comm-global.dat";
+	$comm_local_file_name = "comm-local.dat";
+    }
+    
+    if ( $opt_f ) {
+	($ft_file_name, $ft_global_file_name, $ft_local_file_name) =       
+	    do mk_global_local_names($opt_c);
+    } else {
+	$ft_file_name = "ft.dat";
+	$ft_global_file_name = "ft-global.dat";
+	$ft_local_file_name = "ft-local.dat";
+    }
+    
+    if ( $opt_s ) {
+	($spark_file_name, $spark_global_file_name, $spark_local_file_name) =  
+	    do mk_global_local_names($opt_s);
+    } else {
+	$spark_file_name = "spark.dat";
+	$spark_global_file_name = "spark-global.dat";
+	$spark_local_file_name = "spark-local.dat";
+    }
+    
+    if ( $opt_a ) {
+	($ha_file_name, $ha_global_file_name, $ha_local_file_name) =       
+	    do mk_global_local_names($opt_a);
+    } else {
+	$ha_file_name = "ha.dat";
+    }
+    
+    if ( $opt_p ) {
+	$gp_file_name = $opt_p;
+    } else {
+	$gp_file_name = "gran.gp";
+    }
+    
+    $ps_file_name = &dat2ps_name($gp_file_name);
+    
+    $corr_file_name = "CORR";
+    $cumulat_rts_file_name = "cumulative-rts.dat";
+    $cumulat_has_file_name = "cumulative-has.dat";
+    $cumulat_fts_file_name = "cumulative-fts.dat";
+    $cumulat_cps_file_name = "cumulative-cps.dat";
+    $clust_rts_file_name = "clusters-rts.dat";
+    $clust_has_file_name = "clusters-has.dat";
+    $clust_fts_file_name = "clusters-fts.dat";
+    $clust_cps_file_name = "clusters-cps.dat";
+    $pe_file_name = "pe.dat";
+    $sn_file_name = "sn.dat";
+
+    $pie_file_name = "Pie.ps";
+
+    $cps_file_name = "CPS";
+    $fts_file_name = "FTS";
+    $rts_file_name = "RTS";
+    $has_file_name = "HAS";
+    $lsps_file_name = "LSPS";
+    $gsps_file_name = "GSPS";
+    $ccps_file_name = "CCPS";
+
+    if ( $opt_l ) {
+	$left_margin = $opt_l; 
+    } else {
+	$left_margin = 0; 
+    }
+    $left_perc_margin = 0;
+    
+    if ( $opt_r ) {
+	$right_margin = $opt_r; 
+    } else {
+	$right_margin = 0; 
+    }
+    $right_perc_margin = 0;
+    
+    if ( $opt_x ) {
+	$xsize = $opt_x;
+    } else {
+	$xsize = 1;
+    }
+    
+    if ( $opt_y ) {
+	$ysize = $opt_y;
+    } else {
+	$ysize = 1;
+    }
+    
+    if ( $opt_e ) {
+	$ext_size = $opt_e; 
+    } else {
+	$ext_size = 200; 
+    }
+    
+    if ( $opt_i ) {
+	$gray = $opt_i; 
+    } else {
+	$gray = 0; 
+    }
+    
+    if ( $opt_k ) {
+	$no_of_clusters = $opt_k; 
+    } else {
+	$no_of_clusters = 5; 
+    }
+    
+    if ( $opt_L ) {
+        $str = $opt_L;
+        $str =~ s/[\(\)\[\]]//g;
+        %logscale = split(/[,;. ]+/, $str);
+	# $logscale = $opt_L;
+    } else {
+	%logscale = ();        # ('g',"xy",'a',"xy",'Cg',"xy",'Ca',"xy");
+    }
+    
+# $delta = do compute_delta(@exec_times);
+# $no_of_exec_times = $#exec_times;
+    
+    if ( $opt_G ) {
+	$opt_G =~ s/[\(\)\[\]]//g;
+	@exec_times = split(/[,;. ]+/, $opt_G);
+	# @exec_times = split(/[,;. ]+/, ($opt_G =~ s/[\(\)]//g));
+    } else {
+	# @exec_times = (50, 100, 200, 300, 400, 500, 700);
+    }
+    
+    if ( $opt_F ) {
+	$opt_F =~ s/[\(\)\[\]]//g;
+	@fetch_times = split(/[,;. ]+/, $opt_F);
+	# @fetch_times = split(/[,;. ]+/, ($opt_F =~ s/[\(\)]//g));
+    } else {
+	# @fetch_times = (50, 100, 200, 300, 400, 500, 700);
+    }
+    
+    if ( $opt_C ) {
+	$opt_C =~ s/[\(\)\[\]]//g;
+	@comm_percs = split(/[,;. ]+/, $opt_C);
+    } else { 
+	# @comm_percs = (0,10,20,30,50,100);
+    } 
+    
+    if ( $opt_S ) {
+	$opt_S =~ s/[\(\)\[\]]//g;
+	@sparks = split(/[,;. ]+/, $opt_S);
+    } else { 
+	# @sparks = (0,5,10,50);
+    } 
+    
+# $delta_comm = do compute_delta(@comm_percs);
+    
+    if ( $opt_A ) {
+	$opt_A =~ s/[\(\)\[\]]//g;
+	@has = split(/[,;. ]+/, $opt_A);
+    } else {
+	# @has = (10, 100, 200, 300, 500, 1000);
+    }
+    
+    if ( $opt_t ) {
+	$templ_file_name = ( $opt_t eq '.' ? "TEMPL"     #   default file name
+			     : $opt_t eq ',' ? "/users/fp/hwloidl/grasp/GrAn/bin/TEMPL"     #   global master template
+			     : $opt_t eq '/' ? "/users/fp/hwloidl/grasp/GrAn/bin/T0"     #   template, that throws away most of the info
+                             : $opt_t ); 
+	do read_template();
+	# see RTS2gran for use of template-package
+    }
+    
+    $ylabel = $opt_P ? "% of threads" : "No. of threads";
+}  
+
+# ----------------------------------------------------------------------------
+
+sub print_verbose_message { 
+
+    print "-" x 70 . "\n";
+    print "Setup: \n";
+    print "-" x 70 . "\n";
+    print "\nFilenames: \n";
+    print "  Input file: $input\n";
+    print "  Gran files: $gran_file_name $gran_global_file_name $gran_local_file_name\n"; 
+    print "  Comm files: $comm_file_name $comm_global_file_name $comm_local_file_name\n";
+    print "  Sparked threads file: $spark_file_name $spark_local_file_name $spark_global_file_name\n";
+    print "  Heap file: $ha_file_name\n";
+    print "  GNUPLOT file name: $gp_file_name   Correlation file name: $corr_file_name\n";
+    print "  Cumulative RT file name: $cumulat_rts_file_name   \n  Cumulative HA file name: $cumulat_has_file_name\n";
+    print "  Cluster RT file name: $clust_rts_file_name   \n  Cluster HA file name: $clust_has_file_name\n";
+    print "  Cumulative runtimes file name:    $cumulat_rts_file_name\n";
+    print "  Cumulative heap allocations file name   $cumulat_has_file_name\n";
+    print "  Cluster run times file name:    $clust_rts_file_name\n";
+    print "  Cluster heap allocations file name:    $clust_has_file_name\n";
+    print "  PE load file name:    $pe_file_name\n";
+    print "  Site size file name:    $sn_file_name\n";
+    print "\nBoundaries: \n";
+    print "  Gran boundaries: @exec_times\n";
+    print "  Comm boundaries: @comm_percs\n";
+    print "  Sparked threads boundaries: @sparks\n";
+    print "  Heap boundaries: @has\n";
+    print "\nOther pars: \n";
+    print "  Left margin: $left_margin  Right margin: $right_margin\n";
+    print "  GP-extension: $ext_size  GP xsize: $xsize  GP ysize: $ysize\n";
+    print "  Gray scale: $gray  Smart x-tics is " . ($opt_T ? "ON" : "OFF") .
+	  "  Percentage y-axis is " . ($opt_P ? "ON" : "OFF") . "\n";
+    print "  Log. scaling assoc list: ";
+    while (($key,$value) = each %logscale) {
+        print "$key: $value, ";
+    }
+    print "\n";
+    print "  Active template file: $templ_file\n"              if $opt_t;  
+    print "-" x 70 . "\n";
+}
+
+# ----------------------------------------------------------------------------
+
+sub sort_and_cum {
+
+@sorted_rts = sort {$a <=> $b} @all_rts;
+
+($xstart_cluster_rts,$xend_cluster_rts,$max_cluster_rts,$xtics_cluster_rts) =
+  &write_cumulative_data($cumulat_rts_file_name,$clust_rts_file_name,@sorted_rts);
+
+$xend_cum_rts = pop(@sorted_rts);
+$yend_cum_rts = 100;
+$yend_cum0_rts = $#sorted_rts+1;         # unpercentified cum graph
+
+open(RTS,">$rts_file_name") || die "$rts_file_name: $!";
+print RTS "Sorted list of all runtimes:\n";
+print RTS join("\n",@sorted_rts);
+close(RTS);
+
+@sorted_has = sort {$a <=> $b} @all_has;
+
+($xstart_cluster_has,$xend_cluster_has,$max_cluster_has,$xtics_cluster_has) =
+  &write_cumulative_data($cumulat_has_file_name,$clust_has_file_name,@sorted_has);
+
+$xend_cum_has = pop(@sorted_has);
+$yend_cum_has = 100;
+$yend_cum0_has = $#sorted_has+1;         # unpercentified cum graph
+
+open(HAS,">$has_file_name") || die "$has_file_name: $!";
+print HAS "Sorted list of all heap allocations:\n";
+print HAS join("\n",@sorted_has);
+close(HAS);
+
+@sorted_lsps = sort {$a <=> $b} @all_local_sparks;
+
+open(LSPS,">$lsps_file_name") || die "$lsps_file_name: $!";
+print LSPS "Sorted list of all local sparks:\n";
+print LSPS join("\n",@sorted_lsps);
+close(LSPS);
+
+@sorted_gsps = sort {$a <=> $b} @all_global_sparks;
+
+open(GSPS,">$gsps_file_name") || die "$gsps_file_name: $!";
+print GSPS "Sorted list of all global sparks:\n";
+print GSPS join("\n",@sorted_gsps);
+close(GSPS);
+
+@sorted_fts = sort {$a <=> $b} @all_fts;
+
+($xstart_cluster_fts,$xend_cluster_fts,$max_cluster_fts,$xtics_cluster_fts) =
+  &write_cumulative_data($cumulat_fts_file_name,$clust_fts_file_name,@sorted_fts);
+
+$xend_cum_fts = pop(@sorted_fts);
+$yend_cum_fts = 100;
+$yend_cum0_fts = $#sorted_fts+1;         # unpercentified cum graph
+
+open(FTS,">$fts_file_name") || die "$FTS_file_name: $!";
+print FTS "Sorted list of all communication times:\n";
+print FTS join("\n",@sorted_fts);
+close(FTS);
+
+@sorted_comm_percs = sort {$a <=> $b} @all_comm_percs;
+
+($xstart_cluster_cps,$xend_cluster_cps,$max_cluster_cps,$xtics_cluster_cps) =
+  &write_cumulative_data($cumulat_cps_file_name,$clust_cps_file_name,@sorted_comm_percs);
+
+$xend_cum_cps = 100;  # pop(@sorted_comm_percs);
+$yend_cum_cps = 100;
+$yend_cum0_cps = $#sorted_comm_percs+1;         # unpercentified cum graph
+
+open(CCPS,">$ccps_file_name") || die "$ccps_file_name: $!";
+print CCPS "Sorted list of all communication percentages:\n";
+print CCPS join("\n",@sorted_comm_percs);
+close(CCPS);
+
+($xstart_pe,$xend_pe,$max_pe,$xtics_pe) =
+    &write_array($pe_file_name,$#pe_load,@pe_load);
+
+($xstart_sn,$xend_sn,$max_sn,$xtics_sn) =
+    &write_array($sn_file_name,$#site_size,@site_size);
+
+if ( $opt_D ) {
+  print "After write_array: xstart, xend, max _sn: $xstart_sn,$xend_sn,$max_sn,$xtics_sn\n";
+} 
+}
+
+# ----------------------------------------------------------------------------
+# Compute statistical values (like mean, std_dev and especially corr coeff).
+# Write the important info to a file.
+# ----------------------------------------------------------------------------
+
+sub do_statistics {
+    local ($n) = @_;
+
+    if ( $n <= 1 ) {
+	print "Sorry, no statistics for just $n threads\n";
+        return -1;
+    }
+
+# Compute mean values and std deviations
+# ......................................
+    
+    ($mean_rt,$std_dev_rt) = &mean_std_dev($sum_rt,@all_rts);
+    ($mean_comm_perc,$std_dev_comm_perc) = &mean_std_dev($sum_comm_perc,@all_comm_percs);
+    ($mean_spark,$std_dev_spark) = &mean_std_dev($sum_sp,@all_sparks);
+    ($mean_local_spark,$std_dev_local_spark) = &mean_std_dev($sum_local_sp,@all_local_sparks);
+    ($mean_global_spark,$std_dev_global_spark) = &mean_std_dev($sum_global_sp,@all_global_sparks);
+    ($mean_ha,$std_dev_ha) = &mean_std_dev($sum_ha,@all_has);
+    ($mean_ft,$std_dev_ft) = &mean_std_dev($sum_ft,@all_fts);
+    
+# Compute correlation coefficients
+# ................................
+    
+    $c_exec_ha = &corr($#all_rts+1,$sum_rt,@all_rts,$sum_ha,@all_has);
+    $c_exec_sp = &corr($#all_rts+1,$sum_rt,@all_rts,$sum_sp,@all_sparks);
+    $c_exec_lsp = &corr($#all_rts+1,$sum_rt,@all_rts,$sum_local_sp,@all_local_sparks);
+    $c_exec_gsp = &corr($#all_rts+1,$sum_rt,@all_rts,$sum_global_sp,@all_global_sparks);
+    $c_ha_sp   = &corr($#all_has+1,$sum_ha,@all_has,$sum_sp,@all_sparks);
+    $c_ha_lsp   = &corr($#all_has+1,$sum_ha,@all_has,$sum_local_sp,@all_local_sparks);
+    $c_ha_gsp   = &corr($#all_has+1,$sum_ha,@all_has,$sum_global_sp,@all_global_sparks);
+    $c_exec_ft = &corr($#all_rts+1,$sum_rt,@all_rts,$sum_ft,@all_fts);
+    $c_ha_ft = &corr($#all_has+1,$sum_ha,@all_has,$sum_ft,@all_fts);
+    $c_lsp_ft = &corr($#all_local_sparks+1,$sum_local_sp,@all_local_sparks,$sum_ft,@all_fts);
+    $c_gsp_ft = &corr($#all_global_sparks+1,$sum_global_sp,@all_global_sparks,$sum_ft,@all_fts);
+    
+# Write corr coeffs into a file
+# .............................
+    
+    open(CORR,">$corr_file_name") || die "Couldn't open file $corr_file_name\n";
+    #printf CORR ("%f\n%f\n%f\n%f\n%f",$c_exec_ha,$c_exec_lsp,$c_exec_gsp,$c_ha_lsp,$c_ha_gsp)   ;
+    printf CORR ("CORR of runtime and heap alloc:  %f\n",$c_exec_ha);
+    printf CORR ("CORR of runtime and no. of sparks:  %f\n",$c_exec_sp);
+    printf CORR ("CORR of heap alloc and no. sparks:  %f\n",$c_ha_sp);
+    printf CORR ("CORR of runtime and no. of local sparks:  %f\n",$c_exec_lsp);
+    printf CORR ("CORR of runtime and no. of global sparks:  %f\n",$c_exec_gsp);
+    printf CORR ("CORR of heap alloc and no. local sparks:  %f\n",$c_ha_lsp);
+    printf CORR ("CORR of heap alloc and no. global sparks:  %f\n",$c_ha_gsp);
+    printf CORR ("CORR of runtime and communication time:  %f\n",$c_exec_ft);
+    printf CORR ("CORR of heap alloc and communication time:  %f\n",$c_ha_ft);
+    printf CORR ("CORR of no. of local sparks and communication time:  %f\n",$c_lsp_ft);
+    printf CORR ("CORR of no. of global sparks and communication time:  %f\n",$c_gsp_ft);
+    close(CORR);
+
+# These are needed later in the GNUPLOT files
+# ...........................................
+
+    $max_rt_class = &list_max(@exec_class);
+    $max_rt_global_class = &list_max(@exec_global_class);
+    $max_rt_local_class = &list_max(@exec_local_class);
+    $max_comm_perc_class = &list_max(@comm_class);
+    $max_comm_perc_global_class = &list_max(@comm_global_class);
+    $max_comm_perc_local_class = &list_max(@comm_local_class);
+    $max_spark_class = &list_max(@spark_class);
+    $max_spark_local_class = &list_max(@spark_local_class);
+    $max_spark_global_class = &list_max(@spark_global_class);
+    $max_ha_class = &list_max(@ha_class);
+    $max_ft_class = &list_max(@fetch_class);
+
+}
+
+# ----------------------------------------------------------------------------
+# This is written to STDOUT at the end of the file processing (before 
+# gnuplotting and such) if the verbose option is given.
+# ----------------------------------------------------------------------------
+
+sub print_general_info {
+
+    printf("\nTotal number of lines: %d\n", $line_no);
+    
+    print "\nDistribution of execution times: \n";
+    print " Intervals: " . join('|',@exec_times) . "\n";
+    print " Total: " . join('|',@exec_class) . "\n";
+    print " Global: " . join('|',@exec_global_class) . "\n";
+    print " Local: " . join('|',@exec_local_class) . "\n";
+    
+    $total=0; foreach $i (@exec_class) { $total += $i ; }
+    $global=0; foreach $i (@exec_global_class) { $global += $i ; }
+    $local=0; foreach $i (@exec_local_class) { $local += $i ; }
+    
+    print " Sum of classes (should be " . $line_no . "): " . $total .
+	"   (global/local)=(" . $global . "/" . $local . ")\n";
+    print " Mean value: $mean_rt   Std dev: $std_dev_rt\n";
+    
+    print "\nPercentage of communication: \n";
+    print " Intervals: " . join('|',@comm_percs) . "\n";
+    print " Total: " . join('|',@comm_class) . "\n";
+    print " Global: " . join('|',@comm_global_class) . "\n";
+    print " Local: " . join('|',@comm_local_class) . "\n";
+    print " Values outside closed int: Total: " . $outside .
+	" Global: " . $outside_global . " Local: " . $outside_local . "\n";
+    
+    $total=0; foreach $i (@comm_class) { $total += $i ; }
+    $global=0; foreach $i (@comm_global_class) { $global += $i ; }
+    $local=0; foreach $i (@comm_local_class) { $local += $i ; }
+    
+    print " Sum of classes (should be " . $line_no . "): " . $total .
+	"   (global/local)=(" . $global . "/" . $local . ")\n";
+    print " Mean value: $mean_comm_perc   Std dev: $std_dev_comm_perc\n";
+    
+    print "\nSparked threads: \n";
+    print " Intervals:   " . join('|',@sparks) . "\n";
+    print " Total allocs: " . join('|',@spark_class) . "\n";
+    
+    $total=0; foreach $i (@spark_class) { $total += $i ; }
+
+    print " Sum of classes (should be " . $line_no . "): " . $total . "\n";
+    print " Mean value: $mean_spark   Std dev: $std_dev_spark\n";
+    
+    print "\nHeap Allcoations: \n";
+    print " Intervals:   " . join('|',@has) . "\n";
+    print " Total allocs: " . join('|',@ha_class) . "\n";
+    
+    $total=0; foreach $i (@ha_class) { $total += $i ; }
+    
+    print " Sum of classes (should be " . $line_no . "): " . $total . "\n";
+    print " Mean value: $mean_ha   Std dev: $std_dev_ha\n";
+    print "\n";
+    print "CORRELATION between runtimes and heap allocations: $c_exec_ha \n";
+    print "CORRELATION between runtime and no. of sparks:  $c_exec_sp \n";
+    print "CORRELATION between heap alloc and no. sparks:  $c_ha_sp \n";
+    print "CORRELATION between runtimes and locally sparked threads: $c_exec_lsp \n";
+    print "CORRELATION between runtimes and globally sparked threads: $c_exec_gsp \n";
+    print "CORRELATION between heap allocations and locally sparked threads: $c_ha_lsp \n";
+    print "CORRELATION between heap allocations and globally sparked threads: $c_ha_gsp \n";
+    print "CORRELATION between runtime and communication time:  $c_exec_ft\n";
+    print "CORRELATION between heap alloc and communication time:  $c_ha_ft\n";
+    print "CORRELATION between no. of local sparks and communication time:  $c_lsp_ft\n";
+    print "CORRELATION between no. of global sparks and communication time:  $c_gsp_ft\n";
+    print "\n";
+    
+}
+
+# ----------------------------------------------------------------------------
+# Old (obsolete) stuff
+# ----------------------------------------------------------------------------
+#
+#for ($index=0; 
+#     $index <= &list_max($#spark_local_class,$#spark_local_class); 
+#     $index++) {
+#    $spark_class[$index] = $spark_local_class[$index] + $spark_global_class[$index];
+#}
+#
+#for ($index=0, $sum_sp=0; 
+#     $index <= &list_max($#all_local_sparks,$#all_global_sparks); 
+#     $index++) {
+#    $all_sparks[$index] = $all_local_sparks[$index] + $all_global_sparks[$index];
+#    $sum_sp += $all_sparks[$index];
+#}
+#
+# ----------------------------------------------------------------------------
+#
+#sub compute_delta {
+#    local (@times) = @_;
+#
+#    return ($times[$#times] -  $times[$#times-1]);
+#}
+#
+# ----------------------------------------------------------------------------
+
+sub insert_elem {
+    local ($elem,$val,$n,*list1,*list2) = @_;
+    local (@small_part, $i, $len);
+
+    if ( $opt_D ) {
+	print "Inserting val $val (with elem $elem) in the following list: \n" .
+               @list . "\n yields the lists: \n  ";
+    }
+
+    for ($i=0; $i<=$#list2 && $list2[$i]>$val; $i++) { }
+    $len = $#list2 - $i + 1;
+    if ( $len == 0 ) {
+	push(@list1,$elem);
+	push(@list2,$val);
+    } else {
+	splice(@list1,$i,0,$elem);
+	splice(@list2,$i,0,$val);
+    }
+
+    if ( $opt_D ) {
+	print @list1 . "\n and \n" . @list2;
+    }
+
+}
+
+# ----------------------------------------------------------------------------
+
+sub skip_header {
+    local ($in_header);
+
+    $in_header = 9;
+    while (<INPUT>) {
+	if ( $in_header = 9 ) {
+	    if (/^=/) {
+		$gum_style_gr = 1;
+		$in_header = 0;
+		$prg = "????";		# 
+		$pars = "-b??????";		# 
+		$nPEs =  1; # 
+		$lat =  1;
+		return ($prg, $pars, $nPEs, $lat);
+	    } else {
+		$gum_style_gr = 0;
+		$in_header = 1;
+	    }
+	    
+	}
+	$prg = $1, $pars = $2  if /^Granularity Simulation for\s+(\w+)\s+(.*)$/;
+	$nPEs = $1	       if /^PEs\s+(\d+)/;
+	$lat = $1, $fetch = $2 if /^Latency\s+(\d+)[^F]+Fetch\s+(\d+)/;
+
+	last             if /^\+\+\+\+\+/;
+    }
+}
+
+# ----------------------------------------------------------------------------
+
+sub write_pie_chart {
+    local ($rt_perc, $bt_perc, $ft_perc, $it_perc);
+    local ($title, $title_sz, $label_sz, $x_center, $y_center, $radius); 
+
+    $PieChart = "/users/fp/hwloidl/grasp/GrAn/bin/PieChart.ps";
+
+    $title = "Original Glaswegian Communication Pie (tm)";
+    $title_sz = 24;
+    $label_sz = 12;
+    $x_center = 300; 
+    $y_center = 400;
+    $radius = 100;
+
+    open(PIE,">$pie_file_name") || die "$pie_file_name: $!";
+    
+    print PIE "%!PS-Adobe-2.0\n";
+    print PIE "%%Title: Pie Chart\n";
+    print PIE "%%Creator: gran-extr\n";
+    print PIE "%%CreationDate: Ides of March 44 B.C.\n";
+    print PIE "%%EndComments\n";
+    print PIE "\n";
+    print PIE "% Def of PieChart is taken from:\n";
+    print PIE "% ($PieChart) run\n";
+    print PIE "\n";
+
+    open(PIE_CHART,"<$PieChart") || die "$PieChart: $!";
+    while (<PIE_CHART>){
+	print PIE $_;
+    }
+    close (PIE_CHART);
+    print PIE "\n";
+
+    $rt_perc = $tot_rt / $tot_total_rt;
+    $bt_perc = $tot_bt / $tot_total_rt;
+    $ft_perc = $tot_ft / $tot_total_rt;
+    $it_perc = $tot_it / $tot_total_rt;
+
+    print PIE "($title) $title_sz $label_sz  % Title, title size and label size\n" .
+	      "[                     % PS Array of (descrition, percentage [0, .., 1])\n" .
+	      "[(Run Time) $rt_perc]\n" .
+	      "[(Block Time) $bt_perc]\n" .
+	      "[(Fetch Time) $ft_perc]\n" .
+	      "[(Ready Time) $it_perc]\n" .
+	      "] $x_center $y_center $radius DrawPieChart\n";
+    print PIE "showpage\n";
+
+    close(PIE);
+}
+
+# ----------------------------------------------------------------------------
+
+sub basename {
+    local ($in_str) = @_;
+    local ($str,$i) ;
+
+    $i = rindex($in_str,"/");
+    if ($i == -1) {
+	$str = $in_str;
+    } else {
+	$str = substr($in_str,$i+1) ;
+    }
+
+    return $str;
+}
+
+# ----------------------------------------------------------------------------
+
+sub dirname {
+    local ($in_str) = @_;
+    local ($str,$i) ;
+
+    $i = rindex($in_str,"/");
+    if ($i == -1) {
+	$str = "";
+    } else {
+	$str = substr($in_str,0,$i+1) ;
+    }
+
+    return $str;
+}
+
+# ----------------------------------------------------------------------------
+