# The contents of this file are subject to the Netscape Public
# License Version 1.1 (the "License"); you may not use this file
# except in compliance with the License. You may obtain a copy of
# the License at http://www.mozilla.org/NPL/
# 
# Software distributed under the License is distributed on an "AS
# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
# implied. See the License for the specific language governing
# rights and limitations under the License.
# 
# The Original Code is the Netscape Mailstone utility, 
# released March 17, 2000.
# 
# The Initial Developer of the Original Code is Netscape
# Communications Corporation. Portions created by Netscape are
# Copyright (C) 1997-2000 Netscape Communications Corporation. All
# Rights Reserved.
# 
# Contributor(s):	Dan Christian <robodan@netscape.com>
#			Marcel DePaolis <marcel@netcape.com>
# 
# Alternatively, the contents of this file may be used under the
# terms of the GNU Public License (the "GPL"), in which case the
# provisions of the GPL are applicable instead of those above.
# If you wish to allow use of your version of this file only
# under the terms of the GPL and not to allow others to use your
# version of this file under the NPL, indicate your decision by
# deleting the provisions above and replace them with the notice
# and other provisions required by the GPL.  If you do not delete
# the provisions above, a recipient may use your version of this
# file under either the NPL or the GPL.
#####################################################

# for each protocol, store rate over time (figure derivative), and final count
# commands
# readMessages
# writeMessages
# readBytes
# writeBytes
# connections
# these are already 0 based over time, and average
# connectDelay
# transactionTime

#require "perl-5.005";

#use Cwd;

print "Combining client results:\t", scalar (localtime), "\n";

# Basic sanity check
unless ($testsecs > 0) {
    die "Test time is 0!\n";
}

$startTime = 0;			# these are timeInSeconds/$timeStep
$endTime = 0;

# keep graphs with somewhat more precision than sample rate
# this is supposed to help deal with time skew between clients
#$timeStep = int ($params{FREQUENCY} / 2);
#if ($timeStep < 1) { $timeStep = 1; }
$timeStep = int ($params{FREQUENCY});

# global results initialization
$reportingClients = 0;
$totalProcs = 0;		# number of clients started

my $maxTimeStep = $params{FREQUENCY}*2;
$maxTimeStep = 10 if ($maxTimeStep < 10);


# Fill in graph values
# Usage: updateGraph (graph, lastTimeStep, TimeStep, timeSecs,
#	lastValue, value);
sub updateGraph {
    #SLOW: my ($gp, $lastTime, $time, $timeD, $lastValue, $value) = @_;
    my $gp = shift;		# gp: graph hash to fill in over time
    my $lastTime = shift;	# lastTime: time values (already divided by timestep)
    my $time = shift;
    my $timeD = shift;		# timeD: time delta in seconds
    my $lastValue = shift;
    my $value = shift;
    return unless ($timeD);	# initial case

    #print "updateGraph: time='$time' timeD='$timeD' lastValue='$lastValue' value='$value'\n";
    my $v = ($value - $lastValue) / $timeD; # figure update / step
    for ($i = $lastTime; $i < $time; $i++) { # fill in graph
	$gp->{$i} += $v;
    }
}

# Fill in graph values, figuring the MIN
# Usage: updateMinGraph (graph, lastTimeStep, TimeStep, value);
sub updateMinGraph {
    my $gp = shift;		# graph hash to fill in over time
    my $lastTime = shift;	# time values (already divided by timestep)
    my $time = shift;
    my $v = shift;
    return unless ($lastTime);	# initial case
    return unless ($v > 0);		# 0 min is considered no information

    #print "updateMinGraph: time='$time' lastTime='$lastTime' value='$v'\n";
    for ($i = $lastTime; $i < $time; $i++) { # fill in graph
	$gp->{$i} = $v if (!($gp->{$i}));
	$gp->{$i} = $v if ($v < $gp->{$i});
    }
}

# Fill in graph values, figuring the MAX
# Usage: updateMaxGraph (graph, lastTimeStep, TimeStep, value);
sub updateMaxGraph {
    my $gp = shift;		# graph hash to fill in over time
    my $lastTime = shift;	# time values (already divided by timestep)
    my $time = shift;
    my $v = shift;
    return unless ($lastTime);	# initial case

    #print "updateMaxGraph: time='$time' lastTime='$lastTime' value='$v'\n";
    for ($i = $lastTime; $i < $time; $i++) { # fill in graph
	$gp->{$i} = $v if (!($gp->{$i}));
	$gp->{$i} = $v if ($v > $gp->{$i});
    }
}

