correct the L2 sector cache bypassbit merging(or merging) and parse misprediction rate for each hashPC

Author: cwpeng0511

src/gpgpu-sim/gpu-cache.cc

@@ -643,13 +643,13 @@ void tag_array::fill(new_addr_type addr, unsigned time, mem_fetch *mf, //on-fill
                      uint8_t *l1d_prediction_table,uint8_t hashed_pc //cwpeng
                     ) { 
   fill(addr, time, mf->get_access_sector_mask(), mf->get_access_byte_mask(),
-       is_write, l1d_prediction_table, hashed_pc, mf->get_bypassBit());
+       is_write, l1d_prediction_table, hashed_pc, mf->get_bypassBit(), mf); // cwpeng mf for print PC
 }
 
 void tag_array::fill(new_addr_type addr, unsigned time, //on-fill
                      mem_access_sector_mask_t mask,
                      mem_access_byte_mask_t byte_mask, bool is_write,
-                     uint8_t *l1d_prediction_table,uint8_t hashed_pc, bool bypassBit
+                     uint8_t *l1d_prediction_table,uint8_t hashed_pc, bool bypassBit, mem_fetch *mf
                   ) {
   // assert( m_config.m_alloc_policy == ON_FILL );
   unsigned idx;
@@ -675,13 +675,17 @@ void tag_array::fill(new_addr_type addr, unsigned time, //on-fill
   }
   if(isBypassed){
     if(bypassBit){
-      // printf("L2 indicate misprediction, bypassbit = 1\n") ;
+      printf("L2 indicate misprediction, bypassbit = 1, PC=%llx\n", mf->get_pc()); ;
       // l1d_prediction_table[hashed_pc] = threshold-1 ;
       isBypassed = false ; // if L2 indicates misprediction, do not bypass
+      l1_cache::inst_stats[hashed_pc].misprediction_time++ ;
+    }
+    else{
+      l1_cache::inst_stats[hashed_pc].no_misprediction_time++ ; 
     }
   }
 
-  // isBypassed = false ;
+  // isBypassed = false ; // For testing without bypass
 
 
   if(l1d_prediction_table[m_lines[idx]->m_hashed_pc] < 15 && victim_valid && isBypassed==false) //&& m_tag_array->get_hashed_pc_from_tag(addr)->is_valid_line()) // AISH Saturating counter stays at 15
@@ -1587,6 +1591,7 @@ void baseline_cache::fill(mem_fetch *mf, unsigned time, uint8_t *l1d_prediction_
 
     if (e->second.pending_read > 0) {
       // wait for the other requests to come back
+      // printf("pending_read=%d\n", e->second.pending_read);
       delete mf;
       return;
     } else {
@@ -2645,16 +2650,17 @@ void l1_cache::print_prediction_table(FILE *fp, unsigned core_id) const {
 }
 
 void l1_cache::print_ldst_inst_stats(FILE *fp){
-  fprintf(fp, "L1D Prediction Table State:\n");
+  fprintf(fp, "L1D Prediction Table Stats:\n");
   for(unsigned i = 0; i < 256; i++){
-    fprintf(fp, "HashPC:%3d: access time %8d, hit_rate:%1.5f, L2 access time:%7d, bypass_rate:%1.5f, occupy_l1_count:%8d, reuse_rate:%1.5f\n", 
+    fprintf(fp, "HashPC:%3d: access time %8d, hit_rate:%1.5f, L2 access time:%7d, bypass_rate:%1.5f, occupy_l1_count:%8d, reuse_rate:%1.5f, mispredict_rate:%1.5f\n", 
       i, 
       inst_stats[i].access_time,
       inst_stats[i].get_hit_rate(),
       inst_stats[i].get_l2_access_time(),
       inst_stats[i].get_bypass_rate(),
       inst_stats[i].no_reuse_time + inst_stats[i].reuse_time,
-      inst_stats[i].get_reuse_rate()
+      inst_stats[i].get_reuse_rate(),
+      inst_stats[i].get_misprediction_rate()
     );
   }
   fprintf(fp, "========================================================================\n");

src/gpgpu-sim/gpu-cache.h

@@ -988,7 +988,7 @@ class tag_array {
   void fill(new_addr_type addr, unsigned time, mem_access_sector_mask_t mask,
             mem_access_byte_mask_t byte_mask, bool is_write);
   void fill(new_addr_type addr, unsigned time, mem_access_sector_mask_t mask,
-            mem_access_byte_mask_t byte_mask, bool is_write, uint8_t *l1d_prediction_table,uint8_t hashed_pc, bool bypassBit); // cwpeng
+            mem_access_byte_mask_t byte_mask, bool is_write, uint8_t *l1d_prediction_table,uint8_t hashed_pc, bool bypassBit, mem_fetch *mf); // cwpeng
 
   unsigned size() const { return m_config.get_num_lines(); }
   cache_block_t *get_block(unsigned idx) { return m_lines[idx]; }
@@ -1782,6 +1782,8 @@ class ldst_inst_stats{ // cwpeng
   uint64_t not_bypass_time ;
   uint64_t reuse_time ;
   uint64_t no_reuse_time ;
+  uint64_t misprediction_time ;
+  uint64_t no_misprediction_time ;
 
   double get_hit_rate(){
     if(hit_time+miss_time==0) return 0.0 ;
@@ -1801,6 +1803,11 @@ class ldst_inst_stats{ // cwpeng
     if(reuse_time+no_reuse_time==0) return 0.0 ;
     return (double)reuse_time/(double)(reuse_time+no_reuse_time) ;
   }
+
+  double get_misprediction_rate(){
+    if(misprediction_time+no_misprediction_time==0) return 0.0 ;
+    return (double)misprediction_time/(double)(misprediction_time+no_misprediction_time) ;
+  }
 } ;
 
 /// This is meant to model the first level data cache in Fermi.

src/gpgpu-sim/l2cache.cc

@@ -546,9 +546,10 @@ void memory_sub_partition::cache_cycle(unsigned cycle) {
                 bool isBypassed = mf->get_isBypassed();
                 bool bypassBit = m_L2cache->get_bypass_bit_from_l2(mf->get_addr(), mf); // Read existing bypass bit from L2
                 mf->set_bypassBit(bypassBit); // Set the bypass bit in mf to be sent back to L1
-                // if(bypassBit){
-                //   m_L2cache->set_bypass_bit_from_l2(mf->get_addr(), mf, false);
-                // }
+                if(bypassBit){
+                  // m_L2cache->set_bypass_bit_from_l2(mf->get_addr(), mf, false);
+                  mf->get_original_mf()->set_bypassBit(true); // Also set the bypass bit in original mf to be sent back to L1
+                }
                 // else{
                 //   m_L2cache->set_bypass_bit_from_l2(mf->get_addr(), mf, isBypassed);
                 // }
@@ -729,7 +730,7 @@ bool memory_sub_partition::busy() const { return !m_request_tracker.empty(); }
 
 std::vector<mem_fetch *>
 memory_sub_partition::breakdown_request_to_sector_requests(mem_fetch *mf) {
-  // printf("L2 access data size: %d, from L1? %b\n", mf->get_data_size(), mf->get_L1toL2());
+  // printf("L2 access data size: %d, from L1? %b, PC:%llx\n", mf->get_data_size(), mf->get_L1toL2(), mf->get_pc());
   std::vector<mem_fetch *> result;
   mem_access_sector_mask_t sector_mask = mf->get_access_sector_mask();
   if (mf->get_data_size() == SECTOR_SIZE &&