tree.prl

一个用在mips体系结构中的操作系统

}


####
#### Utility subroutines
####
####

sub SumAcross {
    ($cum, $src, $weight) = @_;

    $weight = (defined($weight)) ? $weight : 1;
    
    if ($src) {
        $cum->{"derived"} = $cum->{"derived"} || $src->{"derived"};
        
        foreach $field (@fieldname) {
            if (($field eq "name") || ($field eq "bucketName")) {
                # ignore

            } elsif ($field eq "time") {
                $cum->{"time"} = $src->{"time"};
                
            } elsif (($field eq "latmin") || ($field eq "compmin")) {
                $cum->{$field} = min($cum->{$field}, $src->{$field});
                
            } elsif (($field eq "latmax") || ($field eq "compmax")) {
                $cum->{$field} = max($cum->{$field}, $src->{$field});
                
            } elsif (!defined($cum->{$field})) {
                if (defined($src->{$field})) {
                    $cum->{$field} = $weight * $src->{$field};
                } else {
                    $cum->{$field} = 0;
                }

            } else {
                $cum->{$field} += $weight * $src->{$field};
            }
        }
    }
}

sub SumUp {
    ($parent, $child, $weight) = @_;

    $weight = (defined($weight)) ? $weight : 1;

    if ($child) {
        $parent->{"derived"} = 1;
        
         foreach $field (@fieldname) {
             if (($field eq "name") || ($field eq "bucketName")
                 || ($field eq "n")) {
                 #ignore
                 
             } elsif ($field eq "time") {
                 $parent->{"time"} = $child->{"time"};
                 
             } elsif (($field eq "lattotal")
                      || ($field eq "latmin") || ($field eq "latmax")
                      || ($field eq "latcorr")) {
                 # ignore
                 
             } elsif (($field eq "compmin") || ($field eq "compmax")
                      || ($field eq "compcorr")) {
                 $parent->{$field} = 0;
                 
             } elsif ($field eq "derived") {
                 
             } elsif (!defined($parent->{$field})) {
                 $parent->{$field} = $child->{$field};
             } else {
                 $parent->{$field} += $child->{$field};
             }
         }
     }
}



