flstats.pl

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

      $piOutOccupancy = (($1/$executionTimeSinceReset[$curProc])*100.0);
      if ($piOutOccupancy > $piOutOccupancy_max) {
	 $piOutOccupancy_max = $piOutOccupancy;
      }
      $piOutOccupancy_sum += $piOutOccupancy;
   }
   if (/^Inbox_addr_match\s+(\d+).*$/) {
      $inboxAddrMatch += $1;
   }
   if (/^Inbox_addr_match_delay_count\s+(\d+).*$/) {
      $inboxAddrMatchDelayCount += $1;
   }
   if (/^Inbox_addr_match_delay_time\s+(\d+).*$/) {
      $inboxAddrMatchDelayTime += $1;
   }
   if (/^Inbox_DP_stall_time\s+(\d+).*$/) {
      $inboxDPStallTime += $1;
   }
   if (/^Inbox_DP_stall_count\s+(\d+).*$/) {
      $inboxDPStallCount += $1;
   }
   if (/^DP_Mem_stall_time\s+(\d+).*$/) {
      $dpMemStallTime += $1;
   }
   if (/^DP_Outbox_stall_time\s+(\d+).*$/) {
      $dpOutboxStallTime += $1;
   }
   if (/^Outbox_PI_stall_time\s+(\d+).*$/) {
      $outboxPIStallTime += $1;
   }
   if (/^Outbox_NI_stall_time\s+(\d+).*$/) {
      $outboxNIStallTime += $1;
   }
   if (/^PI_SysAD_stall_time\s+(\d+).*$/) {
      $piSysADStallTime += $1;
   }
   if (/^total_SysAD_PI_requests\s+(\d+).*$/) {
      $totalSysADPIRequests += $1;
   }
   if (/^processor_Cache_stall_time\s+(\d+).*$/) {
      $processorCacheStallTime += $1;
      $processorCacheStallTimeArray[$curProc] = $1;
   }
   if (/^read_invalidate_retries\s+(\d+).*$/) {
      $readInvalidateRetries += $1;
   }
   if (/^upgrade_invalidate_retries\s+(\d+).*$/) {
      $upgradeInvalidateRetries += $1;
   }
   if (/^processor_read_bus_id_wait_time\s+(\d+).*$/) {
      $readBusIDWaitTime += $1;
   }
   if (/^processor_write_bus_id_wait_time\s+(\d+).*$/) {
      $writeBusIDWaitTime += $1;
   }
   if (/^dirty_local_get_count\s+(\d+).*$/) {
      $dirtyLocalGetCount += $1;
   }
   if (/^dirty_local_getx_count\s+(\d+).*$/) {
      $dirtyLocalGetXCount += $1;
   }
}

# Open the final, nicely formatted statistics file

open(STAT, "> $STATFILE") || die "Can't open $STATFILE: $!\n";

&DO_FLASHLITE_PERF_STATS();
&PRINT_DIVIDER();
&DO_PROCESSOR_STATS();
&PRINT_DIVIDER();
&DO_SCACHE_STATS();
&PRINT_DIVIDER();
&DO_DPSIM_STATS();
&PRINT_DIVIDER();
&DO_HANDLER_STATS();
&PRINT_DIVIDER();
&DO_READ_CLASSIFICATION_STATS();
&PRINT_DIVIDER();
&DO_SW_QUEUE_STATS();
&PRINT_DIVIDER();
&DO_DDCACHE_STATS();
&PRINT_DIVIDER();
&DO_DICACHE_STATS();
&PRINT_DIVIDER();
&DO_MEMORY_STATS();
&PRINT_DIVIDER();
&DO_BUFFER_STATS(); 
&PRINT_DIVIDER();
&DO_QUEUE_STATS();
&PRINT_DIVIDER();
&DO_OCCUPANCY_STATS();
&PRINT_DIVIDER();
&DO_MACROPIPELINE_STALL_STATS();
close(STAT);
#system("raw.pl $OUTPUT") &&
#    die "raw.pl exited abnormally: $!\n";
exit(0);