# Turn one of the disadvantages of interpreted code to an advantage
#  by writing optimal code on the fly.  
#  You must be taller than Kenny the kangaroo to edit this code.
# Create a function that will parse timers (all timer must be identical)
# Timer are built out of positional assignments (not attr=value pairs)
sub CreateFastTimerParser {
    my $ltype = shift;		# hash of line parsing info
    my $fstr = shift;		# format string
    
    my @tlist = @{$ltype->{"$fstr:SEPS"}};
    my @nlist = @{$ltype->{"$fstr:NAMES"}};
	
				# function preamble
    my $fn = "sub FastTimerParser {\n";

    $fn .= 'my $sc = shift; my $gp = shift;
    my $lt = shift; my $t = shift; my $td = shift;
    my $ltype = shift; my $fstr = shift;
    my $ln = shift;' . "\n";

    #$fn .= 'print "(fastTimerParser) $fstr $lt $t $td\n";' . "\n";
    $fn .= 'if ($ln =~ m/^';

    foreach $s (@tlist) {	# write pattern match
	$fn .= "(.+)$s";
    }
    $fn .= '(.+)$/) {' . "\n";		# last field in match
    #$fn .= 'print "$ln =\t$1 + $2 / $3 + $4 / $5 [ $6 , $7 ] $8\n";' . "\n";

    my $n = 0;
    foreach $v (@nlist) {		# write update calls
	$n++;
	if ($v =~ /Min$/) {
	    $fn .= 'updateMinGraph ($gp->{"' . $v . '"}, $lt, $t, $' . $n . ");\n";
	    # Handle never defined case first.
	    $fn .= '$sc->{"' . $v . '"} = 0 if (!($sc->{"' . $v . '"}));' . "\n";
	    # Do the Min update. 0 is not a valid number
	    $fn .= '$sc->{"' . $v . '"} = $' . $n . ' if (($' . $n . ' > 0) && (($sc->{"' . $v . '"} == 0) || ($' . $n . ' < $sc->{"' . $v . '"})));' . "\n";
	} elsif ($v =~ /Max$/) {
	    $fn .= 'updateMaxGraph ($gp->{"' . $v . '"}, $lt, $t, $' . $n . ");\n";
	    $fn .= '$sc->{"' . $v . '"} = $' . $n . ' if (!($sc->{"' . $v . '"}) || ($' . $n . ' > $sc->{"' . $v . '"}));' . "\n";
	} else {
	    $fn .= 'updateGraph ($gp->{"' . $v . '"}, $lt, $t, $td, $sc->{"' . $v . '"}, $' . $n . ");\n";
	    $fn .= '$sc->{"' . $v . '"} = $' . $n . ";\n";
	}
    }
    $fn .= "\n} else {\n";
    $fn .= 'die "Error parsing timer from: $ln\n";';
    $fn .= "\n}\n}\n";
    #($params{DEBUG}) && print "Created timer parse function: $fn\n";
    eval $fn;			# create the function
    $timerParser = \&FastTimerParser;
}
# All this quoted stuff will screw up Emacs' formatter/colorizer.  Oh well.

# Similar to above.
# This seems to be a smaller gain (about 10%) than the timers.
sub CreateFastProtocolParser {
    my $ltype = shift;		# hash of line parsing info
    my $fstr = shift;		# format string

    my @tlist = @{$ltype->{"$fstr:SEPS"}};
    my @nlist = @{$lst = $ltype->{"$fstr:NAMES"}};

    #print "CreateFastProtocolParser: $fstr\n";

    my $nm = $fstr;
    $nm =~ s/^.*://;
    my $fn = "sub FastProtocolParser$nm {\n";
    $fn .= 'my $sc = shift; my $gp = shift;
    my $lt = shift; my $t = shift; my $td = shift;
    my $ltype = shift; my $fstr = shift;
    my $ln = shift;' . "\n";

    #$fn .= 'print "(FastProtocolParser' . $nm . ' ) $fstr $lt $t $td\n";' . "\n";
    $fn .= 'if ($ln =~ m/^';
    my $posttext = pop @tlist;	# save last bit of text
    foreach $s (@tlist) {	# write pattern match
	$fn .= "$s(.+)";
    }
    $fn .= $posttext . '$/) {' . "\n"; # last text in match
    my $n = 0;
    foreach $v (@nlist) {	# write update calls
	$n++;
	if ($v =~ m/^\[(.+)\]$/) { # timer
	    $fn .= 'FastTimerParser ($sc->{"' . $1 . '"}, $gp->{"' . $1 . '"}, $lt, $t, $td, $ltype, "TIMERS:' . $1 . '", $' . $n . ');' . "\n";
	} else {		# direct assignment
	    $fn .= 'updateGraph ($gp->{"' . $v . '"}, $lt, $t, $td, $sc->{"' . $v . '"}, $' . $n . ');' . "\n";
	    $fn .= '$sc->{"' . $v . '"} = $' . $n . ";\n";
	}
    }
    $fn .= "\n} else {\n";
    $fn .= 'die "Error parsing protocol ' . $nm . ' from: $ln\n";';
    $fn .= "\n}\n}\n";
    $fn .= '$cliLines{"SUMMARY-TIME"}->{"' . $fstr . ':PROTOPARSE"} = \&FastProtocolParser' . $nm . ";\n";
    #print "Created proto parse function: $fn\n";
    eval $fn;			# create the function
}

# This is the slow verson of timer parsing.  Kept for possible debugging
# There are only 4 levels to the parse hierarchy: line, protocol, timer, value
# each level consists of 1 or more elements from lower levels, plus text

# Given a timer format description, break string into name,value chunks 
# Timer are built out of positional assignments (not attr=value pairs)
# Usage: parseTimer (...lineHash, format, line)
sub parseTimer {
    my $subcli = shift;		# client hash to update
    my $gp = shift;		# graph hash to fill in over time
    my $lastTime = shift;	# time values (already divided by timestep)
    my $time = shift;
    my $timeD = shift;
    my $ltype = shift;		# hash of line parsing info
    my $fstr = shift;		# format string
    my $line = shift		# text line
	|| die "Missing arguments to parseTimer";
    
    my @tlist = @{$ltype->{"$fstr:SEPS"}};
    my @nlist = @{$lst = $ltype->{"$fstr:NAMES"}};
    #print "\nTimer seps ($fstr): @tlist\nNames: @nlist\n";

    my $remln = $line;
	
    while (@nlist) {
	my $chunk;
	my $sepln;
	my $posttext = shift @tlist;
	my $vname = shift @nlist;

	if ($posttext) {	# remln looks like <value><literal text>...
	    ($chunk, ($sepln), $remln) = split /($posttext)/, $remln, 2;
	    #print "chunk='$chunk' sep='$sepln' remln='$remln'\n";
	    die "Error finding string '$posttext' in '$remln' of '$line'"
		unless ($sepln);
	} else {		# remln looks like <value>
	    $chunk = $remln;
	}
	#print "$vname=$chunk ";
	die "updateGraph: Missing graph '$vname'\n" unless ($gp->{$vname});
	if ($vname =~ /Min$/) {
	    updateMinGraph ($gp->{$vname}, $lastTime, $time, $chunk);
	} elsif ($vname =~ /Max$/) {
	    updateMaxGraph ($gp->{$vname}, $lastTime, $time, $chunk);
	} else {
	    updateGraph ($gp->{$vname}, $lastTime, $time, $timeD,
				$subcli->{$vname}, $chunk);
	}
	$subcli->{$vname} = $chunk;
    }
    #print "\n";
}

