Changeset 81 for trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src

Timestamp:

Apr 15, 2008, 8:40:01 PM (16 years ago)

Author:

rosiere

Message:

• Finish Environment (and test)
• Continue predictor_unit
• Add external tools
• svn keyword "Id" set

Location:

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src

Files:

• Parameters.cpp (modified) (2 diffs, 1 prop)
• Parameters_msg_error.cpp (modified) (1 diff, 1 prop)
• Parameters_print.cpp (modified) (1 diff, 1 prop)
• Update_Prediction_Table.cpp (modified) (3 diffs, 1 prop)
• Update_Prediction_Table_allocation.cpp (modified) (1 diff, 1 prop)
• Update_Prediction_Table_deallocation.cpp (modified) (1 diff, 1 prop)
• Update_Prediction_Table_end_cycle.cpp (modified) (1 prop)
• Update_Prediction_Table_genMealy_branch_complete.cpp (added)
• Update_Prediction_Table_genMealy_decod.cpp (added)
• Update_Prediction_Table_genMealy_predict.cpp (added)
• Update_Prediction_Table_genMoore.cpp (added)
• Update_Prediction_Table_statistics_allocation.cpp (modified) (1 prop)
• Update_Prediction_Table_statistics_deallocation.cpp (modified) (1 prop)
• Update_Prediction_Table_transition.cpp (modified) (1 diff, 1 prop)
• Update_Prediction_Table_vhdl.cpp (modified) (1 prop)
• Update_Prediction_Table_vhdl_body.cpp (modified) (1 prop)
• Update_Prediction_Table_vhdl_declaration.cpp (modified) (1 prop)

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src/Parameters.cpp

@@ -7 +7 @@
 
 #include "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/include/Parameters.h"