sub numerically { $a <=> $b;}
sub PRINT_DIVIDER {
   printf(STAT "\n************************************************************\n\n");
}

sub DO_FLASHLITE_PERF_STATS {
   printf(STAT "Simulation Time: %d Hours %d Minutes %d Seconds\n",
	  $simulation_time/3600, ($simulation_time/60)%60, 
	  $simulation_time % 60);
   printf(STAT "FLASH Instructions Simulated: %.0lf\n", 
	  $instruction_count);
   printf(STAT "FlashLite Speed: %8.3lf (Instructions/Second)\n",
	  $instruction_count/$simulation_time);
   printf(STAT "Execution Time of Simulated Application: %.0lf cycles",
	  $executionTime/$latencyFactor);
}

sub DO_SCACHE_STATS {
   printf(STAT "Secondary Cache Statistics\n\n");
   printf(STAT "Miss Rate = %.2lf%%\n\n", (($processor_load_misses +
	$processor_store_misses + $processor_upgrade_misses + 
	$processor_pref_misses + $processor_prefx_misses + 
        $processor_fullMHT_pref_misses + $processor_fullMHT_prefx_misses)/
       ($processor_loads + 
	$processor_stores + $processor_prefs + $processor_prefxs))
	* 100.0);
   printf(STAT "%-25s %9s %12s\n", Operation, Count, Percentage); 
   printf(STAT "------------------------------------------------\n");
   printf(STAT "%-25s %9d %9.1lf\n", Load, $processor_loads, 
	($processor_loads/($processor_loads + $processor_stores +
	$processor_prefs + $processor_prefxs)) * 100.0);
   printf(STAT "\n%25s %9d %9.1lf\n", Hits, $processor_loads - 
	$processor_load_misses - ($localReadMerges + $remReadMerges), 
	(($processor_loads - $processor_load_misses - ($localReadMerges +
        $remReadMerges))/$processor_loads) * 100.0);
   printf(STAT "%25s %9d %9.1lf\n", Misses, $processor_load_misses, 
	($processor_load_misses/$processor_loads) * 100.0);
   printf(STAT "%25s %9d %9.1lf\n\n", Merges, ($localReadMerges + 
          $remReadMerges), (($localReadMerges + $remReadMerges)/
	  $processor_loads) * 100.0);
   if ($processor_load_misses != 0) {
      printf(STAT "%-25s %9d %9.1lf\n", "Misses w/ Local Home", 
	     $localReadMisses,
	     ($localReadMisses/($localReadMisses + $remReadMisses))*100.0);
      printf(STAT "%-25s %9d %9.1lf\n", "Misses w/ Remote Home", 
	     $remReadMisses,
	     ($remReadMisses/($localReadMisses + $remReadMisses))*100.0);
   }
   else {
      printf(STAT "%-25s %9d %9.1lf\n", "Misses w/ Local Home", 0, 0.0);
      printf(STAT "%-25s %9d %9.1lf\n", "Misses w/ Remote Home", 0, 0.0);
   }
   if ($localReadMerges + $remReadMerges == 0) {
      printf(STAT "%-25s %9d %9.1lf\n", "Merges w/ Local Home", 0, 0.0);
      printf(STAT "%-25s %9d %9.1lf\n", "Merges w/ Remote Home", 0, 0.0);
   }
   else {
      printf(STAT "%-25s %9d %9.1lf\n", "Merges w/ Local Home", 
	     $localReadMerges, ($localReadMerges/($localReadMerges + 
	     $remReadMerges))*100.0);
      printf(STAT "%-25s %9d %9.1lf\n", "Merges w/ Remote Home", 
	     $remReadMerges, ($remReadMerges/($localReadMerges + 
	     $remReadMerges))*100.0);
   }
   if ($localReadConflicts + $remReadConflicts == 0) {
      printf(STAT "%-25s %9d %9.1lf\n", "Conflicts w/ Local Home", 0, 0.0);
      printf(STAT "%-25s %9d %9.1lf\n", "Conflicts w/ Remote Home", 0, 0.0);
   }
   else {
      printf(STAT "%-25s %9d %9.1lf\n", "Conflicts w/ Local Home", 
	  $localReadConflicts,
	  ($localReadConflicts/($localReadConflicts + $remReadConflicts))
	  *100.0);
      printf(STAT "%-25s %9d %9.1lf\n", "Conflicts w/ Remote Home", 
	  $remReadConflicts,
	  ($remReadConflicts/($localReadConflicts + $remReadConflicts))*100.0);
   }
   printf(STAT "\n%-25s %9d %9.1lf\n", Store, $processor_stores, 
	($processor_stores/($processor_loads + $processor_stores +
	$processor_prefs + $processor_prefxs)) * 100.0);
   printf(STAT "\n%25s %9d %9.1lf\n", Hits, $processor_stores - 
	$processor_store_misses - $processor_upgrade_misses - 
        ($localWriteMerges + $remWriteMerges), 
	(($processor_stores - $processor_store_misses - ($localWriteMerges
        + $remWriteMerges) -
	$processor_upgrade_misses)/$processor_stores) * 100.0);
   printf(STAT "%25s %9d %9.1lf\n", "Store Misses", $processor_store_misses, 
	($processor_store_misses/$processor_stores) * 100.0);
   printf(STAT "%25s %9d %9.1lf\n", "Upgrade Misses", 
	$processor_upgrade_misses, ($processor_upgrade_misses/
	$processor_stores) * 100.0);
   printf(STAT "%25s %9d %9.1lf\n\n", Merges, 
	  ($localWriteMerges + $remWriteMerges),
	  (($localWriteMerges + $remWriteMerges)/$processor_stores) * 100.0);
   if ($localWriteMisses + $remWriteMisses == 0) {
      printf(STAT "%-25s %9d %9.1lf\n", "Misses w/ Local Home", 0, 0.0);
      printf(STAT "%-25s %9d %9.1lf\n", "Misses w/ Remote Home", 0, 0.0);
   }
   else {
      printf(STAT "%-25s %9d %9.1lf\n", "Misses w/ Local Home", $localWriteMisses,
	  ($localWriteMisses/($localWriteMisses + $remWriteMisses))*100.0);
      printf(STAT "%-25s %9d %9.1lf\n", "Misses w/ Remote Home", $remWriteMisses,
	  ($remWriteMisses/($localWriteMisses + $remWriteMisses))*100.0);
   }

   if ($localWriteMerges + $remWriteMerges == 0) {
      printf(STAT "%-25s %9d %9.1lf\n", "Merges w/ Local Home", 0, 0.0);
      printf(STAT "%-25s %9d %9.1lf\n", "Merges w/ Remote Home", 0, 0.0);
   }
   else {
      printf(STAT "%-25s %9d %9.1lf\n", "Merges w/ Local Home", 
	     $localWriteMerges, ($localWriteMerges/($localWriteMerges + 
	     $remWriteMerges))*100.0);
      printf(STAT "%-25s %9d %9.1lf\n", "Merges w/ Remote Home", 
	     $remWriteMerges, ($remWriteMerges/($localWriteMerges + 
	     $remWriteMerges))*100.0);
   }
   if ($localWriteConflicts + $remWriteConflicts == 0) {
      printf(STAT "%-25s %9d %9.1lf\n", "Conflicts w/ Local Home", 0, 0.0);
      printf(STAT "%-25s %9d %9.1lf\n", "Conflicts w/ Remote Home", 0, 0.0);
   }
   else {
      printf(STAT "%-25s %9d %9.1lf\n", "Conflicts w/ Local Home", 
	  $localWriteConflicts,
	  ($localWriteConflicts/($localWriteConflicts + $remWriteConflicts))*
	  100.0);
      printf(STAT "%-25s %9d %9.1lf\n", "Conflicts w/ Remote Home", 
	  $remWriteConflicts,
	  ($remWriteConflicts/($localWriteConflicts + $remWriteConflicts))*
	  100.0);
   }

   if ($processor_prefs > 0) {
      printf(STAT "\n%-25s %9d %9.1lf\n", Prefetch, $processor_prefs, 
	 ($processor_prefs/($processor_loads + $processor_stores +
	 $processor_prefs + $processor_prefxs)) * 100.0);
      printf(STAT "\n%25s %9d %9.1lf\n", Hits, $processor_prefs - 
	 $processor_pref_misses - $processor_dropped_prefs - 
         $processor_fullMHT_pref_misses, 
         (($processor_prefs - $processor_pref_misses - 
         $processor_dropped_prefs - $processor_fullMHT_pref_misses)/
	 $processor_prefs) * 100.0);
      printf(STAT "%25s %9d %9.1lf\n", Misses, $processor_pref_misses, 
	 ($processor_pref_misses/$processor_prefs) * 100.0);
      printf(STAT "%25s %9d %9.1lf\n", Dropped, $processor_dropped_prefs,
	 ($processor_dropped_prefs/$processor_prefs) * 100.0);
      printf(STAT "%25s %9d %9.1lf\n", "Full MHT", 
	  $processor_fullMHT_pref_misses,
	 ($processor_fullMHT_pref_misses/$processor_prefs) * 100.0);
   }
   else {
      printf(STAT "\n%-25s %9d %9.1lf\n", Prefetch, 0, 0.0);
   }

   if ($processor_prefxs > 0) {
      printf(STAT "\n%-25s %9d %9.1lf\n", "Prefetch Exclusive", 
	 $processor_prefxs, ($processor_prefxs/($processor_prefxs + 
	 $processor_stores + $processor_prefs + $processor_prefxs)) * 100.0);
      printf(STAT "\n%25s %9d %9.1lf\n", Hits, $processor_prefxs - 
	 $processor_prefx_misses - $processor_dropped_prefxs -
         $processor_fullMHT_prefx_misses, (($processor_prefxs - 
	 $processor_prefx_misses - $processor_dropped_prefxs -
         $processor_fullMHT_prefx_misses)/$processor_prefxs) * 100.0);
      printf(STAT "%25s %9d %9.1lf\n", Misses, $processor_prefx_misses, 
	 ($processor_prefx_misses/$processor_prefxs) * 100.0);
      printf(STAT "%25s %9d %9.1lf\n", Dropped, $processor_dropped_prefxs,
	 ($processor_dropped_prefxs/$processor_prefxs) * 100.0);
      printf(STAT "%25s %9d %9.1lf\n", "Full MHT", 
	  $processor_fullMHT_prefx_misses,
	 ($processor_fullMHT_prefx_misses/$processor_prefxs) * 100.0);
   }
   else {
      printf(STAT "\n%-25s %9d %9.1lf\n", "Prefetch Exclusive", 0, 0.0);
   }

}