# This is the slow verson of protocol parsing.  Kept for possible debugging
# Given a format description, break string into name,value chunks 
# Very similar to parseLine, except: no sub protocols, no top level issues
# Usage: parseProtocol (...lineHash, format, line)
sub parseProtocol {
    my $subcli = shift;	# client hash to update
    my $gp = shift;		# graph hash to fill in over time
    my $lastTime = shift;	# time values (already divided by timestep)
    my $time = shift;
    my $timeD = shift;
    my $ltype = shift;		# hash of line parsing info
    my $fstr = shift;		# format string
    my $line = shift		# text line
	|| die "Missing arguments to parseProtocol";

    #print "\nparseProtocol format='$fstr' line='$line'\n";
    
    my @tlist = @{$ltype->{"$fstr:SEPS"}};
    my @nlist = @{$lst = $ltype->{"$fstr:NAMES"}};
    #print "\nProtocol seps ($fstr): @tlist\nNames: @nlist\n";

    # remove first part of literal text
    my $posttext = shift @tlist;
    my ($chunk, $sepln, $remln) = split /($posttext)/, $line, 2;
    die "Error parsing initial string '$posttext' from '$line'"
	unless ($sepln);
	
    # progressively split $fstr into literal chunks
    # back to back timers or protocols (with no literal space) is not allowed
    while (@nlist) {
	# remln always looks like <value><literal text>
	my $vname = shift @nlist;
	$posttext = shift @tlist;
	#print "posttext='$posttext'\n";

	($chunk, ($sepln), $remln) = split /($posttext)/, $remln, 2;
	#print "chunk='$chunk'\n";
	#print "remln=$remln\n\n";
	die "Error finding string '$posttext' in '$remln'"
	    unless ($sepln);

	if ($vname =~ m/^\[(.+)\]$/) { # timer
	    #print "TIMER $vname ";
	    die "Unknown timer referenced: $vname for client "
		. $scalar{"client"} . "\n"
		unless ($subcli->{$1});
	    die "Invalid timer specified: $ltype->{TIMERS}->{$vname} in '$line'"
		unless ($ltype->{TIMERS}->{$vname});
	    FastTimerParser ($subcli->{$1}, $gp->{$1},
			$lastTime, $time, $timeD,
			$ltype, "TIMERS:$1", $chunk);
	} else {		# direct assignment
	    #print "$vname='$chunk' ";
	    die "updateGraph: Missing graph '$vname'\n" unless ($gp->{$vname});
	    updateGraph ($gp->{$vname}, $lastTime, $time, $timeD,
				$subcli->{$vname}, $chunk);
	    $subcli->{$vname} = $chunk;
	}
    }
    #print "\n";
}

