flstats.pl

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

   }
   if (/^reply_SysAD_stall_time\s+(\d+).*$/) {
      $replySysADStallTime += $1;
   }
   if (/^total_SysAD_read_requests\s+(\d+).*$/) {
      $totalSysADReadRequests += $1;
   }
   if (/^total_SysAD_write_requests\s+(\d+).*$/) {
      $totalSysADWriteRequests += $1;
   }
   if (/^total_SysAD_reply_requests\s+(\d+).*$/) {
      $totalSysADReplyRequests += $1;
   }

#
# Misses
#
   if (/^processor_local_read_misses\s+(\d+).*$/) {
      $localReadMisses += $1;
      $localReadMissArray[$curProc] = $1;
   }
   if (/^processor_rem_read_misses\s+(\d+).*$/) {
      $remReadMisses += $1;
      $remReadMissArray[$curProc] = $1;
   }
   if (/^processor_local_write_misses\s+(\d+).*$/) {
      $localWriteMisses += $1;
#      $localWriteMissArray[$curProc] = $1;
   }
   if (/^processor_rem_write_misses\s+(\d+).*$/) {
      $remWriteMisses += $1;
#      $remWriteMissArray[$curProc] = $1;
   }
   if (/^processor_local_read_miss_latency\s+(\d+).*$/) {
      $localReadMissLatency += $1;
      $localReadMissLatencyArray[$curProc] = $1;
   }
   if (/^processor_rem_read_miss_latency\s+(\d+).*$/) {
      $remReadMissLatency += $1;
      $remReadMissLatencyArray[$curProc] = $1;
   }
   if (/^processor_local_read_hist\[(\d+)\]\s+(\d+).*$/) {
      $localReadHist[$1] += $2;
      if ($localReadHist[$1] > $readHistMax) {
	 $readHistMax = $localReadHist[$1];
      }
   } 
   if (/^processor_rem_read_hist\[(\d+)\]\s+(\d+).*$/) {
      $remReadHist[$1] += $2;
      if ($remReadHist[$1] > $readHistMax) {
	 $readHistMax = $remReadHist[$1];
      }
   } 
   if (/^processor_local_write_miss_latency\s+(\d+).*$/) {
      $localWriteMissLatency += $1;
      $localWriteMissLatencyArray[$curProc] = $1;
   }
   if (/^processor_rem_write_miss_latency\s+(\d+).*$/) {
      $remWriteMissLatency += $1;
      $remWriteMissLatencyArray[$curProc] = $1;
   }
   if (/^processor_local_write_hist\[(\d+)\]\s+(\d+).*$/) {
      $localWriteHist[$1] += $2;
      if ($localWriteHist[$1] > $writeHistMax) {
	 $writeHistMax = $localWriteHist[$1];
      }
   } 
   if (/^processor_rem_write_hist\[(\d+)\]\s+(\d+).*$/) {
      $remWriteHist[$1] += $2;
      if ($remWriteHist[$1] > $writeHistMax) {
	 $writeHistMax = $remWriteHist[$1];
      }
   } 