sub PhaseName {
    ($nodename) = @_;
    @p = split(/\./, $nodename);
    return $p[$#p];
}

sub min {
    ($a, $b) = @_;
    if (!defined($a)) {
        $b;
    } elsif (!defined($b)) {
        $a;
    } else {
        ($a < $b) ? $a : $b;
    }
}

sub max {
    ($a, $b) = @_;
    if (!defined($a)) {
        $b;
    } elsif (!defined($b)) {
        $a;
    } else {
        ($a > $b) ? $a : $b;
    }
}

sub PrintBucket {
    ($data) = @_;
    
    if (defined($data->{"derived"})) {
        printf "%-20s %15d %15.2f %15.2f %15.2f %15.2f %15s %15s %15d\n",
        $data->{"name"},
        $data->{"n"},
        $data->{"lattotal"},
        $data->{"latmin"}, $data->{"latmax"},
        $data->{"comptotal"},
        "n/a", "n/a",
        $data->{"dTlb"};
        
    } else {
        printf "%-20s %15d %15.2f %15.2f %15.2f %15.2f %15.2f %15.2f %15d\n",
        $data->{"name"},
        $data->{"n"},
        $data->{"lattotal"},
        $data->{"latmin"}, $data->{"latmax"},
        $data->{"comptotal"},
        $data->{"compmin"}, $data->{"compmax"},
        $data->{"dTlb"};
    }
}


####
#### Used to be in simos-lib.prl
####

$CYCLESAMPLE = 256;
$INSTRSAMPLE = 256;

@field_time = ('CPU','L1D','L2D','Upg','L1I','L2I');

sub ComputeDerivedFields {
    my $f = shift;
    my $time;
    if ($f->{'cycleSample'} > 0) {
        $f->{'_cycles'} = $f->{'cycleSample'} * $CYCLESAMPLE;
        $f->{'_instr'}  = $f->{'instrSample'} * $INSTRSAMPLE;

    } elsif (defined($f->{'instrCount'})) {
        # Embra stuff
        $f->{'_instr'} = $f->{'instrCount'};
        $f->{'dStall'} = $f->{'dL2Stall'} + $f->{'dUpgradeStall'};
        $f->{'iStall'} = $f->{'iL2Stall'};
        $f->{'_cycles'} = $f->{'instrCount'} + 
            $f->{'dStall'} + $f->{'iStall'};
    }

    $f->{'dL1Stall'} = $f->{'dStall'} - 
        $f->{'dL2Stall'} - $f->{'dUpgradeStall'};
    $f->{'iL1Stall'} = $f->{'iStall'} - $f->{'iL2Stall'};
    
    $f->{'memStall'} = $f->{'dStall'} + $f->{'iStall'};
    if (defined($f->{'dStallPrefetch'})) { 
        $f->{'memStall'} += $f->{'dStallPrefetch'};
    }
    
    # Handle cold misses etc
    if (defined($f->{'read.ice'})) {
	$f->{'cold'} = $f->{'read.ice'} + $f->{'read.cold'} +
	    $f->{'write.ice'} + $f->{'write.cold'};
    }
    
    $time =  $f->{'_cycles'};
    
    # Ensure we don't get any divide by 0 fatal errors
    # Check whether this is necessary before committing!
    if ($time != 0) {
	$f->{'time-CPU'} = 100 * $f->{'_instr'} / $time;
	$f->{'time-L1D'} = 100 * $f->{'dL1Stall'} / $time;
	$f->{'time-L2D'} = 100 * $f->{'dL2Stall'} / $time;
	$f->{'time-Upg'} = 100 * $f->{'dUpgradeStall'} / $time;
	$f->{'time-L1I'} = 100 * $f->{'iL1Stall'} / $time;
	$f->{'time-L2I'} = 100 * $f->{'iL2Stall'} / $time;
	$f->{'seconds'} = $f->{'_cycles'} / $config{'Clock'} / 1000 / 1000;
    } else {
	# Initialize everything to -1.0 (per Ed's convention)
	$f->{'time-CPU'} = $f->{'time-L1D'} =  
	    $f->{'time-L2D'} = $f->{'time-Upg'} = 
		$f->{'time-L1I'} = $f->{'time-L2I'} = -1.0;
	$f->{'seconds'} = 0;
    }
	
    # Now calculate D1/D2/I1/I2 miss rates etc
    $instrCount = $f->{'_instr'};
    if ($instrCount != 0) {
	$f->{'dL1MR'} = 100.0*$f->{'dL1Miss'}/$instrCount;
	$f->{'dL2MR'} = 100.0*$f->{'dL2Miss'}/$instrCount;
	$f->{'iL1MR'} = 100.0*$f->{'iL1Miss'}/$instrCount;
	$f->{'iL2MR'} = 100.0*$f->{'iL2Miss'}/$instrCount;

	$f->{'dTlbMR'} = 100.0*$f->{'dTlb'}/$instrCount;
	$f->{'iTlbMR'} = 100.0*$f->{'iTlb'}/$instrCount;

	# TODO - the upgrade numbers
        $f->{'dMCPI'}   = $f->{'dStall'} / $instrCount;
        $f->{'iMCPI'}   = $f->{'iStall'} / $instrCount;
        $f->{'dL2MCPI'} = $f->{'dL2Stall'} / $instrCount;
        $f->{'dL1MCPI'} = $f->{'dL1Stall'} / $instrCount;
        $f->{'dUpgMCPI'} = $f->{'dUpgradeStall'} / $instrCount;
        if (defined($f->{'dStallPrefetch'})) {
            $f->{'dPrefMCPI'} = $f->{'dStallPrefetch'}  / $instrCount;
        }
        
    } else {        
        $f->{'dL1MR'} = $f->{'dL2MR'} = $f->{'iL1MR'} = 
	    $f->{'iL2MR'} = $f->{'dMR'} = $f->{'iMR'} = 
		$f->{'dTlbMR'} = $f->{'iTlbMR'} = -1.0;
        $f->{'dMCPI'} =   $f->{'iMCPI'} =  $f->{'dL2MCPI'} =  
            $f->{'dL1MCPI'} =   $f->{'dUpgMCPI'} = -1;
    }
    
    # Cache miss classification 
    if (defined($f->{'trueSharing.ice'})) {
        $f->{'missclass-true'} = 
            ($f->{'trueSharing.inv'}+
             $f->{'trueSharing.capinv'}+
             $f->{'trueSharing.cap'}+
             $f->{'trueSharing.cold'});
        $f->{'missclass-cold'} = 
            ($f->{'falseSharing.ice'}+
             $f->{'falseSharing.cold'});
        $f->{'missclass-repl'} = 
            ($f->{'falseSharing.cap'});
        $f->{'missclass-false'} =  
            ($f->{'falseSharing.inv'}+
             $f->{'falseSharing.capinv'});
        $f->{'missclass-other'} =  $f->{'dL2Miss'} - 
            ($f->{'missclass-true'}+
             $f->{'missclass-cold'}+
             $f->{'missclass-repl'}+
             $f->{'missclass-false'});
     
        if (defined($f->{'prefetchNoMiss'}  )) { 
            $f->{'missclass-other'} += $f->{'prefetchNoMiss'};
        }

        foreach $i ('cold','true','false','repl','other') {
            if ($f->{'dL2Miss'} > 0 ) { 
                $f->{"missrate-$i"} = $f->{"missclass-$i"} *
                    $f->{"dL2MR"} /  $f->{"dL2Miss"};
            } else {
                $f->{"missrate-$i"} = -1;
            }
            
        }
        
        $f->{"stall-true"} = 
            ($f->{"trueShStall.inv"}+
             $f->{"trueShStall.capinv"}+
             $f->{"trueShStall.cap"}+
             $f->{"trueShStall.cold"});
        $f->{"stall-cold"} = 
            ($f->{"falseShStall.ice"}+
             $f->{"falseShStall.cold"});
        $f->{"stall-repl"} = 
            ($f->{"falseShStall.cap"}) ;
        $f->{"stall-false"} = 
            ($f->{"falseShStall.inv"}+
             $f->{"falseShStall.capinv"});
        
#        print STDERR "XXX  $f->{trueShStall.inv}\n";
#        print STDERR "XXX