# Given a format description, break string into name,value chunks 
# Figures out all the top level issues of:
#	Figure out what client, what time span,
#	Pass down top level structures
#	Do final special processing (connections graph)
# Usage: parseLine (clientsHash, lineHash, format, line)
sub parseLine {
    my $clients = shift;	# hash of all clients
    my $ltype = shift;		# hash of line parsing info
    my $fstr = shift;		# format string to match
    my $line = shift		# line to parse up
	|| die "Missing arguments to parseLine";
    #print "parseLine: $line\n"; # format='$fstr' 

    my %scalar = ();		# hold scalars until client storage located
    my $subcli;			# client hash to update ($clients->{$n})
    my $lastTime;		# time values (already divided by timestep)
    my $time;
    my $timeD;			# time delta (in seconds)

    my @tlist = @{$ltype->{"$fstr:SEPS"}};
    my @nlist = @{$lst = $ltype->{"$fstr:NAMES"}};
    #print "\nLine seps ($fstr): @tlist\nNames: @nlist\n";

    # remove first part of literal text
    # This should always work, since we pattern matched on this to get here
    my $posttext = shift @tlist;
    my $vname;
    #print "posttext='$posttext'";
    my ($chunk, $sepln, $remln) = split /($posttext)/, $line, 2;
    die "Error parsing initial string '$posttext' from '$line'"
	unless ($sepln);
	
    # progressively split $fstr into literal chunks
    while (@nlist) {
	# remln always looks like <value><literal text>
	$vname = shift @nlist;
	$posttext = shift @tlist;
	#print "\nposttext='$posttext' vname='$vname'\n";

	($chunk, ($sepln), $remln) = split /($posttext)/, $remln, 2;
	#print "chunk='$chunk'\n";
	#print "remln=$remln\n\n";
	die "Error finding string '$posttext' in '$remln'"
	    unless ($sepln);

	if (($vname =~ m/^\[.+\]$/)
	    || ($vname =~ m/^\{.+\}$/)){		# timer or hash

	    unless ($subcli) {	# setup sub client 
		$subcli = $clients->{$scalar{"client"}};
		die "Error parsing client number $scalar{client}"
		    unless ($subcli);
		die "Unknown client referenced: $scalar{client}\n"
		    unless ($subcli);
		$time = $scalar{"time"};
		if ($subcli->{"time"}) {
		    $lastTime = $subcli->{"time"};
		    $timeD = $time - $lastTime; # seconds (not steps)
		    $lastTime = int ($lastTime / $timeStep); # to timesteps
		    if (0 == $timeD) { # final summary case
			$timeD = 1;
			#print "Final update client=$n time=$time\n";
			$time += 1; # so 1 data point gets updated
		    }
		} else {	# first time report
		    $subcli->{"startTime"} = $time;
		    $lastTime = 0;
		    $timeD = 0;	# no time update
		}
		$time = int ($time / $timeStep); # convert to timesteps

		# now store the scalars we have already seen
		#print "(";
		foreach $k (keys %scalar) {
		    #print "$k=$scalar{$k} ";
		    $subcli->{$k} = $scalar{$k};
		    # Dont bother with time graphs here
		}
		#print ") ";
	    }

	    if ($vname =~ m/^\[(.+)\]$/) { # timer
		#print "TIMER $vname '$chunk'\n";
		die "Unknown timer referenced: $vname for client $scalar{client}\n"
		    unless ($subcli->{$1});
		die "Invalid timer specified: $ltype->{TIMERS}->{$vname}"
		    unless ($ltype->{TIMERS}->{$vname});
		FastTimerParser ($subcli->{$1}, $graphs{$1},
			    $lastTime, $time, $timeD,
			    $ltype, "TIMERS:$1", $chunk);
	    } elsif ($vname =~ m/^\{(.+)\}$/) { # protocol
		#print "PROTOCOL $vname '$chunk'\n";
		die "Unknown protocol referenced: $vname for client $scalar{client}\n"
		    unless ($subcli->{$1});
		die "Invalid protocol specified: $ltype->{PROTOCOLS}->{$1}"
		    unless ($ltype->{PROTOCOLS}->{$vname});
		
		#parseProtocol
		&{$ltype->{"PROTOCOLS:$1:PROTOPARSE"}}
		($subcli->{$1}, $graphs{$1},
		 $lastTime, $time, $timeD,
		 $ltype, "PROTOCOLS:$1", $chunk);
	    } else {
		die "parseLine: Unkown separator $posttext\n";
	    }
	} else {		# direct assignment
	    # Note: we dont graph any scalars at the line level
	    #print "$vname='$chunk'\n";
	    $scalar{$vname} = $chunk; # store for later
	    $subcli->{$k} = $chunk if ($subcli);
	} 
    }
    #print "\n";

    return unless ($timeD);	# skip rest if first sample

    # Now do post processing based on the updated $subcli
    foreach $prot (@protocols) { # figure concurrent connections
	next unless ($subcli->{$prot});
	my $pcli = $subcli->{$prot};
	next unless (($pcli->{"conn"}) && ($pcli->{"conn"}->{"Try"}));

	my $connD = $pcli->{"conn"}->{"Try"}; # connections minus logouts
	$connD += $pcli->{"reconn"}->{"Try"} if ($pcli->{"reconn"});
	$connD -= $pcli->{"logout"}->{"Try"};

	$connD -= $pcli->{"total"}->{"Error"}; # subtract sum of errors
	# foreach $k (keys %$pcli) { # subtract errors (which force close)
	# ($k =~ /total/) && next;
	# $connD -= $pcli->{$k}->{"Error"};
	# }

	#print "DERIVED connections {$prot}\n";
	die "updateGraph: Missing graph 'connections'\n"
	    unless ($graphs{$prot}->{"connections"});
	# pass timeD as 1 to avoid time scaling
	updateGraph ($graphs{$prot}->{"connections"},
		     $lastTime, $time, 1, 0, $connD);
    }
}

# Walk a format description (recursively)
# Usage: walkFormatValues (clientHash, formatHash, "LINE", evalExpr)
# Eval expression is call as follows:
#	value in $a
#	field name in $f
#	field path in $p
sub walkFormatValues {
    my $cli = shift;	# hash of all clients
    my $ltype = shift;		# hash of line parsing info
    my $fstr = shift;		# format string to match
    my $doit = shift;		# routine to call
    my $p = shift;		# path to variable (may be empty)
    #print "walkFormatValues ($fstr):  extra: @_\n" if (@_);

    my @nlist = @{$ltype->{"$fstr:NAMES"}};
    #print "walkFormatValues ($fstr):  @nlist";

    if ($p) {			# initialize path
	$p .= ":";
    } else {
	$p = "";
    }

    while (@nlist) {
	my $f = shift @nlist;	# get field name

	if ($f =~ m/^\[(.+)\]$/) { # timer
	    #print "Timer $f:\n";
	    die "Unknown timer referenced: $f for client $scalar{client}\n"
		unless ($cli->{$1});
	    die "Invalid timer specified: $ltype->{TIMERS}->{$f}"
		unless ($ltype->{TIMERS}->{$f});
	    walkFormatValues ($cli->{$1}, $ltype, "TIMERS:$1",
			      $doit, "$p$1", @_);
	} elsif ($f =~ m/^\{(.+)\}$/) { # protocol
	    #print "Protocol $f:\n";
	    die "Unknown protocol referenced: $f for client $scalar{client}\n"
		unless ($cli->{$1});
	    die "Invalid protocol specified: $ltype->{PROTOCOLS}->{$1}"
		unless ($ltype->{PROTOCOLS}->{$f});
	    walkFormatValues ($cli->{$1}, $ltype, "PROTOCOLS:$1",
			      $doit, "$p$1", @_);
	} else {		# direct assignment
	    #print "$p$f=$a ";
	    #too slow???: eval $doit;
	    &$doit ($cli->{$f}, $f, $p, @_);
	} 
    }
    #print "\n";
}