#
# Merges
#
   if (/^processor_local_read_merges\s+(\d+).*$/) {
      $localReadMerges += $1;
      $processorLdMergeArray[$curProc] += $1;
   }
   if (/^processor_rem_read_merges\s+(\d+).*$/) {
      $remReadMerges += $1;
      $processorLdMergeArray[$curProc] += $1;
   }
   if (/^processor_local_write_merges\s+(\d+).*$/) {
      $localWriteMerges += $1;
      $processorStMergeArray[$curProc] += $1;
   }
   if (/^processor_rem_write_merges\s+(\d+).*$/) {
      $remWriteMerges += $1;
      $processorStMergeArray[$curProc] += $1;
   }
   if (/^processor_local_read_merge_latency\s+(\d+).*$/) {
      $localReadMergeLatency += $1;
      $localReadMergeLatencyArray[$curProc] = $1;
   }
   if (/^processor_rem_read_merge_latency\s+(\d+).*$/) {
      $remReadMergeLatency += $1;
      $remReadMergeLatencyArray[$curProc] = $1;
   }
   if (/^processor_local_read_merge_hist\[(\d+)\]\s+(\d+).*$/) {
      $localReadMergeHist[$1] += $2;
      if ($localReadMergeHist[$1] > $readMergeHistMax) {
	 $readMergeHistMax = $localReadMergeHist[$1];
      }
   } 
   if (/^processor_rem_read_merge_hist\[(\d+)\]\s+(\d+).*$/) {
      $remReadMergeHist[$1] += $2;
      if ($remReadMergeHist[$1] > $readMergeHistMax) {
	 $readMergeHistMax = $remReadMergeHist[$1];
      }
   } 
   if (/^processor_local_write_merge_latency\s+(\d+).*$/) {
      $localWriteMergeLatency += $1;
      $localWriteMergeLatencyArray[$curProc] = $1;
   }
   if (/^processor_rem_write_merge_latency\s+(\d+).*$/) {
      $remWriteMergeLatency += $1;
      $remWriteMergeLatencyArray[$curProc] = $1;
   }
   if (/^processor_local_write_merge_hist\[(\d+)\]\s+(\d+).*$/) {
      $localWriteMergeHist[$1] += $2;
      if ($localWriteMergeHist[$1] > $writeMergeHistMax) {
	 $writeMergeHistMax = $localWriteMergeHist[$1];
      }
   } 
   if (/^processor_rem_write_merge_hist\[(\d+)\]\s+(\d+).*$/) {
      $remWriteMergeHist[$1] += $2;
      if ($remWriteMergeHist[$1] > $writeMergeHistMax) {
	 $writeMergeHistMax = $remWriteMergeHist[$1];
      }
   } 
#
# Conflicts
#
   if (/^processor_local_read_conflicts\s+(\d+).*$/) {
      $localReadConflicts += $1;
      $localReadConflictArray[$curProc] = $1;
      $processorLdConflictArray[$curProc] += $1;
   }
   if (/^processor_rem_read_conflicts\s+(\d+).*$/) {
      $remReadConflicts += $1;
      $remReadConflictArray[$curProc] = $1;
      $processorLdConflictArray[$curProc] += $1;
   }
   if (/^processor_local_write_conflicts\s+(\d+).*$/) {
      $localWriteConflicts += $1;
      $processorStConflictArray[$curProc] += $1;
   }
   if (/^processor_rem_write_conflicts\s+(\d+).*$/) {
      $remWriteConflicts += $1;
      $processorStConflictArray[$curProc] += $1;
   }
   if (/^processor_local_read_conflict_latency\s+(\d+).*$/) {
      $localReadConflictLatency += $1;
      $localReadConflictLatencyArray[$curProc] = $1;
   }
   if (/^processor_rem_read_conflict_latency\s+(\d+).*$/) {
      $remReadConflictLatency += $1;
      $remReadConflictLatencyArray[$curProc] = $1;
   }
   if (/^processor_local_read_conflict_hist\[(\d+)\]\s+(\d+).*$/) {
      $localReadConflictHist[$1] += $2;
      if ($localReadConflictHist[$1] > $readConflictHistMax) {
	 $readConflictHistMax = $localReadConflictHist[$1];
      }
   } 
   if (/^processor_rem_read_conflict_hist\[(\d+)\]\s+(\d+).*$/) {
      $remReadConflictHist[$1] += $2;
      if ($remReadConflictHist[$1] > $readConflictHistMax) {
	 $readConflictHistMax = $remReadConflictHist[$1];
      }
   } 
   if (/^processor_local_write_conflict_latency\s+(\d+).*$/) {
      $localWriteConflictLatency += $1;
#      $localWriteConflictLatencyArray[$curProc] = $1;
   }
   if (/^processor_rem_write_conflict_latency\s+(\d+).*$/) {
      $remWriteConflictLatency += $1;
#      $remWriteConflictLatencyArray[$curProc] = $1;
   }
   if (/^processor_local_write_conflict_hist\[(\d+)\]\s+(\d+).*$/) {
      $localWriteConflictHist[$1] += $2;
      if ($localWriteConflictHist[$1] > $writeConflictHistMax) {
	 $writeConflictHistMax = $localWriteConflictHist[$1];
      }
   } 
   if (/^processor_rem_write_conflict_hist\[(\d+)\]\s+(\d+).*$/) {
      $remWriteConflictHist[$1] += $2;
      if ($remWriteConflictHist[$1] > $writeConflictHistMax) {
	 $writeConflictHistMax = $remWriteConflictHist[$1];
      }
   } 