+#include "Common/include/Max.h"
 
 namespace morpheo {
@@ -19 +20 @@
 #undef  FUNCTION
 #define FUNCTION "Update_Prediction_Table::Parameters"
-  Parameters::Parameters ()
+  Parameters::Parameters (uint32_t   nb_context             ,
+                          uint32_t * size_queue             ,
+                          uint32_t   size_address           ,
+                          uint32_t   nb_inst_predict        ,
+                          uint32_t   nb_inst_decod          ,
+                          uint32_t   nb_inst_branch_complete,
+                          uint32_t   nb_inst_update         ,
+                          uint32_t   size_history           ,
+                          uint32_t * size_ras_index         )
   {
     log_printf(FUNC,Update_Prediction_Table,FUNCTION,"Begin");
+
+    _nb_context              = nb_context             ;
+    _size_queue              = size_queue             ;
+    _size_address            = size_address           ;
+    _nb_inst_predict         = nb_inst_predict        ;
+    _nb_inst_decod           = nb_inst_decod          ;
+    _nb_inst_branch_complete = nb_inst_branch_complete;
+    _nb_inst_update          = nb_inst_update         ;
+    _size_history            = size_history           ;
+    _size_ras_index          = size_ras_index         ;
+    
+    _size_context_id         = log2(nb_context);
+    _size_depth              = log2(max<uint32_t>(size_queue,nb_context));
+    _max_size_ras_index      = max<uint32_t>(_size_ras_index,nb_context);
+
+    _have_port_context_id    = _size_context_id> 0;
+    _have_port_depth         = _size_depth     > 0;
+    _have_port_history       = _size_history   > 0;
+    
     test();
     log_printf(FUNC,Update_Prediction_Table,FUNCTION,"End");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src/Parameters_msg_error.cpp

@@ -27 +27 @@
     Parameters_test test ("Update_Prediction_Table");
 
+    if (morpheo::behavioural::test<Tdepth_t>(_size_depth) == false)
+      test.error("type \"Tdepth_t\" is too small.");
+
     log_printf(FUNC,Update_Prediction_Table,FUNCTION,"End");
 

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src/Parameters_print.cpp

@@ -27 +27 @@
 
     xml.balise_open("update_prediction_table");
-//  xml.singleton_begin(""); xml.attribut("value",toString(_)); xml.singleton_end();
+    xml.singleton_begin("nb_context             "); xml.attribut("value",toString(_nb_context             )); xml.singleton_end();
+    xml.singleton_begin("size_address           "); xml.attribut("value",toString(_size_address           )); xml.singleton_end();
+    xml.singleton_begin("nb_inst_predict        "); xml.attribut("value",toString(_nb_inst_predict        )); xml.singleton_end();
+    xml.singleton_begin("nb_inst_decod          "); xml.attribut("value",toString(_nb_inst_decod          )); xml.singleton_end();
+    xml.singleton_begin("nb_inst_branch_complete"); xml.attribut("value",toString(_nb_inst_branch_complete)); xml.singleton_end();
+    xml.singleton_begin("nb_inst_update         "); xml.attribut("value",toString(_nb_inst_update         )); xml.singleton_end();
+    xml.singleton_begin("size_history           "); xml.attribut("value",toString(_size_history           )); xml.singleton_end();
+    for (uint32_t i=0;i<_nb_context; i++)
+      {
+        xml. balise_open_begin("component");
+        xml.  attribut("type","context");
+        xml.  attribut("id"  ,toString(i));
+        xml. balise_open_end();
+        xml.  singleton_begin("size_queue             "); xml.attribut("value",toString(_size_queue             [i])); xml.singleton_end();
+        xml.  singleton_begin("size_ras_index         "); xml.attribut("value",toString(_size_ras_index         [i])); xml.singleton_end();
+        xml. balise_close();
+      }
     xml.balise_close();
 

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src/Update_Prediction_Table.cpp

@@ -38 +38 @@
     log_printf(FUNC,Update_Prediction_Table,FUNCTION,"Begin");
 
+    usage_environment(_usage);
+
     log_printf(INFO,Update_Prediction_Table,FUNCTION,"Allocation");
 
@@ -68 +70 @@
     if (_usage & USE_SYSTEMC)
       {
+
+        for (uint32_t i=0; i<_param->_nb_inst_branch_complete; i++)
+          {
+            internal_BRANCH_COMPLETE_ACK [i] = 1;
+            PORT_WRITE(out_BRANCH_COMPLETE_ACK [i], internal_BRANCH_COMPLETE_ACK [i]);
+          }
+
         log_printf(INFO,Update_Prediction_Table,FUNCTION,"Method - transition");
 
@@ -76 +85 @@
 # ifdef SYSTEMCASS_SPECIFIC
         // List dependency information
+# endif    
+
+        log_printf(INFO,Update_Prediction_Table,FUNCTION,"Method - genMoore");
+
+        SC_METHOD (genMoore);
+        dont_initialize ();
+        sensitive << (*(in_CLOCK)).neg();
+        
+# ifdef SYSTEMCASS_SPECIFIC
+        // List dependency information
+# endif    
+
+        log_printf(INFO,Update_Prediction_Table,FUNCTION,"Method - genMealy_predict");
+
+        SC_METHOD (genMealy_predict);
+        dont_initialize ();
+        sensitive << (*(in_CLOCK)).neg(); // use internal register
+        for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
+          {
+            if (_param->_have_port_context_id)
+              sensitive << (*(in_PREDICT_CONTEXT_ID [i]));
+            sensitive << (*(in_PREDICT_BTB_IS_ACCURATE [i]));
+          }
+        
+# ifdef SYSTEMCASS_SPECIFIC
+        // List dependency information
+        for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
+          {
+            (*(out_PREDICT_ACK                  [i])) (*(in_PREDICT_BTB_IS_ACCURATE [i]));
+            if (_param->_have_port_context_id)
+            (*(out_PREDICT_ACK                  [i])) (*(in_PREDICT_CONTEXT_ID      [i]));
+          }
+# endif    
+
+        log_printf(INFO,Update_Prediction_Table,FUNCTION,"Method - genMealy_decod");
+
+        SC_METHOD (genMealy_decod);
+        dont_initialize ();
+        sensitive << (*(in_CLOCK)).neg(); // use internal register
+        for (uint32_t i=0; i<_param->_nb_inst_decod; i++)
+          {
+            if (_param->_have_port_context_id)
+              sensitive << (*(in_DECOD_CONTEXT_ID [i]));
+            sensitive << (*(in_DECOD_MISS_PREDICTION [i]));
+          }
+        
+# ifdef SYSTEMCASS_SPECIFIC
+        // List dependency information
+        for (uint32_t i=0; i<_param->_nb_inst_decod; i++)
+          {
+            (*(out_DECOD_ACK                  [i])) (*(in_DECOD_MISS_PREDICTION [i]));
+            if (_param->_have_port_context_id)
+            (*(out_DECOD_ACK                  [i])) (*(in_DECOD_CONTEXT_ID      [i]));
+          }
+# endif    
+
+        log_printf(INFO,Update_Prediction_Table,FUNCTION,"Method - genMealy_branch_complete");
+
+        SC_METHOD (genMealy_branch_complete);
+        dont_initialize ();
+        sensitive << (*(in_CLOCK)).neg(); // use internal register
+        for (uint32_t i=0; i<_param->_nb_inst_branch_complete; i++)
+          {
+            if (_param->_have_port_context_id)
+            sensitive << (*(in_BRANCH_COMPLETE_CONTEXT_ID [i]));
+            if (_param->_have_port_depth)
+            sensitive << (*(in_BRANCH_COMPLETE_DEPTH [i]));
+            sensitive << (*(in_BRANCH_COMPLETE_FLAG    [i]))
+                      << (*(in_BRANCH_COMPLETE_ADDRESS [i]));
+          }
+        
+# ifdef SYSTEMCASS_SPECIFIC
+        // List dependency information
+        for (uint32_t i=0; i<_param->_nb_inst_branch_complete; i++)
+          {
+            if (_param->_have_port_context_id)
+            (*(out_BRANCH_COMPLETE_MISS_PREDICTION [i])) (*(in_BRANCH_COMPLETE_CONTEXT_ID [i]));
+            if (_param->_have_port_depth)
+            (*(out_BRANCH_COMPLETE_MISS_PREDICTION [i])) (*(in_BRANCH_COMPLETE_DEPTH      [i]));
+            (*(out_BRANCH_COMPLETE_MISS_PREDICTION [i])) (*(in_BRANCH_COMPLETE_FLAG       [i]));
+            (*(out_BRANCH_COMPLETE_MISS_PREDICTION [i])) (*(in_BRANCH_COMPLETE_ADDRESS    [i]));
+
+            if (_param->_have_port_context_id)
+            (*(out_BRANCH_COMPLETE_TAKE            [i])) (*(in_BRANCH_COMPLETE_CONTEXT_ID [i]));
+            if (_param->_have_port_depth)
+            (*(out_BRANCH_COMPLETE_TAKE            [i])) (*(in_BRANCH_COMPLETE_DEPTH      [i]));
+            (*(out_BRANCH_COMPLETE_TAKE            [i])) (*(in_BRANCH_COMPLETE_FLAG       [i]));
+
+            if (_param->_have_port_context_id)
+            (*(out_BRANCH_COMPLETE_ADDRESS_SRC     [i])) (*(in_BRANCH_COMPLETE_CONTEXT_ID [i]));
+            if (_param->_have_port_depth)
+            (*(out_BRANCH_COMPLETE_ADDRESS_SRC     [i])) (*(in_BRANCH_COMPLETE_DEPTH      [i]));
+
+            if (_param->_have_port_context_id)
+            (*(out_BRANCH_COMPLETE_ADDRESS_DEST    [i])) (*(in_BRANCH_COMPLETE_CONTEXT_ID [i]));
+            if (_param->_have_port_depth)
+            (*(out_BRANCH_COMPLETE_ADDRESS_DEST    [i])) (*(in_BRANCH_COMPLETE_DEPTH      [i]));
+            (*(out_BRANCH_COMPLETE_ADDRESS_DEST    [i])) (*(in_BRANCH_COMPLETE_ADDRESS    [i]));
+          }
 # endif    
         

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src/Update_Prediction_Table_allocation.cpp

@@ -55 +55 @@
       in_NRESET       = interface->set_signal_in  <Tcontrol_t> ("nreset",1, RESET_VHDL_YES);
     }
+
+    // ~~~~~[ Interface : "predict" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+      ALLOC1_INTERFACE("predict", IN,SOUTH, "predict", _param->_nb_inst_predict);
+      
+      ALLOC1_VALACK_IN ( in_PREDICT_VAL                 ,VAL);
+      ALLOC1_VALACK_OUT(out_PREDICT_ACK                 ,ACK);
+      ALLOC1_SIGNAL_IN ( in_PREDICT_CONTEXT_ID          ,"context_id"          ,Tcontext_t         ,_param->_size_context_id);
+      ALLOC1_SIGNAL_IN ( in_PREDICT_BTB_ADDRESS_SRC     ,"btb_address_src"     ,Taddress_t         ,_param->_size_address);
+      ALLOC1_SIGNAL_IN ( in_PREDICT_BTB_ADDRESS_DEST    ,"btb_address_dest"    ,Taddress_t         ,_param->_size_address);
+      ALLOC1_SIGNAL_IN ( in_PREDICT_BTB_CONDITION       ,"btb_condition"       ,Tbranch_condition_t,_param->_size_branch_condition);
+      ALLOC1_SIGNAL_IN ( in_PREDICT_BTB_LAST_TAKE       ,"btb_last_take"       ,Tcontrol_t         ,1);
+      ALLOC1_SIGNAL_IN ( in_PREDICT_BTB_IS_ACCURATE     ,"btb_is_accurate"     ,Tcontrol_t         ,1);
+      ALLOC1_SIGNAL_IN ( in_PREDICT_DIR_HISTORY         ,"dir_history"         ,Thistory_t         ,_param->_size_history);
+      ALLOC1_SIGNAL_IN ( in_PREDICT_RAS_ADDRESS         ,"ras_address"         ,Taddress_t         ,_param->_size_address);
+      ALLOC1_SIGNAL_IN ( in_PREDICT_RAS_INDEX           ,"ras_index"           ,Tptr_t             ,_param->_max_size_ras_index);
+//       ALLOC1_SIGNAL_OUT(out_PREDICT_UPDATE_PREDICTION_ID,"update_prediction_id",Tprediction_ptr_t  ,_param->_size_depth);
+    }
+
+    // ~~~~~[ Interface : "decod" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+      ALLOC1_INTERFACE("predict", IN,SOUTH, "predict", _param->_nb_inst_predict);
+
+      ALLOC1_VALACK_IN ( in_DECOD_VAL                 ,VAL);
+      ALLOC1_VALACK_OUT(out_DECOD_ACK                 ,ACK);
+      ALLOC1_SIGNAL_IN ( in_DECOD_CONTEXT_ID          ,"context_id"          ,Tcontext_t         ,_param->_size_context_id);
+      ALLOC1_SIGNAL_IN ( in_DECOD_BTB_ADDRESS_SRC     ,"btb_address_src"     ,Taddress_t         ,_param->_size_address);
+      ALLOC1_SIGNAL_IN ( in_DECOD_BTB_ADDRESS_DEST    ,"btb_address_dest"    ,Taddress_t         ,_param->_size_address);
+      ALLOC1_SIGNAL_IN ( in_DECOD_BTB_CONDITION       ,"btb_condition"       ,Tbranch_condition_t,_param->_size_branch_condition);
+      ALLOC1_SIGNAL_IN ( in_DECOD_BTB_LAST_TAKE       ,"btb_last_take"       ,Tcontrol_t         ,1);
+      ALLOC1_SIGNAL_IN ( in_DECOD_RAS_ADDRESS         ,"ras_address"         ,Taddress_t         ,_param->_size_address);
+      ALLOC1_SIGNAL_IN ( in_DECOD_RAS_INDEX           ,"ras_index"           ,Tptr_t             ,_param->_max_size_ras_index);
+      ALLOC1_SIGNAL_IN ( in_DECOD_MISS_PREDICTION     ,"miss_prediction"     ,Tcontrol_t         ,1);
+      ALLOC1_SIGNAL_IN ( in_DECOD_UPDATE_PREDICTION_ID,"update_prediction_id",Tprediction_ptr_t  ,_param->_size_depth);
+//    ALLOC1_SIGNAL_OUT(out_DECOD_DEPTH               ,"depth"               ,Tdepth_t           ,_param->_size_depth);
+    }
+
+    // ~~~~~[ Interface : "branch_complete" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+      ALLOC1_INTERFACE("branch_complete", IN,SOUTH, "branch_complete", _param->_nb_inst_branch_complete);
+
+      
+      ALLOC1_VALACK_IN ( in_BRANCH_COMPLETE_VAL            ,VAL);
+      ALLOC1_VALACK_OUT(out_BRANCH_COMPLETE_ACK            ,ACK);
+      ALLOC1_SIGNAL_IN ( in_BRANCH_COMPLETE_CONTEXT_ID     ,"context_id"     ,Tcontext_t,_param->_size_context_id);
+      ALLOC1_SIGNAL_IN ( in_BRANCH_COMPLETE_DEPTH          ,"depth"          ,Tdepth_t  ,_param->_size_depth);
+      ALLOC1_SIGNAL_IN ( in_BRANCH_COMPLETE_ADDRESS        ,"address"        ,Taddress_t,_param->_size_address);
+      ALLOC1_SIGNAL_IN ( in_BRANCH_COMPLETE_FLAG           ,"flag"           ,Tcontrol_t,1);
+      ALLOC1_SIGNAL_OUT(out_BRANCH_COMPLETE_MISS_PREDICTION,"miss_prediction",Tcontrol_t,1);
+      ALLOC1_SIGNAL_OUT(out_BRANCH_COMPLETE_TAKE           ,"take"           ,Tcontrol_t,1);
+      ALLOC1_SIGNAL_OUT(out_BRANCH_COMPLETE_ADDRESS_SRC    ,"address_src"    ,Taddress_t,_param->_size_address);
+      ALLOC1_SIGNAL_OUT(out_BRANCH_COMPLETE_ADDRESS_DEST   ,"address_dest"   ,Taddress_t,_param->_size_address);
+    }
+
+    // ~~~~~[ Interface : "update" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+      ALLOC1_INTERFACE("update",OUT,SOUTH, "update", _param->_nb_inst_update);
+
+      ALLOC1_VALACK_OUT(out_UPDATE_VAL                  ,VAL);
+      ALLOC1_VALACK_IN ( in_UPDATE_ACK                  ,ACK);
+      ALLOC1_SIGNAL_OUT(out_UPDATE_CONTEXT_ID           ,"context_id"           ,Tcontext_t         ,_param->_size_context_id);
+      ALLOC1_SIGNAL_OUT(out_UPDATE_MISS_PREDICTION      ,"miss_prediction"      ,Tcontrol_t         ,1);
+      ALLOC1_SIGNAL_OUT(out_UPDATE_DIRECTION_GOOD       ,"direction_good"       ,Tcontrol_t         ,1);
+      ALLOC1_SIGNAL_OUT(out_UPDATE_BTB_VAL              ,"btb_val"              ,Tcontrol_t         ,1);
+      ALLOC1_SIGNAL_OUT(out_UPDATE_BTB_ADDRESS_SRC      ,"btb_address_src"      ,Taddress_t         ,_param->_size_address);
+      ALLOC1_SIGNAL_OUT(out_UPDATE_BTB_ADDRESS_DEST     ,"btb_address_dest"     ,Taddress_t         ,_param->_size_address);
+      ALLOC1_SIGNAL_OUT(out_UPDATE_BTB_CONDITION        ,"btb_condition"        ,Tbranch_condition_t,_param->_size_branch_condition);
+      ALLOC1_SIGNAL_OUT(out_UPDATE_DIR_VAL              ,"dir_val"              ,Tcontrol_t         ,1);
+      ALLOC1_SIGNAL_OUT(out_UPDATE_DIR_HISTORY          ,"dir_history"          ,Thistory_t         ,_param->_size_history);
+      ALLOC1_SIGNAL_OUT(out_UPDATE_RAS_VAL              ,"ras_val"              ,Tcontrol_t         ,1);
+      ALLOC1_SIGNAL_OUT(out_UPDATE_RAS_ADDRESS          ,"ras_address"          ,Taddress_t         ,_param->_size_address);
+      ALLOC1_SIGNAL_OUT(out_UPDATE_RAS_INDEX            ,"ras_index"            ,Tptr_t             ,_param->_max_size_ras_index);
+      ALLOC1_SIGNAL_OUT(out_UPDATE_RAS_PREDICTION_IFETCH,"ras_prediction_ifetch",Tcontrol_t         ,1);
+    }
+
+    // ~~~~~[ Interface : "depth" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+      ALLOC1_INTERFACE("depth",OUT,SOUTH, "depth", _param->_nb_context);
+
+      ALLOC1_SIGNAL_OUT(out_DEPTH_NB_BRANCH,"NB_BRANCH",Tdepth_t,_param->_size_depth);
+      ALLOC1_SIGNAL_OUT(out_DEPTH_TAIL,"TAIL",Tdepth_t,_param->_size_depth);
+    }
+
+    // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    internal_PREDICT_ACK                     = new Tcontrol_t [_param->_nb_inst_predict];
+    internal_DECOD_ACK                       = new Tcontrol_t [_param->_nb_inst_decod];
+    internal_BRANCH_COMPLETE_ACK             = new Tcontrol_t [_param->_nb_inst_branch_complete];
+    internal_BRANCH_COMPLETE_MISS_PREDICTION = new Tcontrol_t [_param->_nb_inst_branch_complete];
+    internal_BRANCH_COMPLETE_TAKE            = new Tcontrol_t [_param->_nb_inst_branch_complete];
+    internal_BRANCH_COMPLETE_ADDRESS_DEST    = new Taddress_t [_param->_nb_inst_branch_complete];
+    internal_UPDATE_VAL                      = new Tcontrol_t [_param->_nb_inst_update];
+    internal_UPDATE_CONTEXT_ID               = new Tcontext_t [_param->_nb_inst_update];
+    internal_UPDATE_DEPTH                    = new Tdepth_t   [_param->_nb_inst_update];
+
+    // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    
+    reg_TOP                     = new uint32_t  [_param->_nb_context];
+    reg_BOTTOM                  = new uint32_t  [_param->_nb_context];
+    reg_NB_ELT                  = new uint32_t  [_param->_nb_context];
+    reg_NB_ELT_NEED_UPDATE      = new uint32_t  [_param->_nb_context];
+    reg_UPDATE_PREDICTION_TABLE = new entry_t * [_param->_nb_context];
+    for (uint32_t i=0; i<_param->_nb_context; i++)
+      {
+#ifndef NO_INIT
+        reg_TOP [i] = 0;
+#endif
+        reg_UPDATE_PREDICTION_TABLE [i] = new entry_t [_param->_size_queue[i]];
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    
 

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src/Update_Prediction_Table_deallocation.cpp

@@ -27 +27 @@
         delete    in_CLOCK ;
         delete    in_NRESET;
+
+        // ~~~~~[ Interface : "predict" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        delete []  in_PREDICT_VAL                 ;
+        delete [] out_PREDICT_ACK                 ;
+        if (_param->_have_port_context_id)
+        delete []  in_PREDICT_CONTEXT_ID          ;
+        delete []  in_PREDICT_BTB_ADDRESS_SRC     ;
+        delete []  in_PREDICT_BTB_ADDRESS_DEST    ;
+        delete []  in_PREDICT_BTB_CONDITION       ;
+        delete []  in_PREDICT_BTB_LAST_TAKE       ;
+        delete []  in_PREDICT_BTB_IS_ACCURATE     ;
+        if (_param->_have_port_history)
+        delete []  in_PREDICT_DIR_HISTORY         ;
+        delete []  in_PREDICT_RAS_ADDRESS         ;
+        delete []  in_PREDICT_RAS_INDEX           ;
+//      if (_param->_have_port_depth)
+//      delete [] out_PREDICT_UPDATE_PREDICTION_ID;
+        
+        // ~~~~~[ Interface : "decod" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        delete []  in_DECOD_VAL                   ;
+        delete [] out_DECOD_ACK                   ;
+        if (_param->_have_port_context_id)
+        delete []  in_DECOD_CONTEXT_ID            ;
+        delete []  in_DECOD_BTB_ADDRESS_SRC       ;
+        delete []  in_DECOD_BTB_ADDRESS_DEST      ;
+        delete []  in_DECOD_BTB_CONDITION         ;
+        delete []  in_DECOD_BTB_LAST_TAKE         ;
+        delete []  in_DECOD_RAS_ADDRESS           ;
+        delete []  in_DECOD_RAS_INDEX             ;
+        delete []  in_DECOD_MISS_PREDICTION       ;
+        if (_param->_have_port_depth)
+        delete []  in_DECOD_UPDATE_PREDICTION_ID  ;
+//      if (_param->_have_port_depth)
+//      delete [] out_DECOD_DEPTH                 ;
+        
+        // ~~~~~[ Interface : "branch_complete" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        delete []  in_BRANCH_COMPLETE_VAL            ;
+        delete [] out_BRANCH_COMPLETE_ACK            ;
+        if (_param->_have_port_context_id)
+        delete []  in_BRANCH_COMPLETE_CONTEXT_ID     ;
+        if (_param->_have_port_depth)
+        delete []  in_BRANCH_COMPLETE_DEPTH          ;
+        delete []  in_BRANCH_COMPLETE_ADDRESS        ;
+        delete []  in_BRANCH_COMPLETE_FLAG           ;
+        delete [] out_BRANCH_COMPLETE_MISS_PREDICTION;
+        delete [] out_BRANCH_COMPLETE_TAKE           ;
+        delete [] out_BRANCH_COMPLETE_ADDRESS_SRC    ;
+        delete [] out_BRANCH_COMPLETE_ADDRESS_DEST   ;
+        
+        // ~~~~~[ Interface : "update" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        delete [] out_UPDATE_VAL                  ;
+        delete []  in_UPDATE_ACK                  ;
+        if (_param->_have_port_context_id)
+        delete [] out_UPDATE_CONTEXT_ID           ;
+        delete [] out_UPDATE_MISS_PREDICTION      ;
+        delete [] out_UPDATE_DIRECTION_GOOD       ;
+        delete [] out_UPDATE_BTB_VAL              ;
+        delete [] out_UPDATE_BTB_ADDRESS_SRC      ;
+        delete [] out_UPDATE_BTB_ADDRESS_DEST     ;
+        delete [] out_UPDATE_BTB_CONDITION        ;
+        delete [] out_UPDATE_DIR_VAL              ;
+        if (_param->_have_port_history)
+        delete [] out_UPDATE_DIR_HISTORY          ;
+        delete [] out_UPDATE_RAS_VAL              ;
+        delete [] out_UPDATE_RAS_ADDRESS          ;
+        delete [] out_UPDATE_RAS_INDEX            ;
+        delete [] out_UPDATE_RAS_PREDICTION_IFETCH;
+
+        // ~~~~~[ Interface : "depth" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        if (_param->_have_port_depth)
+          {
+        delete [] out_DEPTH_NB_BRANCH;
+        delete [] out_DEPTH_TAIL;
+          }
       }