# Given a timer format description, break string into name,value chunks 
# Usage: allocTimer (clientsHash, graphHash, lineHash, format)
sub allocTimerStorage {
    my $clients = shift;	# hash of this client
    my $graphs = shift;		# hash of graphs
    my $ltype = shift;		# hash of line parsing info
    my $fstr = shift;		# format string to match
    my $sepstr = shift;		# seperator storage to fill in

    #print "parseTimer: format='$fstr'\n\tline='$line'\n";
    my $sepf;
    my $remf = $fstr;
    my $chunk;
    my $sepln;
    my $remln = $line;
    my $vname;
    my @tlist = ();		# list of text tokens
    my @nlist = ();		# list of names

    # progressively split $fstr into literal chunks
    while ($remf) {
	# remf always looks like <tag><literal text>...
	($vname, $sepf, $remf) = split /([][()+\/\,;:|])/, $remf, 2;

	if ($remf) {		# remln looks like <value><literal text>...
	    $sepf =~ s/([][{}*+?^.\/])/\\$1/g; # quote regex syntax
#	    push @tlist, qr/$sepf/; # store compiled match expression
	    push @tlist, $sepf;
	} else {		# remln looks like <value>
	    $chunk = $remln;
	}
	push @nlist, $vname;
	#print "vname='$vname' sep='$sepf'\n";
	unless ($graphs->{$vname}) {
	    #print "$vname ";
	    # This hash that will hold the actual values over time
	    $graphs->{$vname} = ArrayInstance->new();
	}
    }
    #print "Timer sep list: @tlist.  Names: @nlist\n";
    $ltype->{"$sepstr:SEPS"} = \@tlist;
    $ltype->{"$sepstr:NAMES"} = \@nlist;
    CreateFastTimerParser ($ltype, $sepstr) unless ($timerParser);
    # SIDE EFFECT: updates timerFieldsAll
    @timerFieldsAll = @nlist unless (@timerFieldsAll);
}

# Walk a format discription and create storage hierarchy
# Also creates the seperator and field names lists used everywhere else
# 	Some way to precompile the regular expressions (perl 5.005)?
# Usage: allocStorage (clientsHash, graphHash, lineHash, format, "LINE")
sub allocStorage {
    my $clients = shift;	# hash of this client
    my $graphs = shift;		# hash of graphs
    my $ltype = shift;		# hash of line parsing info
    my $fstr = shift;		# format string to match
    my $sepstr = shift;		# seperator storage to fill in
    #print "\nallocStorage format='$fstr'\n";

    my @tlist = ();		# list of text tokens
    my @nlist = ();		# list of name tokens
    # remove first part of literal text
    my ($posttext, $sepf, $remf) = split /([=\{\[])/, $fstr, 2;
    my $nexttext = $posttext . $sepf;
    $posttext .= $sepf if ($sepf =~ m/=/);	# should always happen?
    push @tlist, $posttext;	# store initial text too

    # progressively split $fstr
    my $vname;
    while ($remf) {
	my $lasttext = $nexttext; # last literal text goes with this $vname

	# Get the variable name
	# remf always looks like <tag><literal text>
	#$remf =~ s/^(\w+)//; $vname = $1; # strip value text off line
	($vname, $sepf, $remf) = split /([^\w])/, $remf, 2; # get value text
	unless ($vname) {	# got =[ or ={, go again.
	    #print "+$sepf ";
	    $nexttext .= $sepf;
	    next;
	}
	
	$remf = $sepf . $remf	# put seperator back in to remainder
	    unless ($sepf  =~ /[\]\}]/); # unless after a timer/proto name
	#print "vname='$vname'\n";

	# now get the next bit of literal text
	($posttext, $sepf, $remf) = split /([][={}])/, $remf, 2;
	$nexttext = $posttext . $sepf if ($remf); # unless end of line

	if (($sepf) && ($sepf =~ m/=/)) { # direct assignment
	    $posttext .= $sepf;	# this is part of literal text
	}
	$posttext =~ s/([][{}*+?^.\/])/\\$1/g; # quote regex syntax
	#print "`$lasttext' ";	# this shows some trailing cruft, oops
	#print "remf='$remf'\n";
#	push @tlist, qr/$posttext/;	# save seperator text
	push @tlist, $posttext;	# save seperator text

	if ($lasttext =~ m/[][]/) { # timer
	    #print "[$vname] ";
	    push @nlist, "[$vname]"; # save field name as timer
	    my $nm = "[$vname]";
	    die "Invalid timer specified: $vname in '$fstr'"
		unless ($ltype->{TIMERS}->{$nm});
	    $clients->{$vname} = ArrayInstance->new(); # create sub hash

	    unless ($graphs->{$vname}) { # create graph
		#print "Creating timer graph '$vname':  ";
		$graphs->{$vname} = ArrayInstance->new();
	    } else {
		#print "Timer graph '$vname' already exists.";
	    }
	    allocTimerStorage ($clients->{$vname}, $graphs->{$vname},
			       $ltype,
			       $ltype->{TIMERS}->{$nm}, "TIMERS:$vname");
	    #print "\n"
	} elsif ($lasttext =~ m/[{}]/) { # protocol
	    #print "{$vname}\n";
	    push @nlist, "{$vname}"; # save field name as protocol
	    my $nm = "{$vname}";
	    $clients->{$vname} = ArrayInstance->new(); # create sub hash
	    die "Invalid protocol specified: $vname"
		unless ($ltype->{PROTOCOLS}->{$nm});
	    unless ($graphs->{$vname}) { # create graph protocol
		#print "Creating graph protocol '$vname'\n";
		$graphs->{$vname} = ArrayInstance->new();
				# create generated scalar fields
		$graphs->{$vname}->{"connections"} = ArrayInstance->new();
	    }
	    # recurse into protocol definition
	    # this would allow recursive protocols, 
	    #   but this isnt supported elsewhere
	    allocStorage ($clients->{$vname}, $graphs->{$vname},
			  $ltype,
			  $ltype->{PROTOCOLS}->{$nm}, "PROTOCOLS:$vname");

	    # SIDE EFFECT: updates protocolFields
	    unless ($protocolFields{$vname}) {
		my $lst = $ltype->{"PROTOCOLS:$vname:NAMES"};
		$protocolFields{$vname} = $lst;
		#print "$vname fields: @{$lst}\n"; # DEBUG
	    }
	    CreateFastProtocolParser ($ltype, "PROTOCOLS:$vname")
		unless ($cliLines{"SUMMARY-TIME"}->{"PROTOCOLS:$vname:PROTOPARSE"});
	}  elsif ($lasttext =~ m/=/) { # direct assignment
	    #print "$vname ";
	    push @nlist, $vname;	# save field name
	    #$clients->{$vname} = 0; # preset scalar field
	    unless ($graphs->{$vname}) { # create graph
		#print "Creating value graph '$vname'\n";
		$graphs->{$vname} = ArrayInstance->new();
	    }
	} else {
	    die "Got lost parsing $fstr\n";
	}
    }
    #print "Line/proto sep list: @tlist\nNames: @nlist\n";
    $ltype->{"$sepstr:SEPS"} = \@tlist;
    $ltype->{"$sepstr:NAMES"} = \@nlist;
}