#
# Invalidation Histograms
#
   if (/^inval_hist\[(\d+)\]\s+(\d+).*$/) {
      $invalHist{$curProc, $1} = $2;
   } 

#
# Queue Histograms
#
   if (/^pi_input_queue_hist\[(\d+)\]\s+(\d+).*$/) {
      $piInputQueueHist{$curProc, $1} = $2;
   }
   if (/^ni_input_req_queue_hist\[(\d+)\]\s+(\d+).*$/) {
      $niInputReqQueueHist{$curProc, $1} = $2;
   }
   if (/^ni_input_rep_queue_hist\[(\d+)\]\s+(\d+).*$/) {
      $niInputRepQueueHist{$curProc, $1} = $2;
   }
   if (/^ni_output_req_queue_hist\[(\d+)\]\s+(\d+).*$/) {
      $niOutputReqQueueHist{$curProc, $1} = $2;
   }
   if (/^ni_output_rep_queue_hist\[(\d+)\]\s+(\d+).*$/) {
      $niOutputRepQueueHist{$curProc, $1} = $2;
   }
   if (/^req_network_queue_hist\[(\d+)\]\s+(\d+).*$/) {
      $reqNetworkQueueHist{$curProc, $1} = $2;
   }
   if (/^rep_network_queue_hist\[(\d+)\]\s+(\d+).*$/) {
      $repNetworkQueueHist{$curProc, $1} = $2;
   }

   ?^dc_cache_size\s+(\d+).*$? && ($ddcache_size = $1);
   ?^dc_assoc\s+(\d+).*$? && ($ddcache_assoc = $1);
   ?^dc_replacement_policy\s+(\w+).*$? && ($ddcache_replacement = $1);
   /^dc_cache_ops\s+(\d+).*$/ && ($ddcache_ops += $1);
   /^dc_cache_reads\s+(\d+).*$/ && ($ddcache_reads += $1);
   /^dc_cache_writes\s+(\d+).*$/ && ($ddcache_writes += $1);
   /^dc_cache_hits\s+(\d+).*$/ && ($ddcache_hits += $1);
   /^dc_cache_read_hits\s+(\d+).*$/ && ($ddcache_read_hits += $1);
   /^dc_cache_write_hits\s+(\d+).*$/ && ($ddcache_write_hits += $1);
   /^dc_cache_read_misses\s+(\d+).*$/ && ($ddcache_read_misses += $1);
   /^dc_cache_write_misses\s+(\d+).*$/ && ($ddcache_write_misses += $1);

   ?^dc_icache_size\s+(\d+).*$? && ($dicache_size = $1);
   ?^dc_icache_assoc\s+(\d+).*$? && ($dicache_assoc = $1);
   ?^dc_icache_replacement_policy\s+(\w+).*$? && ($dicache_replacement = $1);
   /^dc_icache_ops\s+(\d+).*$/ && ($dicache_ops += $1);
   /^dc_icache_reads\s+(\d+).*$/ && ($dicache_reads += $1);
   /^dc_icache_writes\s+(\d+).*$/ && ($dicache_writes += $1);
   /^dc_icache_hits\s+(\d+).*$/ && ($dicache_hits += $1);
   /^dc_icache_read_hits\s+(\d+).*$/ && ($dicache_read_hits += $1);
   /^dc_icache_write_hits\s+(\d+).*$/ && ($dicache_write_hits += $1);
   /^dc_icache_read_misses\s+(\d+).*$/ && ($dicache_read_misses += $1);
   /^dc_icache_write_misses\s+(\d+).*$/ && ($dicache_write_misses += $1);

   /^SW_queue_final_count\s+(\d+).*$/ && ($swqueue_final += $1);
   /^SW_queue_re-entries\s+(\d+).*$/ && ($swqueue_retries += $1);
   /^reads_cancelled_by_full_SW_queue\s+(\d+).*$/ && ($swqueue_cancels += $1);
   if (/^PI_queue_max_count\s+(\d+).*$/) {
      $piInputQueue_max_sum += $1;
      if ($1 > $piInputQueue_max) {
	 $piInputQueue_max = $1;
      }
   }
   if (/^NI_req_in_queue_max_count\s+(\d+).*$/) {
      $niInputReqQueue_max_sum += $1;
      if ($1 > $niInputReqQueue_max) {
	 $niInputReqQueue_max = $1;
      }
   }
   if (/^NI_rep_in_queue_max_count\s+(\d+).*$/) {
      $niInputRepQueue_max_sum += $1;
      if ($1 > $niInputRepQueue_max) {
	 $niInputRepQueue_max = $1;
      }
   }
   if (/^Req_out_queue_max_count\s+(\d+).*$/) {
      $niOutputReqQueue_max_sum += $1;
      if ($1 > $niOutputReqQueue_max) {
	 $niOutputReqQueue_max = $1;
      }
   }
   if (/^Rep_out_queue_max_count\s+(\d+).*$/) {
      $niOutputRepQueue_max_sum += $1;
      if ($1 > $niOutputRepQueue_max) {
	 $niOutputRepQueue_max = $1;
      }
   }