sub DO_DPSIM_STATS {
   printf(STAT "DPsim statistics\n\n");

   if ($total_branch_instructions > 0) {
   printf(STAT "%-40s %8d\n", "Total cycles @ 2 slots/cycle:", $total_cycles);
   printf(STAT "%-40s %8d\n", "Total instructions:", $total_instructions);
   printf(STAT "%-40s %5.2f\n", "Percentage slots filled:",
          $total_instructions/(2.0*$total_cycles));
   printf(STAT "\n%-40s %8d\n", "Total ALU instructions:",
          $total_ALU_instructions);
   printf(STAT "%-40s %5.2f\n", "Percentage ALU of total:",
          $total_ALU_instructions/$total_instructions);
   printf(STAT "\n%-40s %8d\n", "Total special ALU instructions:",
          $total_special_ALU_instructions);
   printf(STAT "%-40s %5.2f\n", "Percentage special ALU of ALU:",
          $total_special_ALU_instructions/$total_ALU_instructions);
   printf(STAT "%-40s %5.2f\n", "Percentage special ALU of total:",
          $total_special_ALU_instructions/$total_instructions);
   printf(STAT "\n%-40s %8d\n", "Total branch/jump instructions:",
          $total_branch_instructions);
   printf(STAT "%-40s %5.2f\n", "Percentage branch of total:",
          $total_branch_instructions/$total_instructions);
   printf(STAT "\n%-40s %8d\n", "Total special branch instructions:",
          $total_special_branch_instructions);
   printf(STAT "%-40s %5.2f\n", "Percentage special branch of branch:",
          $total_special_branch_instructions/$total_branch_instructions);
   printf(STAT "%-40s %5.2f\n", "Percentage special branch of total:",
          $total_special_branch_instructions/$total_instructions);
   printf(STAT "\n%-40s %8d\n", "Total ld/st instructions:",
          $total_ldst_instructions);
   printf(STAT "%-40s %5.2f\n", "Percentage ld/st of total:",
          $total_ldst_instructions/$total_instructions);
   printf(STAT "\n%-40s %8d\n", "Total interface instructions:",
          $total_interface_instructions);
   printf(STAT "%-40s %5.2f\n\n", "Percentage interface of total:",
          $total_interface_instructions/$total_instructions);
   }
   else {
      printf(STAT "DPsim not used for this run\n\n");
   }
}