# These are helper routines to be called by walkFormatValues
# Each gets called at each format node with value, field name, field path
sub walkShowVar {
    my $a = shift; my $f = shift; my $p = shift;
    print CSV "$p$f,";
}
sub walkShowName {
    my $a = shift;
    print CSV "$a,";
}
sub walkCreateFinals {
    my $a = shift; my $f = shift; my $p = shift;
    
    if ($p =~ /(\w+):(\w+):$/) {
	$finals{$1}->{$2}= ArrayInstance->new() unless ($finals{$1}->{$2});
    }
} 
# Add up client data to form total data
sub walkTotalFinals {
    my $a = shift; my $f = shift; my $p = shift;
    if ($p =~ /(\w+):(\w+):$/) { # sub arrray case
	my $pr = $1; my $tm = $2;
	if (!($finals{$pr}->{$tm}->{$f})) { # first assignment
	    $finals{$pr}->{$tm}->{$f} = $a;
	} elsif ($f =~ /Min$/) { # take the new MIN
	    $finals{$pr}->{$tm}->{$f} = $a
		if (($a > 0.0) && ($a < $finals{$pr}->{$tm}->{$f}));
	} elsif ($f =~ /Max$/) { # take the new MAX
	    $finals{$pr}->{$tm}->{$f} = $a if ($a > $finals{$pr}->{$tm}->{$f});
	} else {		# simple sum
	    $finals{$pr}->{$tm}->{$f} += $a;
	}
    } elsif ($p =~ /(\w+):$/) {	# scalar case, simple sum
	$finals{$1}->{$f} += $a;
    }
}

				# Since all timers must be the same
#@timerFieldsAll		# names of all timer fields (in order)
%protocolFields = ();		# protocol as key, hash of lists of fields