+
+    // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    delete [] internal_PREDICT_ACK                     ;
+    delete [] internal_DECOD_ACK                       ;
+    delete [] internal_BRANCH_COMPLETE_ACK             ;
+    delete [] internal_BRANCH_COMPLETE_MISS_PREDICTION ;
+    delete [] internal_BRANCH_COMPLETE_TAKE            ;
+    delete [] internal_BRANCH_COMPLETE_ADDRESS_DEST    ;
+    delete [] internal_UPDATE_VAL                      ;
+    delete [] internal_UPDATE_CONTEXT_ID               ;
+    delete [] internal_UPDATE_DEPTH                    ;
+
+    // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    
+    delete [] reg_TOP;
+    delete [] reg_BOTTOM;
+    delete [] reg_NB_ELT;
+    delete [] reg_NB_ELT_NEED_UPDATE;
+    for (uint32_t i=0; i<_param->_nb_context; i++)
+      delete [] reg_UPDATE_PREDICTION_TABLE [i];
+    delete [] reg_UPDATE_PREDICTION_TABLE;
+
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    
 

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src/Update_Prediction_Table_transition.cpp

@@ -24 +24 @@
     log_printf(FUNC,Update_Prediction_Table,FUNCTION,"Begin");
 
+    if (PORT_READ(in_NRESET) == 0)
+      {
+        for (uint32_t i=0; i<_param->_nb_context; i++)
+          {
+            reg_TOP                [i] = 0;
+            reg_BOTTOM             [i] = 0;
+            reg_NB_ELT             [i] = 0;
+            reg_NB_ELT_NEED_UPDATE [i] = 0;
+            for (uint32_t j=0; j<_param->_size_queue[i]; j++)
+              reg_UPDATE_PREDICTION_TABLE [i][j]._state = UPDATE_PREDICTION_STATE_EMPTY;
+          }
+        reg_UPDATE_PRIORITY = 0;
+      }
+    else
+      {
+        // ===================================================================
+        // =====[ PREDICT ]===================================================
+        // ===================================================================
+        for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
+          if (PORT_READ(in_PREDICT_VAL[i]) and internal_PREDICT_ACK [i])
+            {
+              Tcontext_t context = (_param->_have_port_context_id)?PORT_READ(in_PREDICT_CONTEXT_ID [i]):0;
+              uint32_t   top     = reg_TOP [context];
+
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"PREDICT[%d] - Accepted",i);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION," * context : %d",context);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION," * top     : %d",top);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION," * nb_elt  : %d",reg_NB_ELT[context]);
+
+              reg_UPDATE_PREDICTION_TABLE [context][top]._state        = UPDATE_PREDICTION_STATE_WAIT_DECOD;
+              reg_UPDATE_PREDICTION_TABLE [context][top]._ifetch_prediction = true;
+              reg_UPDATE_PREDICTION_TABLE [context][top]._condition    = PORT_READ(in_PREDICT_BTB_CONDITION    [i]);
+              reg_UPDATE_PREDICTION_TABLE [context][top]._address_src  = PORT_READ(in_PREDICT_BTB_ADDRESS_SRC  [i]);
+              reg_UPDATE_PREDICTION_TABLE [context][top]._address_dest = PORT_READ(in_PREDICT_BTB_ADDRESS_DEST [i]);
+              reg_UPDATE_PREDICTION_TABLE [context][top]._last_take    = PORT_READ(in_PREDICT_BTB_LAST_TAKE    [i]);
+            //reg_UPDATE_PREDICTION_TABLE [context][top]._good_take    
+              reg_UPDATE_PREDICTION_TABLE [context][top]._history      = (_param->_have_port_history)?PORT_READ(in_PREDICT_DIR_HISTORY [i]):0;
+              reg_UPDATE_PREDICTION_TABLE [context][top]._address_ras  = PORT_READ(in_PREDICT_RAS_ADDRESS      [i]);
+              reg_UPDATE_PREDICTION_TABLE [context][top]._index_ras    = PORT_READ(in_PREDICT_RAS_INDEX        [i]);
+
+              reg_TOP    [context] = (top+1)%_param->_size_queue [context];
+              reg_NB_ELT [context] ++;
+            }
+
+        // ===================================================================
+        // =====[ DECOD ]=====================================================
+        // ===================================================================
+        for (uint32_t i=0; i<_param->_nb_inst_decod; i++)
+          if (PORT_READ(in_DECOD_VAL[i]) and internal_DECOD_ACK [i])
+            {
+              Tcontext_t context = (_param->_have_port_context_id)?PORT_READ(in_DECOD_CONTEXT_ID [i]):0;
+              Tcontrol_t miss    = PORT_READ(in_DECOD_MISS_PREDICTION [i]);
+
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"DECOD[%d] - Accepted",i);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION," * context : %d",context);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION," * miss    : %d",miss);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION," * nb_elt  : %d",reg_NB_ELT[context]);
+              
+              // Test if miss ifetch
+              //   miss ifetch = decod a branch and the predict unit have not predict this branch ... gloup :P
+              if (miss)
+                {
+                  Tdepth_t depth = (_param->_have_port_depth)?PORT_READ(in_DECOD_UPDATE_PREDICTION_ID [i]):0;
+                  Tdepth_t top   = reg_TOP [context];
+
+                  reg_UPDATE_PREDICTION_TABLE [context][top]._state        = UPDATE_PREDICTION_STATE_WAITEND;
+                  reg_UPDATE_PREDICTION_TABLE [context][top]._ifetch_prediction = false; // static prediction
+                  reg_UPDATE_PREDICTION_TABLE [context][top]._condition    = PORT_READ(in_DECOD_BTB_CONDITION    [i]);
+                  reg_UPDATE_PREDICTION_TABLE [context][top]._address_src  = PORT_READ(in_DECOD_BTB_ADDRESS_SRC  [i]);
+                  reg_UPDATE_PREDICTION_TABLE [context][top]._address_dest = PORT_READ(in_DECOD_BTB_ADDRESS_DEST [i]);
+                  reg_UPDATE_PREDICTION_TABLE [context][top]._last_take    = PORT_READ(in_DECOD_BTB_LAST_TAKE    [i]);
+                //reg_UPDATE_PREDICTION_TABLE [context][top]._good_take
+                //reg_UPDATE_PREDICTION_TABLE [context][top]._history
+                  reg_UPDATE_PREDICTION_TABLE [context][top]._address_ras  = PORT_READ(in_DECOD_RAS_ADDRESS      [i]);
+                  reg_UPDATE_PREDICTION_TABLE [context][top]._index_ras    = PORT_READ(in_DECOD_RAS_INDEX        [i]);
+
+                  // Invalid all previous "ifetch" prediction 
+                  // (ifetch prediction = prediction make in fetch stage and not again comming in decod stage)
+                  uint32_t nb_elt_miss        = ((top> depth)?top:(top+_param->_size_queue[context]))-depth;
+                  uint32_t nb_elt_need_update = 0;
+                  for (uint32_t j=0; j<nb_elt_miss; j++)
+                    {
+                      uint32_t k=(depth+j)%_param->_size_queue[context];
+                      
+                      // Ifetch have make a prediction and it's a miss
+                      // When ifetch predict :
+                      //   * btb is not change       -> needn't update
+                      //   * direction is not change -> needn't update
+                      //   * ras have change         -> need    update
+
+                      Tbranch_condition_t cond = reg_UPDATE_PREDICTION_TABLE [context][k]._condition;
+                      if ((cond == BRANCH_CONDITION_NONE_WITH_WRITE_STACK) or
+                          (cond == BRANCH_CONDITION_READ_REGISTER_WITH_WRITE_STACK) or
+                          (cond == BRANCH_CONDITION_READ_STACK))
+                        {
+                          nb_elt_need_update ++;
+                          reg_UPDATE_PREDICTION_TABLE [context][k]._state = UPDATE_PREDICTION_STATE_KO;
+                        }
+                      else
+                        {
+                          reg_UPDATE_PREDICTION_TABLE [context][k]._state = UPDATE_PREDICTION_STATE_END;
+                        }
+                    }
+
+                  reg_TOP                [context] = (depth+1)%_param->_size_queue [context];
+                  reg_NB_ELT_NEED_UPDATE [context] += nb_elt_need_update;
+                  reg_NB_ELT             [context] ++;
+                }
+              else
+                {
+                  // Normal case : branch is previous predicated, change state of branch
+                  Tdepth_t depth = (_param->_have_port_depth)?PORT_READ(in_DECOD_UPDATE_PREDICTION_ID [i]):0;
+
+                  reg_UPDATE_PREDICTION_TABLE [context][depth]._state = UPDATE_PREDICTION_STATE_WAITEND;
+                }
+            }
+
+        // ===================================================================
+        // =====[ BRANCH_COMPLETE ]===========================================
+        // ===================================================================
+        for (uint32_t i=0; i<_param->_nb_inst_branch_complete; i++)
+          if (PORT_READ(in_BRANCH_COMPLETE_VAL[i]) and internal_BRANCH_COMPLETE_ACK [i])
+            {
+              Tcontext_t context = (_param->_have_port_context_id)?PORT_READ(in_BRANCH_COMPLETE_CONTEXT_ID [i]):0;
+              Tdepth_t   depth   = (_param->_have_port_depth     )?PORT_READ(in_BRANCH_COMPLETE_DEPTH      [i]):0;
+
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"BRANCH_COMPLETE[%d] - Accepted",i);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION," * context : %d",context);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION," * depth   : %d",depth);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION," * nb_elt  : %d",reg_NB_ELT[context]);
+              
+              if (internal_BRANCH_COMPLETE_MISS_PREDICTION [i])
+                {
+                  // Miss case
+                  reg_UPDATE_PREDICTION_TABLE [context][depth]._state = UPDATE_PREDICTION_STATE_KO;
+
+                  // Another prediction (prediction with depth higer)
+                  Tdepth_t top                = reg_TOP [context];
+                  uint32_t nb_elt_miss        = ((top> depth)?top:(top+_param->_size_queue[context]))-depth;
+                  uint32_t nb_elt_need_update = 1;
+                  for (uint32_t j=1; j<nb_elt_miss; j++)
+                    {
+                      uint32_t k=(depth+j)%_param->_size_queue[context];
+                      
+                      // Ifetch have make a prediction and it's a miss
+                      // When ifetch predict :
+                      //   * btb is not change       -> needn't update
+                      //   * direction is not change -> needn't update
+                      //   * ras have change         -> need    update
+
+                      Tbranch_condition_t cond = reg_UPDATE_PREDICTION_TABLE [context][k]._condition;
+                      if ((cond == BRANCH_CONDITION_NONE_WITH_WRITE_STACK) or
+                          (cond == BRANCH_CONDITION_READ_REGISTER_WITH_WRITE_STACK) or
+                          (cond == BRANCH_CONDITION_READ_STACK))
+                        {
+                          nb_elt_need_update ++;
+                          reg_UPDATE_PREDICTION_TABLE [context][k]._state = UPDATE_PREDICTION_STATE_KO;
+                        }
+                      else
+                        {
+                          reg_UPDATE_PREDICTION_TABLE [context][k]._state = UPDATE_PREDICTION_STATE_END;
+                        }
+                    }
+                  reg_NB_ELT_NEED_UPDATE [context] += nb_elt_need_update;
+
+                  // Update pointer :
+                  reg_TOP                [context]  = depth;
+                  reg_NB_ELT             [context] -= nb_elt_miss;
+                }
+              else
+                {
+                  // Hit case
+#ifdef DEBUG_TEST
+                  if (reg_UPDATE_PREDICTION_TABLE [context][depth]._state != UPDATE_PREDICTION_STATE_WAITEND)
+                    ERRORMORPHEO(FUNCTION,"Branche complete : invalid state");
+#endif
+                  reg_UPDATE_PREDICTION_TABLE [context][depth]._state = UPDATE_PREDICTION_STATE_OK;
+                }
+
+              // In all case : update good_take and address_destination
+              reg_UPDATE_PREDICTION_TABLE [context][depth]._good_take    = internal_BRANCH_COMPLETE_TAKE         [i];
+              reg_UPDATE_PREDICTION_TABLE [context][depth]._address_dest = internal_BRANCH_COMPLETE_ADDRESS_DEST [i];
+            }
+
+        // ===================================================================
+        // =====[ UPDATE ]====================================================
+        // ===================================================================
+        for (uint32_t i=0; i<_param->_nb_inst_update; i++)
+          if (internal_UPDATE_VAL[i] and PORT_READ(in_UPDATE_ACK [i]))
+            {
+              Tcontext_t context = internal_UPDATE_CONTEXT_ID [i];
+              Tdepth_t   depth   = internal_UPDATE_DEPTH      [i];
+
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"UPDATE[%d] - Accepted",i);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION," * context : %d",context);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION," * depth   : %d",depth);
+
+              if (reg_UPDATE_PREDICTION_TABLE [context][depth]._state == UPDATE_PREDICTION_STATE_KO)
+                reg_NB_ELT_NEED_UPDATE [context] --;
+
+              reg_UPDATE_PREDICTION_TABLE [context][depth]._state = UPDATE_PREDICTION_STATE_END;
+            }
+        
+        // Round robin
+        reg_UPDATE_PRIORITY = (reg_UPDATE_PRIORITY+1)%_param->_nb_context;
+
+        // ===================================================================
+        // =====[ GARBAGE COLLECTOR ]=========================================
+        // ===================================================================
+
+        for (uint32_t i=0; i<_param->_nb_context; i++)
+          {
+            uint32_t bottom = reg_BOTTOM [i];
+            
+            // Test if the tail of queue is finish (ok or ko and update)
+            if (reg_UPDATE_PREDICTION_TABLE [i][bottom]._state == UPDATE_PREDICTION_STATE_END)
+              {
+                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"GARBAGE_COLLECTOR");
+                log_printf(TRACE,Update_Prediction_Table,FUNCTION," * context : %d",i);
+                log_printf(TRACE,Update_Prediction_Table,FUNCTION," * bottom  : %d",bottom);
+
+                reg_UPDATE_PREDICTION_TABLE [i][bottom]._state = UPDATE_PREDICTION_STATE_EMPTY;
+                reg_BOTTOM [i] = (bottom+1)%_param->_size_queue [i];
+                if (reg_NB_ELT [i]>0)
+                  reg_NB_ELT [i] --;
+              }
+          }
+      }
+
+// #if (DEBUG >= DEBUG_TRACE)
+    log_printf(TRACE,Update_Prediction_Table,FUNCTION,"Dump Update_Prediction_Table");
+    log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * reg_UPDATE_PRIORITY      : %d",reg_UPDATE_PRIORITY);
+    for (uint32_t i=0; i<_param->_nb_context; i++)
+      {
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * Update_Prediction_Table [%d]",i);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * reg_TOP                : %d",reg_TOP                [i]);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * reg_BOTTOM             : %d",reg_BOTTOM             [i]);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * reg_NB_ELT             : %d",reg_NB_ELT             [i]);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * reg_NB_ELT_NEED_UPDATE : %d",reg_NB_ELT_NEED_UPDATE [i]);
+        for (uint32_t j=0; j<_param->_size_queue[i]; j++)
+          log_printf(TRACE,Update_Prediction_Table,FUNCTION,"      [%d] %s %x",j,toString(reg_UPDATE_PREDICTION_TABLE [i][j]._state).c_str(),reg_UPDATE_PREDICTION_TABLE [i][j]._address_src);
+      }
+// #endif
+
+
 #if defined(STATISTICS) or defined(VHDL_TESTBENCH)
     end_cycle ();