flstats.pl

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

#!/usr/local/bin/perl4 
#
# Copyright (C) 1996-1998 by the Board of Trustees
#    of Leland Stanford Junior University.
# 
# This file is part of the SimOS distribution. 
# See LICENSE file for terms of the license. 
#

# Mark A. Heinrich
# Stanford University
# FlashLite/Mipsy Statistics Post-Processor
# September 21, 1993

if (($#ARGV+1) < 2) {
   die "Usage: $0 [-h] <stat file> <MIPSY log file>\n";
}
while (1) {
   $next_option = shift(@ARGV);
   if ($next_option eq "-h") {
      $HISTMODE = 1;
   }
   else {
      unshift(@ARGV, $next_option);
      last;
   }
}
$APPL = shift(@ARGV);
$STATFILE = "$APPL.stats";
$MIPSYLOG = shift(@ARGV);
$OUTPUT = $MIPSYLOG;

# Get some old FL stats that are now in the MIPSYLOG file
open(MIPSYFILE, $MIPSYLOG) || die "Can't open $MIPSYLOG: $!\n";
while (<MIPSYFILE>) {

#
# Get Number of Processors
#
   ?^CONFIG\s+NumCPUs\s+(\d+).*$? && ($numProcs = $1);

#
# Number of Instructions and Thread runtimes
#
   if (/^M_EVENT_C(\d+)\s+Insts\s+(\d+).*$/) {
      $curProc = $1;
      $instruction_count += $2;
      $numInstructions[$1] = $2;
   }

   if (/^M_EVENT_C(\d+)\s+FP-Insts\s+(\d+).*$/) {
      $instruction_count += $2;
      $numInstructions[$1] += $2;
   }

   if (/^M_EVENT_C(\d+)\s+CPI\s+(\d+.\d+).*$/) {
      $CPI[$1] = $2;
   }

#
# Loads, Stores, Cache Stats
#
   if (/^C(\d+)\s+U\s+D\s+Read\s+Misses:\s+(\d+)\s+Reads:\s+(\d+).*$/) {
      $processor_loads += $3;
      $processorLoadArray[$1] = $3;
   }
   if (/^C(\d+)\s+U\s+D\s+Write\s+Misses:\s+(\d+)\s+Writes:\s+(\d+).*$/) {
      $processor_stores += $3;
      $processorStoreArray[$1] = $3;
   }

   # Include Icache misses in Get references (loads)
   if (/^C(\d+)\s+U\s+S\s+IMisses\s+(\d+)\s+IRefs:\s+(\d+).*$/) {
      $processor_load_misses += $2;
      $processorLdMissArray[$1] += $2;
   }

   if (/^C(\d+)\s+U\s+S\s+DMisses:\s+GetMisses\s+(\d+)\s+GetRefs\s+(\d+).*$/) {
      $processor_load_misses += $2;
      $processorLdMissArray[$1] += $2;
   }

   if (/^C(\d+)\s+U\s+S\s+DMisses:\s+GetXMisses\s+(\d+)\s+GetXRefs\s+(\d+).*$/) {
      $processor_store_misses += $2;
      $processorStMissArray[$1] += $2;
   }

   if (/^C(\d+)\s+U\s+S\s+UpgMisses:\s+(\d+)\s+UpgRefs:\s+(\d+).*$/) {
      $processor_stores += $3;
      $processor_upgrade_misses += $2;
      $processorStMissArray[$1] += $2;
   }

   if (/^M_EVENT_C(\d+)\s+Prefetches\s+(\d+).*$/) {
      $processor_prefs += $2;
   }

   if (/^M_EVENT_C(\d+)\s+PrefetchL1Hits\s+(\d+).*$/) {
      $processor_pref_hits += $2;
      $processor_pref_misses = $processor_prefs - $processor_pref_hits -
	 $processor_dropped_prefs - $processor_fullMHT_pref_misses;
   }

   if (/^M_EVENT_C(\d+)\s+PrefetchL2Hits\s+(\d+).*$/) {
      $processor_pref_hits += $2;
      $processor_pref_misses = $processor_prefs - $processor_pref_hits -
	 $processor_dropped_prefs - $processor_fullMHT_pref_misses;
   }

   if (/^M_EVENT_C(\d+)\s+PrefetchMerges\s+(\d+).*$/) {
      $processor_dropped_prefs += $2;
      $processor_pref_misses = $processor_prefs - $processor_pref_hits -
	 $processor_dropped_prefs - $processor_fullMHT_pref_misses;
   }

   if (/^M_EVENT_C(\d+)\s+PrefetchMHTStall\s+(\d+).*$/) {
      $processor_fullMHT_pref_misses += $2;
      $processor_pref_misses = $processor_prefs - $processor_pref_hits -
	 $processor_dropped_prefs - $processor_fullMHT_pref_misses;
   }

   if (/^M_EVENT_C(\d+)\s+PrefetchExclusives\s+(\d+).*$/) {
      $processor_prefxs += $2;
   }

   if (/^M_EVENT_C(\d+)\s+PrefetchXL1Hits\s+(\d+).*$/) {
      $processor_prefx_hits += $2;
      $processor_prefx_misses = $processor_prefxs - $processor_prefx_hits -
	 $processor_dropped_prefxs - $processor_fullMHT_prefx_misses;
   }

   if (/^M_EVENT_C(\d+)\s+PrefetchXL2Hits\s+(\d+).*$/) {
      $processor_prefx_hits += $2;
      $processor_prefx_misses = $processor_prefxs - $processor_prefx_hits -
	 $processor_dropped_prefxs - $processor_fullMHT_prefx_misses;
   }

   if (/^M_EVENT_C(\d+)\s+PrefetchXMerges\s+(\d+).*$/) {
      $processor_dropped_prefxs += $2;
      $processor_prefx_misses = $processor_prefxs - $processor_prefx_hits -
	 $processor_dropped_prefxs - $processor_fullMHT_prefx_misses;
   }

   if (/^M_EVENT_C(\d+)\s+PrefetchXMHTStall\s+(\d+).*$/) {
      $processor_fullMHT_prefx_misses += $2;
      $processor_prefx_misses = $processor_prefxs - $processor_prefx_hits -
	 $processor_dropped_prefxs - $processor_fullMHT_prefx_misses;
   }

   if (/^M_EVENT_C(\d+)\s+SyncOpStallTime\s+(\d+).*$/) {
      $syncWaitTimeArray[$1] = $2;
   }


#    if (/^U I\$ Get Retries\s+(\d+),\s+D\$ Get Retries\s+(\d+),\s+D\$ GetXRetries\s+(\d+).*$/) {
#       $IcacheGetRetries += $1;
#       $DcacheGetRetries += $2;
#       $DcacheGetRetryArray[$curProc] = $2;
#       $DcacheGetXRetries += $3;
#       # Make sure this makes sense
#       &assert(($loadCheck - $firstLevelLoadMisses[$curProc]) == $2);
#       &assert(($storeCheck - $firstLevelStoreMisses[$curProc]) == $3);

#       # Adjust number of store misses (save load for later)
#       $processor_store_misses -= $3;
#       $processorStMissArray[$curProc] -= $3;
#    }

#
# Synchronization
#
   if (/^M_EVENT_C(\d+)\s+LLStallTime\s+(\d+).*$/) {
      $LLStallTime[$1] = $2;
   }
   if (/^M_EVENT_C(\d+)\s+SCStallTime\s+(\d+).*$/) {
      $SCStallTime[$1] = $2;
   }

   if (/^SOLO_C(\d+)\s+Barriers\s+(\d+)\s+BarrierStall\s+(\d+).*$/) {
      $barWaitTimeArray[$1] = $3;
   }
   if (/^SOLO_C(\d+)\s+Locks\s+(\d+)\s+LockStall\s+(\d+).*$/) {
      $lockWaitTimeArray[$1] += $3;
   }
   if (/^SOLO_C(\d+)\s+Unlocks\s+(\d+)\s+UnlockStall\s+(\d+).*$/) {
      $lockWaitTimeArray[$1] += $3;
   }
   if (/^SOLO_C(\d+)\s+WaitFors\s+(\d+)\s+WaitForStall\s+(\d+)$/) {
      $waitForWaitTimeArray[$1] = $3;
   }


# # Not supported in Mipsy
#    if (/^processor_spin_lock_wait_time\s+(\d+).*$/) {
#       $spinLockWaitTimeArray[$numProcs-1] = $1;
#    }
#    if (/^processor_delay_wait_time\s+(\d+).*$/) {
#       $delayWaitTimeArray[$numProcs-1] = $1;
#    }
#    if (/^processor_getsub_wait_time\s+(\d+).*$/) {
#       $getsubWaitTimeArray[$numProcs-1] = $1;
#    }
#    if (/^processor_pause_wait_time\s+(\d+).*$/) {
#       $pauseWaitTimeArray[$numProcs-1] = $1;
#    }
}
close(MIPSYFILE);

# Save only the FlashLite statistics from the output file
open(OUTFILE, $OUTPUT) || die "Can't open $OUTPUT: $!\n";
while (<OUTFILE>) {
   /^total_cycles\s+(\d+).*$/ && ($total_cycles += $1);
   /^total_instructions\s+(\d+).*$/ && ($total_instructions += $1);
   /^total_ALU_instructions\s+(\d+).*$/ && ($total_ALU_instructions += $1);
   /^total_special_ALU_instructions\s+(\d+).*$/ && ($total_special_ALU_instructions += $1);
   /^total_branch_instructions\s+(\d+).*$/ && ($total_branch_instructions += $1);
   /^total_special_branch_instructions\s+(\d+).*$/ && ($total_special_branch_instructions += $1);
   /^total_ldst_instructions\s+(\d+).*$/ && ($total_ldst_instructions += $1);
   /^total_interface_instructions\s+(\d+).*$/ && ($total_interface_instructions += $1);
   if (/^total_(([PN]I|SW|IO)[^_]+)_latency_cycles\s+(\d+).*$/) {
      $latencies{$1} = $3;
   }
   if (/^total_(([PN]I|SW|IO)[^_]+)_occupancy_cycles\s+(\d+).*$/) {
      $occupancies{$1} = $3;
   }
   next unless /^BEGIN_PROC (\d+)/;
   $curProc = 0;
   @FL_OUTPUT = <OUTFILE>;
   last;
}

# Parse the FlashLite Statistics
foreach (@FL_OUTPUT) {
   if (/^BEGIN_PROC\s+(\d+).*$/) {
      $curProc = $1;
   }
   ?^simulation_time\s+(\d+).*$? && ($simulation_time = $1);
   ?^latency_factor\s+(\d+).*$? && ($latencyFactor = $1);

   if (/^total_execution_time\s+(\d+).*$/) {
      $executionTime = $1;
   }
   if (/^thread_execution_time_since_reset\s+(\d+).*$/) {
      $executionTimeSinceReset[$curProc] = $1;
   }

   if (/^messages_processed\s+(\d+)/) {
      if ($messages_processed != $totalCount) {
	 printf("WARNING: totalCount (%d) != messages_processed (%d) on node %d\n", $totalCount, $messages_processed, $curProc);
      }
      $messages_processed += $1;
   }
   if (/^(([PN]I|SW|IO)[^_]\w+)\s+(\d+).*$/ ) {
      $count{$1} += $3;
      $totalCount += $3;
   }
   if (/^Greatest_buffer_num_used\s+(\d+).*$/) {
      if ($1 > $greatest_buffer) {
	 $greatest_buffer = $1;
      }
      $greatest_buffer_sum += $1;
   }
   if (/^PI_wait_count\s+(\d+).*$/) {
      $piBufferWaitCount = $1;
   }
   if (/^PI_wait_time\s+(\d+).*$/) {
      if ($piBufferWaitCount > 0) {
	 $piBufferWaitLatency = $1/$piBufferWaitCount;
      }
      else {
	 $piBufferWaitLatency = 0;
      }
      if ($piBufferWaitLatency > $piBufferWaitLatency_max) {
	 $piBufferWaitLatency_max = $piBufferWaitLatency;
      }
      $piBufferWaitLatency_sum += $piBufferWaitLatency;
   }
   if (/^NI_req_wait_count\s+(\d+).*$/) {
      $niReqBufferWaitCount = $1;
   }
   if (/^NI_req_wait_time\s+(\d+).*$/) {
      if ($niReqBufferWaitCount > 0) {
	 $niReqBufferWaitLatency = $1/$niReqBufferWaitCount;
      }
      else {
	 $niReqBufferWaitLatency = 0;
      }
      if ($niReqBufferWaitLatency > $niReqBufferWaitLatency_max) {
	 $niReqBufferWaitLatency_max = $niReqBufferWaitLatency;
      }
      $niReqBufferWaitLatency_sum += $niReqBufferWaitLatency;
   }
   if (/^NI_reply_wait_count\s+(\d+).*$/) {
      $niRepBufferWaitCount = $1;
   }
   if (/^NI_reply_wait_time\s+(\d+).*$/) {
      if ($niRepBufferWaitCount > 0) {
	 $niRepBufferWaitLatency = $1/$niRepBufferWaitCount;
      }
      else {
	 $niReqBufferWaitLatency = 0;
      }
      if ($niRepBufferWaitLatency > $niRepBufferWaitLatency_max) {
	 $niRepBufferWaitLatency_max = $niRepBufferWaitLatency;
      }
      $niRepBufferWaitLatency_sum += $niRepBufferWaitLatency;
   }

   /^PI_memory_ops\s+(\d+).*$/ && ($pi_memory_ops += $1);
   /^NI_memory_ops\s+(\d+).*$/ && ($ni_memory_ops += $1);
   /^DP_memory_ops\s+(\d+).*$/ && ($dp_memory_ops += $1);
   /^dc_cache_misses\s+(\d+).*$/ && ($ddcache_misses += $1);
   /^dc_icache_misses\s+(\d+).*$/ && ($dicache_misses += $1);
   /^dc_cache_writebacks\s+(\d+).*$/ && ($ddcache_writebacks += $1);
   if (/^memory_ops\s+(\d+).*$/) {
      $total_memory_ops_sum += $1;
      if ($1 != 0) {
	 $memLatency = $memTime/$1;
      }
      else {
	 $memLatency = 0;
      }
      if ($memLatency > $memLatency_max) {
	 $memLatency_max = $memLatency;
      }
      $memLatency_sum += $memLatency;      
   }
   /^memory_reads\s+(\d+).*$/ && ($memory_reads += $1);
   /^memory_writes\s+(\d+).*$/ && ($memory_writes += $1);
   /^directory_memory_reads\s+(\d+).*$/ && ($dir_memory_reads += $1);
   /^directory_memory_writes\s+(\d+).*$/ && ($dir_memory_writes += $1);
   /^useless_memory_reads\s+(\d+).*$/ && ($useless_reads += $1);

#
# Pre-SysADBus Stall Time
#
   if (/^processor_write_stall_time\s+(\d+).*$/) {
      $writeStallTimeArray[$curProc] = $1;
   }
   if (/^processor_num_naks\s+(\d+).*$/) {
      $numNaks += $1;
   }

#
# SysADBus Stall Time
#
   if (/^read_SysAD_stall_time\s+(\d+).*$/) {
      $readSysADStallTime += $1;
   }
   if (/^write_SysAD_stall_time\s+(\d+).*$/) {
      $writeSysADStallTime += $1;