# This is where the raw data files get read in.
foreach $section (@workload) {
    next unless ($section->{sectionTitle} =~ /CLIENT/o);
    next unless ($section->{PROCESSES}); # unused client

    my $slist = $section->{sectionParams};
    $slist =~ s/HOSTS=\s*//; # strip off initial bit
    foreach $cli (split /[\s,]/, $slist) {
	my $clientfile= getClientFilename ($cli, $section);
	# open the output from this child
	open(CLIENTDATA, "<$clientfile") || 
	    open(CLIENTDATA, "gunzip -c $clientfile.gz |") || 
		warn "Couldn't open $clientfile:$!\n";

	# start writing clients.csv file 
	fileBackup ("$resultdir/client-$cli.csv");
	open(CSV, ">$resultdir/clients-$cli.csv") # Summary of all clients
	    || die "Could not open $resultdir/client-$cli.csv: $!\n";

	($params{DEBUG}) && print "Processing $clientfile\n";
	($params{DEBUG}) && print "\tInput start:\t", scalar (localtime), "\n";
	my $numThisClient=0;
	my $linesThisClient=0;
	my $skippedLines=0;
	my $summaryLines=0;
	my $noticeLines=0;

	%cliLines = ();		# line_name as key, hash of info fields
	my %clidata = ();	# clear client data store

	my $cliTimers = ArrayInstance->new(); # timer, format pairs
	my $cliProtocols = ArrayInstance->new(); # protocol, format pairs


	# read through, looking for connections and throughput over time
	RAWLINE: while (<CLIENTDATA>) {
	    $linesThisClient++;

	    if (/^<FORMAT client=/) { # FORMAT definition
		#print "FORMAT (raw) $_\n";
		s/<\/FORMAT>\s*$//; # strip close format and newline
		s/"//;		# strip quotes (Fix emacs) "
		my ($element, $value) = split />/, $_, 2;
		$element =~ s/^<FORMAT //; # strip initial part
		my ($clipair, $typepair) = split /\s/, $element;
		my ($clijunk, $clinum) = split /=/, $clipair;
		my ($type, $label) = split /=/, $typepair;

		if ($type =~ /TIMER/) {
		    unless ($cliTimers->{$label}) { # already exists
			$cliTimers->{$label} = $value;
			($params{DEBUG}) &&
			    print "TIMER $label, $value\n";
			#print CSV "<FORMAT client=$clinum TIMER=$label>$value</FORMAT>\n";
		    }
		} elsif ($type =~ /PROTOCOL/) {
		    unless ($cliProtocols->{$label}) {
			$cliProtocols->{$label} = $value;
			($params{DEBUG}) &&
			    print "PROTOCOL $label, $value\n";
			#print CSV "<FORMAT client=$clinum PROTOCOL=$label>$value</FORMAT>\n";
		    }
		} elsif ($type =~ /LINE/) {
		    # Note: Line types ($label) must be unique

		    unless ($cliLines{$label}) { # already seen
			my ($spat) = split /=/, $value;
			$spat = "^$spat=";

			($params{DEBUG}) &&
			    print "LINE/$spat/ $value\n";

			#print "LINE short pattern '^$spat='\n";
			# Store all the information about parsing this line
			$cliLines{$label} = ArrayInstance->new();
			$cliLines{$label}->{LINE} = $value;
			# $cliLines{$label}->{PATTERN} = qr/^$spat/;
			$cliLines{$label}->{PATTERN} = "^$spat";
			$cliLines{$label}->{TIMERS} = $cliTimers;
			$cliLines{$label}->{PROTOCOLS} = $cliProtocols;
			#print CSV "<FORMAT client=$clinum LINE=$label>$value</FORMAT>\n";
		    } else {
			#print "Skipping already seen line: $label $value\n";
		    }

		    # Allocate storage for each client number
		    unless ($clidata{$clinum}) {
			$clidata{$clinum} = ArrayInstance->new();
			allocStorage ($clidata{$clinum}, \%graphs,
				      $cliLines{$label},
				      $cliLines{$label}->{LINE}, "LINE");
		    }
		} else {
		    print "Unknown FORMAT: line $_\n";
		}
		next;
	    }

	    # check most common case first
	    if (/$cliLines{"SUMMARY-TIME"}->{PATTERN}/) {
		chomp;		# strip newline
		parseLine (\%clidata,
			   $cliLines{"SUMMARY-TIME"}, "LINE", $_);
		$summaryLines++;
		next;
	    }

	    # Should optimize this dynamic matching, Perl Cookbook 182-185
	    foreach $key (keys %cliLines) {
		#print "Checking $cliLines{$key}->{PATTERN}\n";
		next unless (m/$cliLines{$key}->{PATTERN}/);
		#print "\nMatched dynamic line $key: '$cliLines{$key}->{PATTERN}'\n";
		if ($key =~ /^SUMMARY-TIME/) {
		    warn "SUMMARY-TIME slipped through.  Should never happen\n";
		} elsif ($key =~ /^NOTICE/) {
		    $noticeLines++;
		    next RAWLINE;
		} elsif ($key =~ /^BLOCK-STATISTICS-/) {
				# ignore for now
		    next RAWLINE;
		} else {
		    warn "Found format line without hander $key\n";
		    last;
		}
	    }

	    ($params{DEBUG}) && print "skipping $.: $_";
	    $skippedLines++;
	    next;
	}

	close(CLIENTDATA);
	($params{DEBUG}) && print "\tInput done:\t", scalar (localtime), "\n";

	my $pcount = $section->{PROCESSES};
	my $tcount = ($section->{THREADS}) ? $section->{THREADS} : 1;
	$totalProcs += $pcount * $tcount;

	# Update totals, and dump out client numbers
	my @clist = sort numeric keys %clidata;
	$numThisClient = $#clist+1;

	$reportingClients += $numThisClient * $tcount;

	# Write out format description.  Note can be different for every client
	walkFormatValues ($clidata{0}, $cliLines{"SUMMARY-TIME"}, "LINE",
			  \&walkShowVar);
	print CSV "\n";
	foreach $p (@protocols) { # Create the finals arrays as needed
	    $finals{$p} = ArrayInstance->new() unless ($finals{$p});
	}

	# Create finals arrays (if needed)
	walkFormatValues ($clidata{0}, $cliLines{"SUMMARY-TIME"}, "LINE",
			  \&walkCreateFinals);
	foreach $cnum (@clist) {
	    my $cn = $clidata{$cnum};
	    #print "Total client $cnum\n";

	    # Total finals array.  Handle Min and Max special cases
	    walkFormatValues ($cn, $cliLines{"SUMMARY-TIME"}, "LINE",
			      \&walkTotalFinals);

        }
	($params{DEBUG}) && print "\tTotals done:\t", scalar (localtime), "\n";
	foreach $cnum (@clist) {
	    my $cn = $clidata{$cnum};
	    # Write out CSV
	    walkFormatValues ($cn, $cliLines{"SUMMARY-TIME"}, "LINE",
			      \&walkShowName);
	    print CSV "\n";
	}
	($params{DEBUG}) && print "\tCSV done:\t", scalar (localtime), "\n";
	#print "\n";

	print "Processed: $clientfile: $numThisClient clients\n";
	if (1 || $params{DEBUG}) {
	    foreach $cnum (@clist) {
		printf "\tFirst: %d\tFinal: %d\tDuration: %d\n",
		$clidata{$cnum}->{startTime}, $clidata{$cnum}->{"time"},
		$clidata{$cnum}->{"time"} - $clidata{$cnum}->{startTime};
	    }
	}

	print "\t$summaryLines summaries, $noticeLines notices, $skippedLines unknown.\n";
	print CSV "\n";
	close(CSV);
	($params{DEBUG}) && print "Wrote $resultdir/client-$cli.csv\n";

    }
}