#   /^time_in_memory_queue\s+(\d+).*$/ && ($memTime = $1);
   if (/^SysAD_occupancy\s+(\d+).*$/) {
      $sysADBusOccupancy = (($1/$executionTimeSinceReset[$curProc])*100.0);
      if ($sysADBusOccupancy > $sysADBusOccupancy_max) {
	 $sysADBusOccupancy_max = $sysADBusOccupancy;
      }
      $sysADBusOccupancy_sum += $sysADBusOccupancy;
   }
   if (/^Inbox_occupancy\s+(\d+).*$/) {
      $inboxOccupancy = (($1/$executionTimeSinceReset[$curProc])*100.0);
      if ($inboxOccupancy > $inboxOccupancy_max) {
	 $inboxOccupancy_max = $inboxOccupancy;
      }
      $inboxOccupancy_sum += $inboxOccupancy;
   }
   if (/^DP_occupancy\s+(\d+).*$/) {
      $dpOccupancy = (($1/$executionTimeSinceReset[$curProc])*100.0);
      if ($dpOccupancy > $dpOccupancy_max) {
	 $dpOccupancy_max = $dpOccupancy;
      }
      $dpOccupancy_sum += $dpOccupancy;
   }
   if (/^time_in_memory\s+(\d+).*$/) {
      $memTime = $1;
      $memOccupancy = (($1/$executionTimeSinceReset[$curProc])*100.0);
      if ($memOccupancy > $memOccupancy_max) {
	 $memOccupancy_max = $memOccupancy;
      }
      $memOccupancy_sum += $memOccupancy;
   }
   if (/^NI_request_occupancy\s+(\d+).*$/) {
      $niReqOccupancy = (($1/$executionTimeSinceReset[$curProc])*100.0);
      if ($niReqOccupancy > $niReqOccupancy_max) {
	 $niReqOccupancy_max = $niReqOccupancy;
      }
      $niReqOccupancy_sum += $niReqOccupancy;
   }
   if (/^NI_reply_occupancy\s+(\d+).*$/) {
      $niRepOccupancy = (($1/$executionTimeSinceReset[$curProc])*100.0);
      if ($niRepOccupancy > $niRepOccupancy_max) {
	 $niRepOccupancy_max = $niRepOccupancy;
      }
      $niRepOccupancy_sum += $niRepOccupancy;
   }
   if (/^NI_request_in_occupancy\s+(\d+).*$/) {
      $niReqInOccupancy = (($1/$executionTimeSinceReset[$curProc])*100.0);
      if ($niReqInOccupancy > $niReqInOccupancy_max) {
	 $niReqInOccupancy_max = $niReqInOccupancy;
      }
      $niReqInOccupancy_sum += $niReqInOccupancy;
   }
   if (/^NI_reply_in_occupancy\s+(\d+).*$/) {
      $niRepInOccupancy = (($1/$executionTimeSinceReset[$curProc])*100.0);
      if ($niRepInOccupancy > $niRepInOccupancy_max) {
	 $niRepInOccupancy_max = $niRepInOccupancy;
      }
      $niRepInOccupancy_sum += $niRepInOccupancy;
   }
   if (/^PI_in_occupancy\s+(\d+).*$/) {
      $piInOccupancy = (($1/$executionTimeSinceReset[$curProc])*100.0);
      if ($piInOccupancy > $piInOccupancy_max) {
	 $piInOccupancy_max = $piInOccupancy;
      }
      $piInOccupancy_sum += $piInOccupancy;
   }
   if (/^PI_out_occupancy\s+(\d+).*$/) {