sub DO_READ_CLASSIFICATION_STATS {
   if ($processor_load_misses != 0) {
      printf(STAT "Breakdown of Read Distributions:\n\n");
      printf(STAT "%-40s %8d (%5.2lf%%)\n", "Local, satisfied locally", 
	  $piLocalGetCount - $niLocalPutCount, (($piLocalGetCount - 
	  $niLocalPutCount)/$processor_load_misses)*100.0);
      printf(STAT "%-40s %8d (%5.2lf%%)\n", "Local, satisfied remote", 
	  $niLocalPutCount, ($niLocalPutCount/$processor_load_misses)*100.0);
      printf(STAT "%-40s %8d (%5.2lf%%)\n", "Remote, clean at home",
	  $niRemotePutCount - $dirtyLocalGetCount - $niSharingWritebackCount,
	  (($niRemotePutCount - $dirtyLocalGetCount - $niSharingWritebackCount)
	   / $processor_load_misses) * 100.0);
      printf(STAT "%-40s %8d (%5.2lf%%)\n", "Remote, dirty at home",
	  $dirtyLocalGetCount, ($dirtyLocalGetCount/$processor_load_misses)*
	  100.0);
      printf(STAT "%-40s %8d (%5.2lf%%)\n", "Remote, dirty remote",
	  $niSharingWritebackCount, ($niSharingWritebackCount/
          $processor_load_misses) * 100.0);				     
   }
}

sub DO_HANDLER_STATS {
   printf(STAT "Handler Statistics\n\n");

   printf(STAT "%-40s %8d\n", "Read-Invalidate retries:", 
	  $readInvalidateRetries);
   printf(STAT "%-40s %8d\n", "Upgrade-Invalidate retries:", 
	  $upgradeInvalidateRetries);
   printf(STAT "%-40s %8d\n", "Total Number of Naks:", $numNaks);
   foreach $i (30..$#localReadHist) {
      $numLongReqs += $localReadHist[$i] + $remReadHist[$i] + 
	 $localWriteHist[$i] + $remWriteHist[$i] + $localReadMergeHist[$i]
	 + $remReadMergeHist[$i] + $localWriteMergeHist[$i] +