%cliLines = ();			# clear storage


unless ($reportingClients > 0) {
    print "No clients reported.  Check $resultdir/stderr\n";
    die "Test Failed!";
}

# Find time extent for a key graph
($startTime, $endTime) = dataMinMax ("blocks", \@protocols,
				     $startTime, $endTime);

$realTestSecs = ($endTime - $startTime) * $timeStep;
$realTestSecs = 1 unless ($realTestSecs); # in case of small MaxBlocks
printf "Reported test duration %d seconds with %d second resolution\n",
	$realTestSecs, $timeStep;
$realTestSecs = $testsecs if ($realTestSecs > $testsecs);

($params{DEBUG})
    && print "Doing statistical data reduction:\t", scalar (localtime), "\n";


# WRONG:  These numbers have already been converted to rate and summed
# Convert Time2 to standard deviation
foreach $p (@protocols) {
    my $gp = $graphs{$p};
    foreach $n (@{$protocolFields{$p}}) { # all timers
	my $t = $n;	# dont modify original list
	if ($t =~ /^\[(\w+)\]$/) { $t = $1; } # strip off brackets
	next unless ($gp->{$t}); # proto doesnt have this timer
	my $sp = $gp->{$t}->{"Time2"}; # sum of time squared graph pointer
	my $tp = $gp->{$t}->{"Time"}; # sum of time graph pointer
	my $np = $gp->{$t}->{"Try"}; # try graph pointer
	next unless (($sp) && ($tp) && ($gp));

	#print "Calculating std dev $t for $p\n";
	foreach $tm (keys %$tp) {
	    my $n = $np->{$tm};
	    my $tot = $sp->{$tm};
	    if ($np->{$tm}) {
		my $var = ($sp->{$tm} - (($tot * $tot) / $n)) / $n;
		print "$p->$t var < 0: Time2=$sp->{$tm} Time=$tot n=$n \@$tm\n"
		    if (($var < 0) && ($params{DEBUG}));
		
		$sp->{$tm} = ($var > 0) ? sqrt ($var) : 0.0;
	    } else {
		print "$p->$t: Time2=$sp->{$tm} Time=$tot w/0 tries \@$tm\n"
		    if (($tp->{$tm}) || ($sp->{$tm})); # internal error check
		$sp->{$tm} = 0;
	    }
	}
    }
}

($params{DEBUG}) && print "Doing final data reduction:\t", scalar (localtime), "\n";

# divide time graphs by number of tries
foreach $p (@protocols) {
    my $gp = $graphs{$p};
    foreach $n (@{$protocolFields{$p}}) { # all timers
	my $t = $n;	# dont modify original list
	if ($t =~ /^\[(\w+)\]$/) { $t = $1; } # strip off brackets
	next unless ($gp->{$t}); # proto doesnt have this timer

	my $tp = $gp->{$t}->{"Time"}; # time graph pointer
	my $np = $gp->{$t}->{"Try"}; # try graph pointer
	next unless (($tp) && ($gp)); # should never happen.

	#print "Ratioing $t for $p\n";
	foreach $tm (keys %$tp) {
	    if ($np->{$tm}) {
		$tp->{$tm} /= $np->{$tm} ;
	    } else {
		print "$p->$t: $tp->{$tm} time with 0 tries \@$tm\n"
		    if ($tp->{$tm}); # internal error check
		$tp->{$tm} = 0;
	    }
	}
    }
}

print "Saving combined graphs:\t", scalar (localtime), "\n";

# Dump graphs into file by protocol
foreach $p (@protocols) {
    my $gp = $graphs{$p};

    # Write out data
    fileBackup ("$resultdir/time-$p.csv"); # if processing as we go, backup
    open(CSV, ">$resultdir/time-$p.csv") # Summary of protocol over time
	|| die "Could not open $resultdir/time-$p.csv: $!\n";

    print CSV "time";
    foreach $t (@{$protocolFields{$p}}) {
	if ($t =~ /^\[(\w+)\]$/) { # Timer case, strip off brackets
	    foreach $f (@timerFieldsAll) {
		print CSV ",$p:$1:$f";
	    }
	} else {
	    print CSV ",$p:$t";
	}
    }
				# note: line print includes initial newline

    for (my $tm = $startTime; $tm <= $endTime; $tm++) {
	print CSV "\n", $tm-$startTime;
	foreach $t (@{$protocolFields{$p}}) {
	    if ($t =~ /^\[(\w+)\]$/) { # Timer case, strip off brackets
		foreach $f (@timerFieldsAll) {
		    if ($gp->{$1}->{$f}->{$tm}) {
			print CSV "," . $gp->{$1}->{$f}->{$tm};
		    } else {
			print CSV ",0";
		    }
		}
	    } else {
		if ($gp->{$t}->{$tm}) {
		    print CSV "," . $gp->{$t}->{$tm};
		} else {
		    print CSV ",0";
		}
	    }
	}
    }
    print CSV "\n";
    close(CSV);
    ($params{DEBUG}) && print "Wrote $resultdir/time-$p.csv\n";

}

return 1;