Ignore:
Timestamp:
May 1, 2008, 6:48:45 PM (16 years ago)
Author:
rosiere
Message:
  • support locale (now must "just" translate)
  • update all component with new test format
  • update all component with usage
  • New component : decod queue and prediction_unit
Location:
trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue
Files:
2 added
14 edited

Legend:

Unmodified
Added
Removed

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue/SelfTest/config_mono_context.cfg

    r81 r82  
    11Prediction_unit_Glue
    2 1       1       +1      # nb_context     
    3 30      30      +32     # size_address   
    4 1       4       *4      # nb_instruction  [0] [nb_context]
    5 1       4       *4      # size_depth      [0] [nb_context]
    6 1       1       *4      # nb_inst_predict
    7 4       4       *4      # nb_inst_decod 
    8 4       4       *4      # nb_inst_update
     21       1       *4      # nb_context         
     31       1       *4      # nb_decod_unit     
     430      30      +32     # size_address       
     51       1       *4      # nb_instruction  [0] [nb_context]
     61       1       *4      # size_depth      [0] [nb_context]
     74       4       *4      # nb_inst_decod   [0] [nb_decod_unit]
     81       1       *4      # nb_inst_branch_predict     
     94       4       *4      # nb_inst_branch_decod
     104       4       *4      # nb_inst_branch_update

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue/SelfTest/config_multi_context.cfg

    r81 r82  
    11Prediction_unit_Glue
    2 4       4       +1      # nb_context     
    3 30      30      +32     # size_address   
     24       4       *4      # nb_context         
     31       1       *4      # nb_decod_unit     
     430      30      +32     # size_address       
    451       1       *4      # nb_instruction  [0] [nb_context]
    562       2       *4      # nb_instruction  [1] [nb_context]
    … …  
    892       2       *4      # size_depth      [0] [nb_context]
    9101       1       *4      # size_depth      [1] [nb_context]
    10 8       8       *4      # size_depth      [2] [nb_context]
     117       7       *4      # size_depth      [2] [nb_context]
    11124       4       *4      # size_depth      [3] [nb_context]
    12 1       4       *4      # nb_inst_predict
    13 4       4       *4      # nb_inst_decod 
    14 4       4       *4      # nb_inst_update
     134       4       *4      # nb_inst_decod   [0] [nb_decod_unit]
     141       4       *4      # nb_inst_branch_predict     
     154       4       *4      # nb_inst_branch_decod
     164       4       *4      # nb_inst_branch_update

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue/SelfTest/src/main.cpp

    r81 r82  
    88#include "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue/SelfTest/include/test.h"
    99
    10 #define NB_PARAMS 5
     10#define NB_PARAMS 6
    1111
    1212void usage (int argc, char * argv[])
    … …  
    1414  err (_("<Usage> %s name_instance list_params.\n"),argv[0]);
    1515  err (_("list_params is :\n"));
    16   err (_(" * nb_context                   (uint32_t)\n"));
    17   err (_(" * size_address                 (uint32_t)\n"));
    18   err (_(" * nb_instruction  [nb_context] (uint32_t)\n"));
    19   err (_(" * size_depth      [nb_context] (uint32_t)\n"));
    20   err (_(" * nb_inst_predict              (uint32_t)\n"));
    21   err (_(" * nb_inst_decod                (uint32_t)\n"));
    22   err (_(" * nb_inst_update               (uint32_t)\n"));
     16  err (_(" * nb_context                             (uint32_t)\n"));
     17  err (_(" * nb_decod_unit                          (uint32_t)\n"));
     18//   err (_(" * nb_ooo_engine                          (uint32_t)\n"));
     19  err (_(" * size_address                           (uint32_t)\n"));
     20  err (_(" * nb_instruction         [nb_context]    (uint32_t)\n"));
     21  err (_(" * size_depth             [nb_context]    (uint32_t)\n"));
     22  err (_(" * nb_inst_decod          [nb_decod_unit] (uint32_t)\n"));
     23//   err (_(" * nb_inst_update         [nb_ooo_engine] (uint32_t)\n"));
     24  err (_(" * nb_inst_branch_predict                 (uint32_t)\n"));
     25  err (_(" * nb_inst_branch_decod                   (uint32_t)\n"));
     26  err (_(" * nb_inst_branch_update                  (uint32_t)\n"));
    2327
    2428  exit (1);
    … …  
    3943
    4044  uint32_t   _nb_context      = fromString<uint32_t>(argv[x++]);
     45  uint32_t   _nb_decod_unit   = fromString<uint32_t>(argv[x++]);
     46//   uint32_t   _nb_ooo_engine   = fromString<uint32_t>(argv[x++]);
    4147  uint32_t   _size_address    = fromString<uint32_t>(argv[x++]);
    4248 
    43   if (argc != static_cast<int>(2+NB_PARAMS+2*_nb_context))
     49  if (argc != static_cast<int>(2+NB_PARAMS+2*_nb_context+_nb_decod_unit// +_nb_ooo_engine
     50                               ))
    4451    usage (argc, argv);
    4552
    … …  
    5057  for (uint32_t i=0; i<_nb_context; i++)
    5158    _size_depth     [i] = fromString<uint32_t>(argv[x++]);
    52   uint32_t   _nb_inst_predict = fromString<uint32_t>(argv[x++]);
    53   uint32_t   _nb_inst_decod   = fromString<uint32_t>(argv[x++]);
    54   uint32_t   _nb_inst_update  = fromString<uint32_t>(argv[x++]);
     59  uint32_t * _nb_inst_decod   = new uint32_t [_nb_decod_unit];
     60  for (uint32_t i=0; i<_nb_decod_unit; i++)
     61    _nb_inst_decod  [i] = fromString<uint32_t>(argv[x++]);
     62//   uint32_t * _nb_inst_update  = new uint32_t [_nb_ooo_engine];
     63//   for (uint32_t i=0; i<_nb_ooo_engine; i++)
     64//     _nb_inst_update [i] = fromString<uint32_t>(argv[x++]);
     65  uint32_t   _nb_inst_branch_predict = fromString<uint32_t>(argv[x++]);
     66  uint32_t   _nb_inst_branch_update  = fromString<uint32_t>(argv[x++]);
     67  uint32_t   _nb_inst_branch_decod   = fromString<uint32_t>(argv[x++]);
    5568
    5669  int _return = EXIT_SUCCESS;
    … …  
    5871    {
    5972      morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::prediction_unit_glue::Parameters * param = new morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::prediction_unit_glue::Parameters
    60         (_nb_context     ,
    61          _size_address   ,
    62          _nb_instruction ,
    63          _size_depth     ,
    64          _nb_inst_predict,
    65          _nb_inst_decod  ,
    66          _nb_inst_update );
     73        (_nb_context            ,
     74         _nb_decod_unit         ,
     75//       _nb_ooo_engine         ,
     76         _size_address          ,
     77         _nb_instruction        ,
     78         _size_depth            ,
     79         _nb_inst_decod         ,
     80//       _nb_inst_update        ,
     81         _nb_inst_branch_predict,
     82         _nb_inst_branch_decod  ,
     83         _nb_inst_branch_update );
    6784     
    6885      msg(_("%s"),param->print(1).c_str());
    … …  
    83100  delete [] _nb_instruction;
    84101  delete [] _size_depth    ;
     102  delete [] _nb_inst_decod ;
     103//   delete [] _nb_inst_update;
    85104
    86105  return (_return);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue/SelfTest/src/test.cpp

    r81 r82  
    6363  ALLOC1_SC_SIGNAL(out_PREDICT_BRANCH_STATE                ,"out_PREDICT_BRANCH_STATE               ",Tbranch_state_t    ,_param->_nb_context);
    6464  ALLOC1_SC_SIGNAL(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID ,"out_PREDICT_BRANCH_UPDATE_PREDICTION_ID",Tprediction_ptr_t  ,_param->_nb_context);
    65   ALLOC1_SC_SIGNAL(out_PREDICT_BTB_VAL                     ,"out_PREDICT_BTB_VAL                    ",Tcontrol_t         ,_param->_nb_inst_predict);
    66   ALLOC1_SC_SIGNAL( in_PREDICT_BTB_ACK                     ," in_PREDICT_BTB_ACK                    ",Tcontrol_t         ,_param->_nb_inst_predict);
    67   ALLOC1_SC_SIGNAL(out_PREDICT_BTB_CONTEXT_ID              ,"out_PREDICT_BTB_CONTEXT_ID             ",Tcontext_t         ,_param->_nb_inst_predict);
    68   ALLOC1_SC_SIGNAL(out_PREDICT_BTB_ADDRESS                 ,"out_PREDICT_BTB_ADDRESS                ",Taddress_t         ,_param->_nb_inst_predict);
    69   ALLOC1_SC_SIGNAL( in_PREDICT_BTB_HIT                     ," in_PREDICT_BTB_HIT                    ",Tcontrol_t         ,_param->_nb_inst_predict);
    70   ALLOC1_SC_SIGNAL( in_PREDICT_BTB_ADDRESS_SRC             ," in_PREDICT_BTB_ADDRESS_SRC            ",Taddress_t         ,_param->_nb_inst_predict);
    71   ALLOC1_SC_SIGNAL( in_PREDICT_BTB_ADDRESS_DEST            ," in_PREDICT_BTB_ADDRESS_DEST           ",Taddress_t         ,_param->_nb_inst_predict);
    72   ALLOC1_SC_SIGNAL( in_PREDICT_BTB_CONDITION               ," in_PREDICT_BTB_CONDITION              ",Tbranch_condition_t,_param->_nb_inst_predict);
    73 //ALLOC1_SC_SIGNAL( in_PREDICT_BTB_LAST_TAKE               ," in_PREDICT_BTB_LAST_TAKE              ",Tcontrol_t         ,_param->_nb_inst_predict);
    74   ALLOC1_SC_SIGNAL( in_PREDICT_BTB_IS_ACCURATE             ," in_PREDICT_BTB_IS_ACCURATE            ",Tcontrol_t         ,_param->_nb_inst_predict);
    75   ALLOC1_SC_SIGNAL(out_PREDICT_DIR_VAL                     ,"out_PREDICT_DIR_VAL                    ",Tcontrol_t         ,_param->_nb_inst_predict);
    76   ALLOC1_SC_SIGNAL( in_PREDICT_DIR_ACK                     ," in_PREDICT_DIR_ACK                    ",Tcontrol_t         ,_param->_nb_inst_predict);
    77   ALLOC1_SC_SIGNAL(out_PREDICT_DIR_ADDRESS_SRC             ,"out_PREDICT_DIR_ADDRESS_SRC            ",Taddress_t         ,_param->_nb_inst_predict);
    78   ALLOC1_SC_SIGNAL(out_PREDICT_DIR_STATIC                  ,"out_PREDICT_DIR_STATIC                 ",Tcontrol_t         ,_param->_nb_inst_predict);
    79 //ALLOC1_SC_SIGNAL(out_PREDICT_DIR_LAST_TAKE               ,"out_PREDICT_DIR_LAST_TAKE              ",Tcontrol_t         ,_param->_nb_inst_predict);
    80 //ALLOC1_SC_SIGNAL( in_PREDICT_DIR_HISTORY                 ," in_PREDICT_DIR_HISTORY                ",Thistory_t         ,_param->_nb_inst_predict);
    81   ALLOC1_SC_SIGNAL( in_PREDICT_DIR_DIRECTION               ," in_PREDICT_DIR_DIRECTION              ",Tcontrol_t         ,_param->_nb_inst_predict);
    82   ALLOC1_SC_SIGNAL(out_PREDICT_RAS_VAL                     ,"out_PREDICT_RAS_VAL                    ",Tcontrol_t         ,_param->_nb_inst_predict);
    83   ALLOC1_SC_SIGNAL( in_PREDICT_RAS_ACK                     ," in_PREDICT_RAS_ACK                    ",Tcontrol_t         ,_param->_nb_inst_predict);
    84   ALLOC1_SC_SIGNAL(out_PREDICT_RAS_CONTEXT_ID              ,"out_PREDICT_RAS_CONTEXT_ID             ",Tcontext_t         ,_param->_nb_inst_predict);
    85   ALLOC1_SC_SIGNAL( in_PREDICT_RAS_HIT                     ," in_PREDICT_RAS_HIT                    ",Tcontrol_t         ,_param->_nb_inst_predict);
    86   ALLOC1_SC_SIGNAL(out_PREDICT_RAS_PUSH                    ,"out_PREDICT_RAS_PUSH                   ",Tcontrol_t         ,_param->_nb_inst_predict);
    87   ALLOC1_SC_SIGNAL(out_PREDICT_RAS_ADDRESS_PUSH            ,"out_PREDICT_RAS_ADDRESS_PUSH           ",Taddress_t         ,_param->_nb_inst_predict);
    88   ALLOC1_SC_SIGNAL( in_PREDICT_RAS_ADDRESS_POP             ," in_PREDICT_RAS_ADDRESS_POP            ",Taddress_t         ,_param->_nb_inst_predict);
    89 //ALLOC1_SC_SIGNAL( in_PREDICT_RAS_INDEX                   ," in_PREDICT_RAS_INDEX                  ",Tptr_t             ,_param->_nb_inst_predict);
    90   ALLOC1_SC_SIGNAL(out_PREDICT_UPT_VAL                     ,"out_PREDICT_UPT_VAL                    ",Tcontrol_t         ,_param->_nb_inst_predict);
    91   ALLOC1_SC_SIGNAL( in_PREDICT_UPT_ACK                     ," in_PREDICT_UPT_ACK                    ",Tcontrol_t         ,_param->_nb_inst_predict);
    92   ALLOC1_SC_SIGNAL(out_PREDICT_UPT_CONTEXT_ID              ,"out_PREDICT_UPT_CONTEXT_ID             ",Tcontext_t         ,_param->_nb_inst_predict);
    93   ALLOC1_SC_SIGNAL(out_PREDICT_UPT_BTB_ADDRESS_SRC         ,"out_PREDICT_UPT_BTB_ADDRESS_SRC        ",Taddress_t         ,_param->_nb_inst_predict);
    94   ALLOC1_SC_SIGNAL(out_PREDICT_UPT_BTB_ADDRESS_DEST        ,"out_PREDICT_UPT_BTB_ADDRESS_DEST       ",Taddress_t         ,_param->_nb_inst_predict);
    95   ALLOC1_SC_SIGNAL(out_PREDICT_UPT_BTB_CONDITION           ,"out_PREDICT_UPT_BTB_CONDITION          ",Tbranch_condition_t,_param->_nb_inst_predict);
    96   ALLOC1_SC_SIGNAL(out_PREDICT_UPT_BTB_LAST_TAKE           ,"out_PREDICT_UPT_BTB_LAST_TAKE          ",Tcontrol_t         ,_param->_nb_inst_predict);
    97   ALLOC1_SC_SIGNAL(out_PREDICT_UPT_BTB_IS_ACCURATE         ,"out_PREDICT_UPT_BTB_IS_ACCURATE        ",Tcontrol_t         ,_param->_nb_inst_predict);
    98 //ALLOC1_SC_SIGNAL(out_PREDICT_UPT_DIR_HISTORY             ,"out_PREDICT_UPT_DIR_HISTORY            ",Thistory_t         ,_param->_nb_inst_predict);
    99   ALLOC1_SC_SIGNAL(out_PREDICT_UPT_RAS_ADDRESS             ,"out_PREDICT_UPT_RAS_ADDRESS            ",Taddress_t         ,_param->_nb_inst_predict);
    100 //ALLOC1_SC_SIGNAL(out_PREDICT_UPT_RAS_INDEX               ,"out_PREDICT_UPT_RAS_INDEX              ",Tptr_t             ,_param->_nb_inst_predict);
     65  ALLOC1_SC_SIGNAL(out_PREDICT_BTB_VAL                     ,"out_PREDICT_BTB_VAL                    ",Tcontrol_t         ,_param->_nb_inst_branch_predict);
     66  ALLOC1_SC_SIGNAL( in_PREDICT_BTB_ACK                     ," in_PREDICT_BTB_ACK                    ",Tcontrol_t         ,_param->_nb_inst_branch_predict);
     67  ALLOC1_SC_SIGNAL(out_PREDICT_BTB_CONTEXT_ID              ,"out_PREDICT_BTB_CONTEXT_ID             ",Tcontext_t         ,_param->_nb_inst_branch_predict);
     68  ALLOC1_SC_SIGNAL(out_PREDICT_BTB_ADDRESS                 ,"out_PREDICT_BTB_ADDRESS                ",Taddress_t         ,_param->_nb_inst_branch_predict);
     69  ALLOC1_SC_SIGNAL( in_PREDICT_BTB_HIT                     ," in_PREDICT_BTB_HIT                    ",Tcontrol_t         ,_param->_nb_inst_branch_predict);
     70  ALLOC1_SC_SIGNAL( in_PREDICT_BTB_ADDRESS_SRC             ," in_PREDICT_BTB_ADDRESS_SRC            ",Taddress_t         ,_param->_nb_inst_branch_predict);
     71  ALLOC1_SC_SIGNAL( in_PREDICT_BTB_ADDRESS_DEST            ," in_PREDICT_BTB_ADDRESS_DEST           ",Taddress_t         ,_param->_nb_inst_branch_predict);
     72  ALLOC1_SC_SIGNAL( in_PREDICT_BTB_CONDITION               ," in_PREDICT_BTB_CONDITION              ",Tbranch_condition_t,_param->_nb_inst_branch_predict);
     73//ALLOC1_SC_SIGNAL( in_PREDICT_BTB_LAST_TAKE               ," in_PREDICT_BTB_LAST_TAKE              ",Tcontrol_t         ,_param->_nb_inst_branch_predict);
     74  ALLOC1_SC_SIGNAL( in_PREDICT_BTB_IS_ACCURATE             ," in_PREDICT_BTB_IS_ACCURATE            ",Tcontrol_t         ,_param->_nb_inst_branch_predict);
     75  ALLOC1_SC_SIGNAL(out_PREDICT_DIR_VAL                     ,"out_PREDICT_DIR_VAL                    ",Tcontrol_t         ,_param->_nb_inst_branch_predict);
     76  ALLOC1_SC_SIGNAL( in_PREDICT_DIR_ACK                     ," in_PREDICT_DIR_ACK                    ",Tcontrol_t         ,_param->_nb_inst_branch_predict);
     77  ALLOC1_SC_SIGNAL(out_PREDICT_DIR_ADDRESS_SRC             ,"out_PREDICT_DIR_ADDRESS_SRC            ",Taddress_t         ,_param->_nb_inst_branch_predict);
     78  ALLOC1_SC_SIGNAL(out_PREDICT_DIR_STATIC                  ,"out_PREDICT_DIR_STATIC                 ",Tcontrol_t         ,_param->_nb_inst_branch_predict);
     79//ALLOC1_SC_SIGNAL(out_PREDICT_DIR_LAST_TAKE               ,"out_PREDICT_DIR_LAST_TAKE              ",Tcontrol_t         ,_param->_nb_inst_branch_predict);
     80//ALLOC1_SC_SIGNAL( in_PREDICT_DIR_HISTORY                 ," in_PREDICT_DIR_HISTORY                ",Thistory_t         ,_param->_nb_inst_branch_predict);
     81  ALLOC1_SC_SIGNAL( in_PREDICT_DIR_DIRECTION               ," in_PREDICT_DIR_DIRECTION              ",Tcontrol_t         ,_param->_nb_inst_branch_predict);
     82  ALLOC1_SC_SIGNAL(out_PREDICT_RAS_VAL                     ,"out_PREDICT_RAS_VAL                    ",Tcontrol_t         ,_param->_nb_inst_branch_predict);
     83  ALLOC1_SC_SIGNAL( in_PREDICT_RAS_ACK                     ," in_PREDICT_RAS_ACK                    ",Tcontrol_t         ,_param->_nb_inst_branch_predict);
     84  ALLOC1_SC_SIGNAL(out_PREDICT_RAS_CONTEXT_ID              ,"out_PREDICT_RAS_CONTEXT_ID             ",Tcontext_t         ,_param->_nb_inst_branch_predict);
     85  ALLOC1_SC_SIGNAL( in_PREDICT_RAS_HIT                     ," in_PREDICT_RAS_HIT                    ",Tcontrol_t         ,_param->_nb_inst_branch_predict);
     86  ALLOC1_SC_SIGNAL(out_PREDICT_RAS_PUSH                    ,"out_PREDICT_RAS_PUSH                   ",Tcontrol_t         ,_param->_nb_inst_branch_predict);
     87  ALLOC1_SC_SIGNAL(out_PREDICT_RAS_ADDRESS_PUSH            ,"out_PREDICT_RAS_ADDRESS_PUSH           ",Taddress_t         ,_param->_nb_inst_branch_predict);
     88  ALLOC1_SC_SIGNAL( in_PREDICT_RAS_ADDRESS_POP             ," in_PREDICT_RAS_ADDRESS_POP            ",Taddress_t         ,_param->_nb_inst_branch_predict);
     89//ALLOC1_SC_SIGNAL( in_PREDICT_RAS_INDEX                   ," in_PREDICT_RAS_INDEX                  ",Tptr_t             ,_param->_nb_inst_branch_predict);
     90  ALLOC1_SC_SIGNAL(out_PREDICT_UPT_VAL                     ,"out_PREDICT_UPT_VAL                    ",Tcontrol_t         ,_param->_nb_inst_branch_predict);
     91  ALLOC1_SC_SIGNAL( in_PREDICT_UPT_ACK                     ," in_PREDICT_UPT_ACK                    ",Tcontrol_t         ,_param->_nb_inst_branch_predict);
     92  ALLOC1_SC_SIGNAL(out_PREDICT_UPT_CONTEXT_ID              ,"out_PREDICT_UPT_CONTEXT_ID             ",Tcontext_t         ,_param->_nb_inst_branch_predict);
     93  ALLOC1_SC_SIGNAL(out_PREDICT_UPT_BTB_ADDRESS_SRC         ,"out_PREDICT_UPT_BTB_ADDRESS_SRC        ",Taddress_t         ,_param->_nb_inst_branch_predict);
     94  ALLOC1_SC_SIGNAL(out_PREDICT_UPT_BTB_ADDRESS_DEST        ,"out_PREDICT_UPT_BTB_ADDRESS_DEST       ",Taddress_t         ,_param->_nb_inst_branch_predict);
     95  ALLOC1_SC_SIGNAL(out_PREDICT_UPT_BTB_CONDITION           ,"out_PREDICT_UPT_BTB_CONDITION          ",Tbranch_condition_t,_param->_nb_inst_branch_predict);
     96  ALLOC1_SC_SIGNAL(out_PREDICT_UPT_BTB_LAST_TAKE           ,"out_PREDICT_UPT_BTB_LAST_TAKE          ",Tcontrol_t         ,_param->_nb_inst_branch_predict);
     97  ALLOC1_SC_SIGNAL(out_PREDICT_UPT_BTB_IS_ACCURATE         ,"out_PREDICT_UPT_BTB_IS_ACCURATE        ",Tcontrol_t         ,_param->_nb_inst_branch_predict);
     98//ALLOC1_SC_SIGNAL(out_PREDICT_UPT_DIR_HISTORY             ,"out_PREDICT_UPT_DIR_HISTORY            ",Thistory_t         ,_param->_nb_inst_branch_predict);
     99  ALLOC1_SC_SIGNAL(out_PREDICT_UPT_RAS_ADDRESS             ,"out_PREDICT_UPT_RAS_ADDRESS            ",Taddress_t         ,_param->_nb_inst_branch_predict);
     100//ALLOC1_SC_SIGNAL(out_PREDICT_UPT_RAS_INDEX               ,"out_PREDICT_UPT_RAS_INDEX              ",Tptr_t             ,_param->_nb_inst_branch_predict);
    101101  ALLOC1_SC_SIGNAL( in_DEPTH_UPT_NB_BRANCH                 ," in_DEPTH_UPT_NB_BRANCH                ",Tdepth_t           ,_param->_nb_context);
    102102  ALLOC1_SC_SIGNAL( in_DEPTH_UPT_TAIL                      ," in_DEPTH_UPT_TAIL                     ",Tdepth_t           ,_param->_nb_context);
     103  ALLOC1_SC_SIGNAL(out_DEPTH_NB_BRANCH                     ,"out_DEPTH_NB_BRANCH                    ",Tdepth_t           ,_param->_nb_context);
     104  ALLOC1_SC_SIGNAL(out_DEPTH_TAIL                          ,"out_DEPTH_TAIL                         ",Tdepth_t           ,_param->_nb_context);
     105
     106  ALLOC2_SC_SIGNAL( in_DECOD_VAL                        ," in_DECOD_VAL                        ",Tcontrol_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     107  ALLOC2_SC_SIGNAL(out_DECOD_ACK                        ,"out_DECOD_ACK                        ",Tcontrol_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     108  ALLOC2_SC_SIGNAL( in_DECOD_CONTEXT_ID                 ," in_DECOD_CONTEXT_ID                 ",Tcontext_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     109  ALLOC2_SC_SIGNAL( in_DECOD_MATCH_INST_IFETCH_PTR      ," in_DECOD_MATCH_INST_IFETCH_PTR      ",Tcontrol_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     110  ALLOC2_SC_SIGNAL( in_DECOD_BRANCH_STATE               ," in_DECOD_BRANCH_STATE               ",Tbranch_state_t    ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     111  ALLOC2_SC_SIGNAL( in_DECOD_BRANCH_UPDATE_PREDICTION_ID," in_DECOD_BRANCH_UPDATE_PREDICTION_ID",Tprediction_ptr_t  ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     112  ALLOC2_SC_SIGNAL( in_DECOD_BRANCH_CONDITION           ," in_DECOD_BRANCH_CONDITION           ",Tbranch_condition_t,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     113  ALLOC2_SC_SIGNAL( in_DECOD_BRANCH_DIRECTION           ," in_DECOD_BRANCH_DIRECTION           ",Tcontrol_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     114  ALLOC2_SC_SIGNAL( in_DECOD_ADDRESS_SRC                ," in_DECOD_ADDRESS_SRC                ",Taddress_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     115  ALLOC2_SC_SIGNAL( in_DECOD_ADDRESS_DEST               ," in_DECOD_ADDRESS_DEST               ",Taddress_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     116  ALLOC1_SC_SIGNAL(out_DECOD_BTB_VAL                    ,"out_DECOD_BTB_VAL                    ",Tcontrol_t         ,_param->_nb_inst_branch_decod);
     117  ALLOC1_SC_SIGNAL( in_DECOD_BTB_ACK                    ," in_DECOD_BTB_ACK                    ",Tcontrol_t         ,_param->_nb_inst_branch_decod);
     118  ALLOC1_SC_SIGNAL(out_DECOD_BTB_CONTEXT_ID             ,"out_DECOD_BTB_CONTEXT_ID             ",Tcontext_t         ,_param->_nb_inst_branch_decod);
     119  ALLOC1_SC_SIGNAL(out_DECOD_BTB_ADDRESS_SRC            ,"out_DECOD_BTB_ADDRESS_SRC            ",Taddress_t         ,_param->_nb_inst_branch_decod);
     120  ALLOC1_SC_SIGNAL(out_DECOD_BTB_ADDRESS_DEST           ,"out_DECOD_BTB_ADDRESS_DEST           ",Taddress_t         ,_param->_nb_inst_branch_decod);
     121  ALLOC1_SC_SIGNAL(out_DECOD_BTB_CONDITION              ,"out_DECOD_BTB_CONDITION              ",Tbranch_condition_t,_param->_nb_inst_branch_decod);
     122  ALLOC1_SC_SIGNAL(out_DECOD_BTB_LAST_TAKE              ,"out_DECOD_BTB_LAST_TAKE              ",Tcontrol_t         ,_param->_nb_inst_branch_decod);
     123  ALLOC1_SC_SIGNAL(out_DECOD_BTB_MISS_PREDICTION        ,"out_DECOD_BTB_MISS_PREDICTION        ",Tcontrol_t         ,_param->_nb_inst_branch_decod);
     124  ALLOC1_SC_SIGNAL(out_DECOD_BTB_IS_ACCURATE            ,"out_DECOD_BTB_IS_ACCURATE            ",Tcontrol_t         ,_param->_nb_inst_branch_decod);
     125  ALLOC1_SC_SIGNAL(out_DECOD_RAS_VAL                    ,"out_DECOD_RAS_VAL                    ",Tcontrol_t         ,_param->_nb_inst_branch_decod);
     126  ALLOC1_SC_SIGNAL( in_DECOD_RAS_ACK                    ," in_DECOD_RAS_ACK                    ",Tcontrol_t         ,_param->_nb_inst_branch_decod);
     127  ALLOC1_SC_SIGNAL(out_DECOD_RAS_CONTEXT_ID             ,"out_DECOD_RAS_CONTEXT_ID             ",Tcontext_t         ,_param->_nb_inst_branch_decod);
     128  ALLOC1_SC_SIGNAL( in_DECOD_RAS_HIT                    ," in_DECOD_RAS_HIT                    ",Tcontrol_t         ,_param->_nb_inst_branch_decod);
     129  ALLOC1_SC_SIGNAL(out_DECOD_RAS_PUSH                   ,"out_DECOD_RAS_PUSH                   ",Tcontrol_t         ,_param->_nb_inst_branch_decod);
     130  ALLOC1_SC_SIGNAL(out_DECOD_RAS_ADDRESS_PUSH           ,"out_DECOD_RAS_ADDRESS_PUSH           ",Taddress_t         ,_param->_nb_inst_branch_decod);
     131  ALLOC1_SC_SIGNAL( in_DECOD_RAS_ADDRESS_POP            ," in_DECOD_RAS_ADDRESS_POP            ",Taddress_t         ,_param->_nb_inst_branch_decod);
     132//ALLOC1_SC_SIGNAL( in_DECOD_RAS_INDEX                  ," in_DECOD_RAS_INDEX                  ",Tptr_t             ,_param->_nb_inst_branch_decod);
     133  ALLOC1_SC_SIGNAL(out_DECOD_RAS_MISS_PREDICTION        ,"out_DECOD_RAS_MISS_PREDICTION        ",Tcontrol_t         ,_param->_nb_inst_branch_decod);
     134  ALLOC1_SC_SIGNAL(out_DECOD_UPT_VAL                    ,"out_DECOD_UPT_VAL                    ",Tcontrol_t         ,_param->_nb_inst_branch_decod);
     135  ALLOC1_SC_SIGNAL( in_DECOD_UPT_ACK                    ," in_DECOD_UPT_ACK                    ",Tcontrol_t         ,_param->_nb_inst_branch_decod);
     136  ALLOC1_SC_SIGNAL(out_DECOD_UPT_CONTEXT_ID             ,"out_DECOD_UPT_CONTEXT_ID             ",Tcontext_t         ,_param->_nb_inst_branch_decod);
     137  ALLOC1_SC_SIGNAL(out_DECOD_UPT_BTB_ADDRESS_SRC        ,"out_DECOD_UPT_BTB_ADDRESS_SRC        ",Taddress_t         ,_param->_nb_inst_branch_decod);
     138  ALLOC1_SC_SIGNAL(out_DECOD_UPT_BTB_ADDRESS_DEST       ,"out_DECOD_UPT_BTB_ADDRESS_DEST       ",Taddress_t         ,_param->_nb_inst_branch_decod);
     139  ALLOC1_SC_SIGNAL(out_DECOD_UPT_BTB_CONDITION          ,"out_DECOD_UPT_BTB_CONDITION          ",Tbranch_condition_t,_param->_nb_inst_branch_decod);
     140  ALLOC1_SC_SIGNAL(out_DECOD_UPT_BTB_LAST_TAKE          ,"out_DECOD_UPT_BTB_LAST_TAKE          ",Tcontrol_t         ,_param->_nb_inst_branch_decod);
     141  ALLOC1_SC_SIGNAL(out_DECOD_UPT_RAS_ADDRESS            ,"out_DECOD_UPT_RAS_ADDRESS            ",Taddress_t         ,_param->_nb_inst_branch_decod);
     142//ALLOC1_SC_SIGNAL(out_DECOD_UPT_RAS_INDEX              ,"out_DECOD_UPT_RAS_INDEX              ",Tptr_t             ,_param->_nb_inst_branch_decod);
     143  ALLOC1_SC_SIGNAL(out_DECOD_UPT_MISS_IFETCH            ,"out_DECOD_UPT_MISS_IFETCH            ",Tcontrol_t         ,_param->_nb_inst_branch_decod);
     144  ALLOC1_SC_SIGNAL(out_DECOD_UPT_MISS_DECOD             ,"out_DECOD_UPT_MISS_DECOD             ",Tcontrol_t         ,_param->_nb_inst_branch_decod);
     145  ALLOC1_SC_SIGNAL(out_DECOD_UPT_UPDATE_PREDICTION_ID   ,"out_DECOD_UPT_UPDATE_PREDICTION_ID   ",Tprediction_ptr_t  ,_param->_nb_inst_branch_decod);
    103146 
     147  ALLOC1_SC_SIGNAL(out_UPDATE_BTB_VAL                  ,"out_UPDATE_BTB_VAL                  ",Tcontrol_t         ,_param->_nb_inst_branch_update);
     148  ALLOC1_SC_SIGNAL( in_UPDATE_BTB_ACK                  ," in_UPDATE_BTB_ACK                  ",Tcontrol_t         ,_param->_nb_inst_branch_update);
     149//ALLOC1_SC_SIGNAL(out_UPDATE_BTB_CONTEXT_ID           ,"out_UPDATE_BTB_CONTEXT_ID           ",Tcontext_t         ,_param->_nb_inst_branch_update);
     150//ALLOC1_SC_SIGNAL(out_UPDATE_BTB_ADDRESS_SRC          ,"out_UPDATE_BTB_ADDRESS_SRC          ",Taddress_t         ,_param->_nb_inst_branch_update);
     151//ALLOC1_SC_SIGNAL(out_UPDATE_BTB_ADDRESS_DEST         ,"out_UPDATE_BTB_ADDRESS_DEST         ",Taddress_t         ,_param->_nb_inst_branch_update);
     152//ALLOC1_SC_SIGNAL(out_UPDATE_BTB_CONDITION            ,"out_UPDATE_BTB_CONDITION            ",Tbranch_condition_t,_param->_nb_inst_branch_update);
     153//ALLOC1_SC_SIGNAL(out_UPDATE_BTB_LAST_TAKE            ,"out_UPDATE_BTB_LAST_TAKE            ",Tcontrol_t         ,_param->_nb_inst_branch_update);
     154//ALLOC1_SC_SIGNAL(out_UPDATE_BTB_MISS_PREDICTION      ,"out_UPDATE_BTB_MISS_PREDICTION      ",Tcontrol_t         ,_param->_nb_inst_branch_update);
     155  ALLOC1_SC_SIGNAL(out_UPDATE_DIR_VAL                  ,"out_UPDATE_DIR_VAL                  ",Tcontrol_t         ,_param->_nb_inst_branch_update);
     156  ALLOC1_SC_SIGNAL( in_UPDATE_DIR_ACK                  ," in_UPDATE_DIR_ACK                  ",Tcontrol_t         ,_param->_nb_inst_branch_update);
     157//ALLOC1_SC_SIGNAL(out_UPDATE_DIR_ADDRESS              ,"out_UPDATE_DIR_ADDRESS              ",Taddress_t         ,_param->_nb_inst_branch_update);
     158//ALLOC1_SC_SIGNAL(out_UPDATE_DIR_HISTORY              ,"out_UPDATE_DIR_HISTORY              ",Thistory_t         ,_param->_nb_inst_branch_update);
     159//ALLOC1_SC_SIGNAL(out_UPDATE_DIR_DIRECTION            ,"out_UPDATE_DIR_DIRECTION            ",Tcontrol_t         ,_param->_nb_inst_branch_update);
     160  ALLOC1_SC_SIGNAL(out_UPDATE_RAS_VAL                  ,"out_UPDATE_RAS_VAL                  ",Tcontrol_t         ,_param->_nb_inst_branch_update);
     161  ALLOC1_SC_SIGNAL( in_UPDATE_RAS_ACK                  ," in_UPDATE_RAS_ACK                  ",Tcontrol_t         ,_param->_nb_inst_branch_update);
     162//ALLOC1_SC_SIGNAL(out_UPDATE_RAS_CONTEXT_ID           ,"out_UPDATE_RAS_CONTEXT_ID           ",Tcontext_t         ,_param->_nb_inst_branch_update);
     163//ALLOC1_SC_SIGNAL(out_UPDATE_RAS_PUSH                 ,"out_UPDATE_RAS_PUSH                 ",Tcontrol_t         ,_param->_nb_inst_branch_update);
     164//ALLOC1_SC_SIGNAL(out_UPDATE_RAS_ADDRESS              ,"out_UPDATE_RAS_ADDRESS              ",Taddress_t         ,_param->_nb_inst_branch_update);
     165//ALLOC1_SC_SIGNAL(out_UPDATE_RAS_INDEX                ,"out_UPDATE_RAS_INDEX                ",Tptr_t             ,_param->_nb_inst_branch_update);
     166//ALLOC1_SC_SIGNAL(out_UPDATE_RAS_MISS_PREDICTION      ,"out_UPDATE_RAS_MISS_PREDICTION      ",Tcontrol_t         ,_param->_nb_inst_branch_update);
     167//ALLOC1_SC_SIGNAL(out_UPDATE_RAS_PREDICTION_IFETCH    ,"out_UPDATE_RAS_PREDICTION_IFETCH    ",Tcontrol_t         ,_param->_nb_inst_branch_update);
     168  ALLOC1_SC_SIGNAL( in_UPDATE_UPT_VAL                  ," in_UPDATE_UPT_VAL                  ",Tcontrol_t         ,_param->_nb_inst_branch_update);
     169  ALLOC1_SC_SIGNAL(out_UPDATE_UPT_ACK                  ,"out_UPDATE_UPT_ACK                  ",Tcontrol_t         ,_param->_nb_inst_branch_update);
     170//ALLOC1_SC_SIGNAL( in_UPDATE_UPT_CONTEXT_ID           ," in_UPDATE_UPT_CONTEXT_ID           ",Tcontext_t         ,_param->_nb_inst_branch_update);
     171//ALLOC1_SC_SIGNAL( in_UPDATE_UPT_MISS_PREDICTION      ," in_UPDATE_UPT_MISS_PREDICTION      ",Tcontrol_t         ,_param->_nb_inst_branch_update);
     172//ALLOC1_SC_SIGNAL( in_UPDATE_UPT_DIRECTION_GOOD       ," in_UPDATE_UPT_DIRECTION_GOOD       ",Tcontrol_t         ,_param->_nb_inst_branch_update);
     173  ALLOC1_SC_SIGNAL( in_UPDATE_UPT_BTB_VAL              ," in_UPDATE_UPT_BTB_VAL              ",Tcontrol_t         ,_param->_nb_inst_branch_update);
     174//ALLOC1_SC_SIGNAL( in_UPDATE_UPT_BTB_ADDRESS_SRC      ," in_UPDATE_UPT_BTB_ADDRESS_SRC      ",Taddress_t         ,_param->_nb_inst_branch_update);
     175//ALLOC1_SC_SIGNAL( in_UPDATE_UPT_BTB_ADDRESS_DEST     ," in_UPDATE_UPT_BTB_ADDRESS_DEST     ",Taddress_t         ,_param->_nb_inst_branch_update);
     176//ALLOC1_SC_SIGNAL( in_UPDATE_UPT_BTB_CONDITION        ," in_UPDATE_UPT_BTB_CONDITION        ",Tbranch_condition_t,_param->_nb_inst_branch_update);
     177  ALLOC1_SC_SIGNAL( in_UPDATE_UPT_DIR_VAL              ," in_UPDATE_UPT_DIR_VAL              ",Tcontrol_t         ,_param->_nb_inst_branch_update);
     178//ALLOC1_SC_SIGNAL( in_UPDATE_UPT_DIR_HISTORY          ," in_UPDATE_UPT_DIR_HISTORY          ",Thistory_t         ,_param->_nb_inst_branch_update);
     179  ALLOC1_SC_SIGNAL( in_UPDATE_UPT_RAS_VAL              ," in_UPDATE_UPT_RAS_VAL              ",Tcontrol_t         ,_param->_nb_inst_branch_update);
     180//ALLOC1_SC_SIGNAL( in_UPDATE_UPT_RAS_PUSH             ," in_UPDATE_UPT_RAS_PUSH             ",Tcontrol_t         ,_param->_nb_inst_branch_update);
     181//ALLOC1_SC_SIGNAL( in_UPDATE_UPT_RAS_ADDRESS          ," in_UPDATE_UPT_RAS_ADDRESS          ",Taddress_t         ,_param->_nb_inst_branch_update);
     182//ALLOC1_SC_SIGNAL( in_UPDATE_UPT_RAS_INDEX            ," in_UPDATE_UPT_RAS_INDEX            ",Tptr_t             ,_param->_nb_inst_branch_update);
     183//ALLOC1_SC_SIGNAL( in_UPDATE_UPT_RAS_PREDICTION_IFETCH," in_UPDATE_UPT_RAS_PREDICTION_IFETCH",Tcontrol_t         ,_param->_nb_inst_branch_update);
     184
    104185  /********************************************************
    105186   * Instanciation
    … …  
    119200  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_PC_NEXT_IS_DS_TAKE          ,_param->_nb_context);
    120201  INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_INSTRUCTION_ENABLE          ,_param->_nb_context,_param->_nb_instruction[alloc_signal_it1]);
     202  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_BRANCH_STATE                ,_param->_nb_context);
    121203  for (uint32_t i=0; i<_param->_nb_context; i++)
    122204    {
    … …  
    126208        INSTANCE_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [i]);
    127209    }
    128   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_BRANCH_STATE                ,_param->_nb_context);
    129   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_BTB_VAL                     ,_param->_nb_inst_predict);
    130   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_BTB_ACK                     ,_param->_nb_inst_predict);
     210
     211  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_BTB_VAL                     ,_param->_nb_inst_branch_predict);
     212  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_BTB_ACK                     ,_param->_nb_inst_branch_predict);
    131213  if (_param->_have_port_context_id)
    132   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_BTB_CONTEXT_ID              ,_param->_nb_inst_predict);
    133   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_BTB_ADDRESS                 ,_param->_nb_inst_predict);
    134   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_BTB_HIT                     ,_param->_nb_inst_predict);
    135   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_BTB_ADDRESS_SRC             ,_param->_nb_inst_predict);
    136   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_BTB_ADDRESS_DEST            ,_param->_nb_inst_predict);
    137   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_BTB_CONDITION               ,_param->_nb_inst_predict);
    138 //INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_BTB_LAST_TAKE               ,_param->_nb_inst_predict);
    139   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_BTB_IS_ACCURATE             ,_param->_nb_inst_predict);
    140   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_DIR_VAL                     ,_param->_nb_inst_predict);
    141   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_DIR_ACK                     ,_param->_nb_inst_predict);
    142   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_DIR_ADDRESS_SRC             ,_param->_nb_inst_predict);
    143   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_DIR_STATIC                  ,_param->_nb_inst_predict);
    144 //INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_DIR_LAST_TAKE               ,_param->_nb_inst_predict);
    145 //INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_DIR_HISTORY                 ,_param->_nb_inst_predict);
    146   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_DIR_DIRECTION               ,_param->_nb_inst_predict);
    147   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_RAS_VAL                     ,_param->_nb_inst_predict);
    148   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_RAS_ACK                     ,_param->_nb_inst_predict);
     214  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_BTB_CONTEXT_ID              ,_param->_nb_inst_branch_predict);
     215  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_BTB_ADDRESS                 ,_param->_nb_inst_branch_predict);
     216  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_BTB_HIT                     ,_param->_nb_inst_branch_predict);
     217  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_BTB_ADDRESS_SRC             ,_param->_nb_inst_branch_predict);
     218  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_BTB_ADDRESS_DEST            ,_param->_nb_inst_branch_predict);
     219  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_BTB_CONDITION               ,_param->_nb_inst_branch_predict);
     220//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_BTB_LAST_TAKE               ,_param->_nb_inst_branch_predict);
     221  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_BTB_IS_ACCURATE             ,_param->_nb_inst_branch_predict);
     222
     223  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_DIR_VAL                     ,_param->_nb_inst_branch_predict);
     224  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_DIR_ACK                     ,_param->_nb_inst_branch_predict);
     225  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_DIR_ADDRESS_SRC             ,_param->_nb_inst_branch_predict);
     226  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_DIR_STATIC                  ,_param->_nb_inst_branch_predict);
     227//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_DIR_LAST_TAKE               ,_param->_nb_inst_branch_predict);
     228//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_DIR_HISTORY                 ,_param->_nb_inst_branch_predict);
     229  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_DIR_DIRECTION               ,_param->_nb_inst_branch_predict);
     230
     231  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_RAS_VAL                     ,_param->_nb_inst_branch_predict);
     232  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_RAS_ACK                     ,_param->_nb_inst_branch_predict);
     233
    149234  if (_param->_have_port_context_id)
    150   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_RAS_CONTEXT_ID              ,_param->_nb_inst_predict);
    151   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_RAS_HIT                     ,_param->_nb_inst_predict);
    152   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_RAS_PUSH                    ,_param->_nb_inst_predict);
    153   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_RAS_ADDRESS_PUSH            ,_param->_nb_inst_predict);
    154   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_RAS_ADDRESS_POP             ,_param->_nb_inst_predict);
    155 //INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_RAS_INDEX                   ,_param->_nb_inst_predict);
    156   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_UPT_VAL                     ,_param->_nb_inst_predict);
    157   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_UPT_ACK                     ,_param->_nb_inst_predict);
     235  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_RAS_CONTEXT_ID              ,_param->_nb_inst_branch_predict);
     236  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_RAS_HIT                     ,_param->_nb_inst_branch_predict);
     237  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_RAS_PUSH                    ,_param->_nb_inst_branch_predict);
     238  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_RAS_ADDRESS_PUSH            ,_param->_nb_inst_branch_predict);
     239  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_RAS_ADDRESS_POP             ,_param->_nb_inst_branch_predict);
     240//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_RAS_INDEX                   ,_param->_nb_inst_branch_predict);
     241  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_UPT_VAL                     ,_param->_nb_inst_branch_predict);
     242  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_UPT_ACK                     ,_param->_nb_inst_branch_predict);
    158243  if (_param->_have_port_context_id)
    159   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_UPT_CONTEXT_ID              ,_param->_nb_inst_predict);
    160   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_UPT_BTB_ADDRESS_SRC         ,_param->_nb_inst_predict);
    161   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_UPT_BTB_ADDRESS_DEST        ,_param->_nb_inst_predict);
    162   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_UPT_BTB_CONDITION           ,_param->_nb_inst_predict);
    163   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_UPT_BTB_LAST_TAKE           ,_param->_nb_inst_predict);
    164   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_UPT_BTB_IS_ACCURATE         ,_param->_nb_inst_predict);
    165 //INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_UPT_DIR_HISTORY             ,_param->_nb_inst_predict);
    166   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_UPT_RAS_ADDRESS             ,_param->_nb_inst_predict);
    167 //INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_UPT_RAS_INDEX               ,_param->_nb_inst_predict);
     244  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_UPT_CONTEXT_ID              ,_param->_nb_inst_branch_predict);
     245  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_UPT_BTB_ADDRESS_SRC         ,_param->_nb_inst_branch_predict);
     246  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_UPT_BTB_ADDRESS_DEST        ,_param->_nb_inst_branch_predict);
     247  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_UPT_BTB_CONDITION           ,_param->_nb_inst_branch_predict);
     248  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_UPT_BTB_LAST_TAKE           ,_param->_nb_inst_branch_predict);
     249  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_UPT_BTB_IS_ACCURATE         ,_param->_nb_inst_branch_predict);
     250//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_UPT_DIR_HISTORY             ,_param->_nb_inst_branch_predict);
     251  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_UPT_RAS_ADDRESS             ,_param->_nb_inst_branch_predict);
     252//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_UPT_RAS_INDEX               ,_param->_nb_inst_branch_predict);
     253
     254  INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_VAL                        ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     255  INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_ACK                        ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     256  if (_param->_have_port_context_id)
     257  INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_CONTEXT_ID                 ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     258  INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_MATCH_INST_IFETCH_PTR      ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     259  INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_BRANCH_STATE               ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     260  if (_param->_have_port_max_depth)
     261  INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     262  INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_BRANCH_CONDITION           ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     263  INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_BRANCH_DIRECTION           ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     264  INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_ADDRESS_SRC                ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     265  INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_ADDRESS_DEST               ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     266  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_BTB_VAL                    ,_param->_nb_inst_branch_decod);
     267  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_BTB_ACK                    ,_param->_nb_inst_branch_decod);
     268  if (_param->_have_port_context_id)
     269  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_BTB_CONTEXT_ID             ,_param->_nb_inst_branch_decod);
     270  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_BTB_ADDRESS_SRC            ,_param->_nb_inst_branch_decod);
     271  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_BTB_ADDRESS_DEST           ,_param->_nb_inst_branch_decod);
     272  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_BTB_CONDITION              ,_param->_nb_inst_branch_decod);
     273  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_BTB_LAST_TAKE              ,_param->_nb_inst_branch_decod);
     274  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_BTB_MISS_PREDICTION        ,_param->_nb_inst_branch_decod);
     275  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_BTB_IS_ACCURATE            ,_param->_nb_inst_branch_decod);
     276  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_RAS_VAL                    ,_param->_nb_inst_branch_decod);
     277  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_RAS_ACK                    ,_param->_nb_inst_branch_decod);
     278  if (_param->_have_port_context_id)
     279  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_RAS_CONTEXT_ID             ,_param->_nb_inst_branch_decod);
     280  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_RAS_HIT                    ,_param->_nb_inst_branch_decod);
     281  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_RAS_PUSH                   ,_param->_nb_inst_branch_decod);
     282  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_RAS_ADDRESS_PUSH           ,_param->_nb_inst_branch_decod);
     283  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_RAS_ADDRESS_POP            ,_param->_nb_inst_branch_decod);
     284//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_RAS_INDEX                  ,_param->_nb_inst_branch_decod);
     285  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_RAS_MISS_PREDICTION        ,_param->_nb_inst_branch_decod);
     286  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_UPT_VAL                    ,_param->_nb_inst_branch_decod);
     287  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_UPT_ACK                    ,_param->_nb_inst_branch_decod);
     288  if (_param->_have_port_context_id)
     289  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_UPT_CONTEXT_ID             ,_param->_nb_inst_branch_decod);
     290  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_UPT_BTB_ADDRESS_SRC        ,_param->_nb_inst_branch_decod);
     291  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_UPT_BTB_ADDRESS_DEST       ,_param->_nb_inst_branch_decod);
     292  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_UPT_BTB_CONDITION          ,_param->_nb_inst_branch_decod);
     293  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_UPT_BTB_LAST_TAKE          ,_param->_nb_inst_branch_decod);
     294  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_UPT_RAS_ADDRESS            ,_param->_nb_inst_branch_decod);
     295//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_UPT_RAS_INDEX              ,_param->_nb_inst_branch_decod);
     296  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_UPT_MISS_IFETCH            ,_param->_nb_inst_branch_decod);
     297  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_UPT_MISS_DECOD             ,_param->_nb_inst_branch_decod);
     298  if (_param->_have_port_max_depth)
     299  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_UPT_UPDATE_PREDICTION_ID   ,_param->_nb_inst_branch_decod);
     300
     301  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_UPDATE_BTB_VAL                  ,_param->_nb_inst_branch_update);
     302  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_UPDATE_BTB_ACK                  ,_param->_nb_inst_branch_update);
     303//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_UPDATE_BTB_CONTEXT_ID           ,_param->_nb_inst_branch_update);
     304//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_UPDATE_BTB_ADDRESS_SRC          ,_param->_nb_inst_branch_update);
     305//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_UPDATE_BTB_ADDRESS_DEST         ,_param->_nb_inst_branch_update);
     306//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_UPDATE_BTB_CONDITION            ,_param->_nb_inst_branch_update);
     307//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_UPDATE_BTB_LAST_TAKE            ,_param->_nb_inst_branch_update);
     308//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_UPDATE_BTB_MISS_PREDICTION      ,_param->_nb_inst_branch_update);
     309  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_UPDATE_DIR_VAL                  ,_param->_nb_inst_branch_update);
     310  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_UPDATE_DIR_ACK                  ,_param->_nb_inst_branch_update);
     311//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_UPDATE_DIR_ADDRESS              ,_param->_nb_inst_branch_update);
     312//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_UPDATE_DIR_HISTORY              ,_param->_nb_inst_branch_update);
     313//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_UPDATE_DIR_DIRECTION            ,_param->_nb_inst_branch_update);
     314  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_UPDATE_RAS_VAL                  ,_param->_nb_inst_branch_update);
     315  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_UPDATE_RAS_ACK                  ,_param->_nb_inst_branch_update);
     316//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_UPDATE_RAS_CONTEXT_ID           ,_param->_nb_inst_branch_update);
     317//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_UPDATE_RAS_PUSH                 ,_param->_nb_inst_branch_update);
     318//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_UPDATE_RAS_ADDRESS              ,_param->_nb_inst_branch_update);
     319//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_UPDATE_RAS_INDEX                ,_param->_nb_inst_branch_update);
     320//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_UPDATE_RAS_MISS_PREDICTION      ,_param->_nb_inst_branch_update);
     321//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_UPDATE_RAS_PREDICTION_IFETCH    ,_param->_nb_inst_branch_update);
     322  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_UPDATE_UPT_VAL                  ,_param->_nb_inst_branch_update);
     323  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_UPDATE_UPT_ACK                  ,_param->_nb_inst_branch_update);
     324//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_UPDATE_UPT_CONTEXT_ID           ,_param->_nb_inst_branch_update);
     325//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_UPDATE_UPT_MISS_PREDICTION      ,_param->_nb_inst_branch_update);
     326//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_UPDATE_UPT_DIRECTION_GOOD       ,_param->_nb_inst_branch_update);
     327  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_UPDATE_UPT_BTB_VAL              ,_param->_nb_inst_branch_update);
     328//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_UPDATE_UPT_BTB_ADDRESS_SRC      ,_param->_nb_inst_branch_update);
     329//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_UPDATE_UPT_BTB_ADDRESS_DEST     ,_param->_nb_inst_branch_update);
     330//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_UPDATE_UPT_BTB_CONDITION        ,_param->_nb_inst_branch_update);
     331  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_UPDATE_UPT_DIR_VAL              ,_param->_nb_inst_branch_update);
     332//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_UPDATE_UPT_DIR_HISTORY          ,_param->_nb_inst_branch_update);
     333  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_UPDATE_UPT_RAS_VAL              ,_param->_nb_inst_branch_update);
     334//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_UPDATE_UPT_RAS_PUSH             ,_param->_nb_inst_branch_update);
     335//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_UPDATE_UPT_RAS_ADDRESS          ,_param->_nb_inst_branch_update);
     336//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_UPDATE_UPT_RAS_INDEX            ,_param->_nb_inst_branch_update);
     337//INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_UPDATE_UPT_RAS_PREDICTION_IFETCH,_param->_nb_inst_branch_update);
     338
    168339  for (uint32_t i=0; i<_param->_nb_context; i++)
    169340    {
    170341      if (_param->_have_port_depth [i])
    171342        {
     343          INSTANCE_SC_SIGNAL(_Prediction_unit_Glue, in_DEPTH_UPT_TAIL      [i]);
     344          INSTANCE_SC_SIGNAL(_Prediction_unit_Glue,out_DEPTH_TAIL          [i]);
     345        }
    172346          INSTANCE_SC_SIGNAL(_Prediction_unit_Glue, in_DEPTH_UPT_NB_BRANCH [i]);
    173           INSTANCE_SC_SIGNAL(_Prediction_unit_Glue, in_DEPTH_UPT_TAIL      [i]);
    174         }
     347          INSTANCE_SC_SIGNAL(_Prediction_unit_Glue,out_DEPTH_NB_BRANCH     [i]);
    175348    }
    176349
    … …  
    191364
    192365  int32_t percent_transaction_predict =  75;
     366  int32_t percent_transaction_decod   =  75;
    193367
    194368  SC_START(0);
    … …  
    199373  for (uint32_t i=0; i<_param->_nb_context; i++)
    200374    in_PREDICT_VAL [i]->write(0);
    201   for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     375  for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    202376    {
    203377      in_PREDICT_BTB_ACK         [i]->write(0);
    … …  
    208382      in_PREDICT_BTB_IS_ACCURATE [i]->write(1);
    209383    }
     384  for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
     385    for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
     386      in_DECOD_VAL [i][j]->write(0);
    210387
    211388  in_NRESET->write(0);
    … …  
    237414            do
    238415              {
    239                 for (uint32_t j=0; j<_param->_nb_inst_predict; j++)
     416                for (uint32_t j=0; j<_param->_nb_inst_branch_predict; j++)
    240417                  in_PREDICT_BTB_ACK [j]->write(0);
    241418
    … …  
    245422
    246423                uint32_t port;
    247                 for (port=0; port<_param->_nb_inst_predict; port++)
     424                for (port=0; port<_param->_nb_inst_branch_predict; port++)
    248425                  {
    249426                    if (_param->_have_port_context_id)
    … …  
    289466            for (uint32_t i=0; i<_param->_nb_context; i++)
    290467              in_PREDICT_VAL [i]->write(0);
    291             for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     468            for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    292469              {
    293470                in_PREDICT_BTB_ACK [i]->write(0);
    … …  
    319496            do
    320497              {
    321                 for (uint32_t j=0; j<_param->_nb_inst_predict; j++)
     498                for (uint32_t j=0; j<_param->_nb_inst_branch_predict; j++)
    322499                  in_PREDICT_BTB_ACK [j]->write(0);
    323500
    … …  
    327504
    328505                uint32_t port;
    329                 for (port=0; port<_param->_nb_inst_predict; port++)
     506                for (port=0; port<_param->_nb_inst_branch_predict; port++)
    330507                  {
    331508                    if (_param->_have_port_context_id)
    … …  
    355532
    356533                    TEST(Taddress_t        ,out_PREDICT_PC_NEXT                     [context]->read(),addr_dest);
    357 //                  TEST(Tcontrol_t        ,out_PREDICT_PC_NEXT_IS_DS_TAKE          [context]->read(),0);
     534                    TEST(Tcontrol_t        ,out_PREDICT_PC_NEXT_IS_DS_TAKE          [context]->read(),i==(_param->_nb_instruction [context]-1));
    358535                    TEST(Tinst_ifetch_ptr_t,out_PREDICT_INST_IFETCH_PTR             [context]->read(),i);
    359536                    TEST(Tbranch_state_t   ,out_PREDICT_BRANCH_STATE                [context]->read(),BRANCH_STATE_NSPEC_TAKE);
    360537//                  TEST(Tprediction_ptr_t ,out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [context]->read(),0);
    361                    
    362 //                  for (uint32_t j=0; j<i; j++)
    363 //                    TEST(Tcontrol_t        ,out_PREDICT_INSTRUCTION_ENABLE [context][j]->read(),0);
    364 //                  for (uint32_t j=i; j<_param->_nb_instruction[context]; j++)
    365 //                    TEST(Tcontrol_t        ,out_PREDICT_INSTRUCTION_ENABLE [context][j]->read(),1);
    366                    
     538
     539                    uint32_t k=((addr_src%_param->_nb_instruction[context])==_param->_nb_instruction[context]-1)?_param->_nb_instruction[context]:((addr_src%_param->_nb_instruction[context])+2);
     540                    LABEL("instruction enable : ");
     541                    LABEL("  [0:%d[ = 1",k);
     542                    LABEL("  [%d:%d[ = 1",k,_param->_nb_instruction[context]);
     543                    for (uint32_t j=0; j<k; j++)
     544                      TEST(Tcontrol_t        ,out_PREDICT_INSTRUCTION_ENABLE [context][j]->read(),1);
     545                    for (uint32_t j=k; j<_param->_nb_instruction[context]; j++)
     546                      TEST(Tcontrol_t        ,out_PREDICT_INSTRUCTION_ENABLE [context][j]->read(),0);
     547
    367548                    TEST(Tcontrol_t        ,out_PREDICT_BTB_VAL        [port]->read(),1);
    368549                    TEST(Tcontext_t        ,out_PREDICT_BTB_CONTEXT_ID [port]->read(),context);
    369550                    TEST(Taddress_t        ,out_PREDICT_BTB_ADDRESS    [port]->read(),addr);
    370551                  }
    371 
     552               
    372553                SC_START(1);
    373554
    … …  
    376557            for (uint32_t i=0; i<_param->_nb_context; i++)
    377558              in_PREDICT_VAL [i]->write(0);
    378             for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     559            for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    379560              {
    380561                in_PREDICT_BTB_ACK [i]->write(0);
    … …  
    386567      }
    387568
     569      {
     570        LABEL("Decod - Ok");
     571        uint32_t decod_unit = rand()%_param->_nb_decod_unit;
     572        LABEL("decod_unit : %d",decod_unit);
     573
     574        for (uint32_t i=0; i<_param->_nb_inst_decod[i];i++)
     575          {
     576            Tcontext_t context = i%_param->_nb_context;
     577            in_DECOD_CONTEXT_ID                  [decod_unit][i]->write(context);
     578            in_DECOD_MATCH_INST_IFETCH_PTR       [decod_unit][i]->write(1);
     579            in_DECOD_BRANCH_STATE                [decod_unit][i]->write(BRANCH_STATE_NSPEC_TAKE);
     580
     581            bool find = false;
     582            do
     583              {
     584                in_DECOD_VAL                         [decod_unit][i]->write((rand()%100)<percent_transaction_decod);
     585                in_DECOD_BRANCH_UPDATE_PREDICTION_ID [decod_unit][i]->write(rand()%_param->_size_depth[context]);
     586               
     587                in_DECOD_BTB_ACK[0]->write((rand()%100)<percent_transaction_decod);
     588                in_DECOD_RAS_ACK[0]->write((rand()%100)<percent_transaction_decod);
     589                in_DECOD_UPT_ACK[0]->write((rand()%100)<percent_transaction_decod);
     590               
     591                SC_START(0);
     592           
     593                LABEL("DECOD[%d][%d] - %d %d",decod_unit,i,in_DECOD_VAL[decod_unit][i]->read(),out_DECOD_ACK[decod_unit][i]->read());
     594                if (in_DECOD_VAL[decod_unit][i]->read() and out_DECOD_ACK[decod_unit][i]->read())
     595                  {
     596                    LABEL("DECOD[%d][%d] - Transaction Accepted",decod_unit,i);
     597                    TEST(Tcontrol_t, in_DECOD_UPT_ACK[0]->read(),1);
     598                    TEST(Tcontrol_t,out_DECOD_BTB_VAL[0]->read(),0);
     599                    TEST(Tcontrol_t,out_DECOD_RAS_VAL[0]->read(),0);
     600                    TEST(Tcontrol_t,out_DECOD_UPT_VAL[0]->read(),1);
     601                    find = true;
     602                  }
     603
     604                SC_START(1);
     605
     606              } while (not find);
     607
     608            in_DECOD_VAL    [decod_unit][i]->write(0);
     609            in_DECOD_BTB_ACK[0]->write(0);
     610            in_DECOD_RAS_ACK[0]->write(0);
     611            in_DECOD_UPT_ACK[0]->write(0);
     612          }
     613      }
     614
     615      {
     616        LABEL("Decod - Ko");
     617        uint32_t decod_unit = rand()%_param->_nb_decod_unit;
     618        LABEL("decod_unit : %d",decod_unit);
     619
     620        for (uint32_t i=0; i<_param->_nb_inst_decod[i];i++)
     621          {
     622            Tcontext_t context = i%_param->_nb_context;
     623            in_DECOD_CONTEXT_ID                  [decod_unit][i]->write(context);
     624            in_DECOD_MATCH_INST_IFETCH_PTR       [decod_unit][i]->write(0);
     625            in_DECOD_BRANCH_STATE                [decod_unit][i]->write(BRANCH_STATE_SPEC_TAKE);
     626            in_DECOD_BRANCH_UPDATE_PREDICTION_ID [decod_unit][i]->write(i%_param->_max_size_depth);
     627            in_DECOD_BRANCH_CONDITION            [decod_unit][i]->write(BRANCH_CONDITION_READ_REGISTER_WITH_WRITE_STACK);
     628            in_DECOD_BRANCH_DIRECTION            [decod_unit][i]->write(1);
     629            in_DECOD_ADDRESS_SRC                 [decod_unit][i]->write(0xdeadbeef+i);
     630            in_DECOD_ADDRESS_DEST                [decod_unit][i]->write(0x11061979+i);
     631
     632                                                                                     
     633            bool find = false;
     634            do
     635              {
     636                in_DECOD_VAL                         [decod_unit][i]->write((rand()%100)<percent_transaction_decod);
     637               
     638                in_DECOD_BTB_ACK[0]->write((rand()%100)<percent_transaction_decod);
     639                in_DECOD_RAS_ACK[0]->write((rand()%100)<percent_transaction_decod);
     640                in_DECOD_UPT_ACK[0]->write((rand()%100)<percent_transaction_decod);
     641
     642                in_DECOD_RAS_HIT[0]->write(1);
     643                in_DECOD_RAS_ADDRESS_POP[0]->write(0xdadedead+i);
     644
     645               
     646                SC_START(0);
     647           
     648                LABEL("DECOD[%d][%d] - %d %d",decod_unit,i,in_DECOD_VAL[decod_unit][i]->read(),out_DECOD_ACK[decod_unit][i]->read());
     649                if (in_DECOD_VAL[decod_unit][i]->read() and out_DECOD_ACK[decod_unit][i]->read())
     650                  {
     651                    LABEL("DECOD[%d][%d] - Transaction Accepted",decod_unit,i);
     652                    TEST(Tcontrol_t         , in_DECOD_UPT_ACK                  [0]->read(),1);
     653                    TEST(Tcontrol_t         ,out_DECOD_BTB_VAL                  [0]->read(),1);
     654                    TEST(Tcontrol_t         ,out_DECOD_RAS_VAL                  [0]->read(),1);
     655                    TEST(Tcontrol_t         ,out_DECOD_UPT_VAL                  [0]->read(),1);
     656
     657                    TEST(Tcontext_t         ,out_DECOD_BTB_CONTEXT_ID           [0]->read(),context);
     658                    TEST(Taddress_t         ,out_DECOD_BTB_ADDRESS_SRC          [0]->read(),0xdeadbeef+i);
     659                    TEST(Taddress_t         ,out_DECOD_BTB_ADDRESS_DEST         [0]->read(),0x11061979+i);
     660                    TEST(Tbranch_condition_t,out_DECOD_BTB_CONDITION            [0]->read(),BRANCH_CONDITION_READ_REGISTER_WITH_WRITE_STACK);
     661                    TEST(Tcontrol_t         ,out_DECOD_BTB_LAST_TAKE            [0]->read(),1);
     662                    TEST(Tcontrol_t         ,out_DECOD_BTB_MISS_PREDICTION      [0]->read(),1);
     663                    TEST(Tcontrol_t         ,out_DECOD_BTB_IS_ACCURATE          [0]->read(),0);
     664                    TEST(Tcontext_t         ,out_DECOD_RAS_CONTEXT_ID           [0]->read(),context);
     665                    TEST(Tcontrol_t         ,out_DECOD_RAS_PUSH                 [0]->read(),1);
     666                    TEST(Taddress_t         ,out_DECOD_RAS_ADDRESS_PUSH         [0]->read(),0x11061979+i);
     667                    TEST(Tcontrol_t         ,out_DECOD_RAS_MISS_PREDICTION      [0]->read(),1);
     668                    TEST(Tcontext_t         ,out_DECOD_UPT_CONTEXT_ID           [0]->read(),context);
     669                    TEST(Taddress_t         ,out_DECOD_UPT_BTB_ADDRESS_SRC      [0]->read(),0xdeadbeef+i);
     670                    TEST(Taddress_t         ,out_DECOD_UPT_BTB_ADDRESS_DEST     [0]->read(),0x11061979+i);
     671                    TEST(Tbranch_condition_t,out_DECOD_UPT_BTB_CONDITION        [0]->read(),BRANCH_CONDITION_READ_REGISTER_WITH_WRITE_STACK);
     672                    TEST(Tcontrol_t         ,out_DECOD_UPT_BTB_LAST_TAKE        [0]->read(),1);
     673                    TEST(Taddress_t         ,out_DECOD_UPT_RAS_ADDRESS          [0]->read(),0xdadedead+i);
     674                    TEST(Tcontrol_t         ,out_DECOD_UPT_MISS_IFETCH          [0]->read(),1);
     675                    TEST(Tcontrol_t         ,out_DECOD_UPT_MISS_DECOD           [0]->read(),0);
     676                    TEST(Tprediction_ptr_t  ,out_DECOD_UPT_UPDATE_PREDICTION_ID [0]->read(),i%_param->_max_size_depth);
     677
     678                    find = true;
     679                  }
     680
     681                SC_START(1);
     682
     683              } while (not find);
     684
     685            in_DECOD_VAL    [decod_unit][i]->write(0);
     686            in_DECOD_BTB_ACK[0]->write(0);
     687            in_DECOD_RAS_ACK[0]->write(0);
     688            in_DECOD_UPT_ACK[0]->write(0);
     689          }
     690      }
    388691
    389692      SC_START(1);
    … …  
    413716  DELETE1_SC_SIGNAL(out_PREDICT_BRANCH_STATE                ,_param->_nb_context);
    414717  DELETE1_SC_SIGNAL(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID ,_param->_nb_context);
    415   DELETE1_SC_SIGNAL(out_PREDICT_BTB_VAL                     ,_param->_nb_inst_predict);
    416   DELETE1_SC_SIGNAL( in_PREDICT_BTB_ACK                     ,_param->_nb_inst_predict);
    417   DELETE1_SC_SIGNAL(out_PREDICT_BTB_CONTEXT_ID              ,_param->_nb_inst_predict);
    418   DELETE1_SC_SIGNAL(out_PREDICT_BTB_ADDRESS                 ,_param->_nb_inst_predict);
    419   DELETE1_SC_SIGNAL( in_PREDICT_BTB_HIT                     ,_param->_nb_inst_predict);
    420   DELETE1_SC_SIGNAL( in_PREDICT_BTB_ADDRESS_SRC             ,_param->_nb_inst_predict);
    421   DELETE1_SC_SIGNAL( in_PREDICT_BTB_ADDRESS_DEST            ,_param->_nb_inst_predict);
    422   DELETE1_SC_SIGNAL( in_PREDICT_BTB_CONDITION               ,_param->_nb_inst_predict);
    423 //DELETE1_SC_SIGNAL( in_PREDICT_BTB_LAST_TAKE               ,_param->_nb_inst_predict);
    424   DELETE1_SC_SIGNAL( in_PREDICT_BTB_IS_ACCURATE             ,_param->_nb_inst_predict);
    425   DELETE1_SC_SIGNAL(out_PREDICT_DIR_VAL                     ,_param->_nb_inst_predict);
    426   DELETE1_SC_SIGNAL( in_PREDICT_DIR_ACK                     ,_param->_nb_inst_predict);
    427   DELETE1_SC_SIGNAL(out_PREDICT_DIR_ADDRESS_SRC             ,_param->_nb_inst_predict);
    428   DELETE1_SC_SIGNAL(out_PREDICT_DIR_STATIC                  ,_param->_nb_inst_predict);
    429 //DELETE1_SC_SIGNAL(out_PREDICT_DIR_LAST_TAKE               ,_param->_nb_inst_predict);
    430 //DELETE1_SC_SIGNAL( in_PREDICT_DIR_HISTORY                 ,_param->_nb_inst_predict);
    431   DELETE1_SC_SIGNAL( in_PREDICT_DIR_DIRECTION               ,_param->_nb_inst_predict);
    432   DELETE1_SC_SIGNAL(out_PREDICT_RAS_VAL                     ,_param->_nb_inst_predict);
    433   DELETE1_SC_SIGNAL( in_PREDICT_RAS_ACK                     ,_param->_nb_inst_predict);
    434   DELETE1_SC_SIGNAL(out_PREDICT_RAS_CONTEXT_ID              ,_param->_nb_inst_predict);
    435   DELETE1_SC_SIGNAL( in_PREDICT_RAS_HIT                     ,_param->_nb_inst_predict);
    436   DELETE1_SC_SIGNAL(out_PREDICT_RAS_PUSH                    ,_param->_nb_inst_predict);
    437   DELETE1_SC_SIGNAL(out_PREDICT_RAS_ADDRESS_PUSH            ,_param->_nb_inst_predict);
    438   DELETE1_SC_SIGNAL( in_PREDICT_RAS_ADDRESS_POP             ,_param->_nb_inst_predict);
    439 //DELETE1_SC_SIGNAL( in_PREDICT_RAS_INDEX                   ,_param->_nb_inst_predict);
    440   DELETE1_SC_SIGNAL(out_PREDICT_UPT_VAL                     ,_param->_nb_inst_predict);
    441   DELETE1_SC_SIGNAL( in_PREDICT_UPT_ACK                     ,_param->_nb_inst_predict);
    442   DELETE1_SC_SIGNAL(out_PREDICT_UPT_CONTEXT_ID              ,_param->_nb_inst_predict);
    443   DELETE1_SC_SIGNAL(out_PREDICT_UPT_BTB_ADDRESS_SRC         ,_param->_nb_inst_predict);
    444   DELETE1_SC_SIGNAL(out_PREDICT_UPT_BTB_ADDRESS_DEST        ,_param->_nb_inst_predict);
    445   DELETE1_SC_SIGNAL(out_PREDICT_UPT_BTB_CONDITION           ,_param->_nb_inst_predict);
    446   DELETE1_SC_SIGNAL(out_PREDICT_UPT_BTB_LAST_TAKE           ,_param->_nb_inst_predict);
    447   DELETE1_SC_SIGNAL(out_PREDICT_UPT_BTB_IS_ACCURATE         ,_param->_nb_inst_predict);
    448 //DELETE1_SC_SIGNAL(out_PREDICT_UPT_DIR_HISTORY             ,_param->_nb_inst_predict);
    449   DELETE1_SC_SIGNAL(out_PREDICT_UPT_RAS_ADDRESS             ,_param->_nb_inst_predict);
    450 //DELETE1_SC_SIGNAL(out_PREDICT_UPT_RAS_INDEX               ,_param->_nb_inst_predict);
     718  DELETE1_SC_SIGNAL(out_PREDICT_BTB_VAL                     ,_param->_nb_inst_branch_predict);
     719  DELETE1_SC_SIGNAL( in_PREDICT_BTB_ACK                     ,_param->_nb_inst_branch_predict);
     720  DELETE1_SC_SIGNAL(out_PREDICT_BTB_CONTEXT_ID              ,_param->_nb_inst_branch_predict);
     721  DELETE1_SC_SIGNAL(out_PREDICT_BTB_ADDRESS                 ,_param->_nb_inst_branch_predict);
     722  DELETE1_SC_SIGNAL( in_PREDICT_BTB_HIT                     ,_param->_nb_inst_branch_predict);
     723  DELETE1_SC_SIGNAL( in_PREDICT_BTB_ADDRESS_SRC             ,_param->_nb_inst_branch_predict);
     724  DELETE1_SC_SIGNAL( in_PREDICT_BTB_ADDRESS_DEST            ,_param->_nb_inst_branch_predict);
     725  DELETE1_SC_SIGNAL( in_PREDICT_BTB_CONDITION               ,_param->_nb_inst_branch_predict);
     726//DELETE1_SC_SIGNAL( in_PREDICT_BTB_LAST_TAKE               ,_param->_nb_inst_branch_predict);
     727  DELETE1_SC_SIGNAL( in_PREDICT_BTB_IS_ACCURATE             ,_param->_nb_inst_branch_predict);
     728  DELETE1_SC_SIGNAL(out_PREDICT_DIR_VAL                     ,_param->_nb_inst_branch_predict);
     729  DELETE1_SC_SIGNAL( in_PREDICT_DIR_ACK                     ,_param->_nb_inst_branch_predict);
     730  DELETE1_SC_SIGNAL(out_PREDICT_DIR_ADDRESS_SRC             ,_param->_nb_inst_branch_predict);
     731  DELETE1_SC_SIGNAL(out_PREDICT_DIR_STATIC                  ,_param->_nb_inst_branch_predict);
     732//DELETE1_SC_SIGNAL(out_PREDICT_DIR_LAST_TAKE               ,_param->_nb_inst_branch_predict);
     733//DELETE1_SC_SIGNAL( in_PREDICT_DIR_HISTORY                 ,_param->_nb_inst_branch_predict);
     734  DELETE1_SC_SIGNAL( in_PREDICT_DIR_DIRECTION               ,_param->_nb_inst_branch_predict);
     735  DELETE1_SC_SIGNAL(out_PREDICT_RAS_VAL                     ,_param->_nb_inst_branch_predict);
     736  DELETE1_SC_SIGNAL( in_PREDICT_RAS_ACK                     ,_param->_nb_inst_branch_predict);
     737  DELETE1_SC_SIGNAL(out_PREDICT_RAS_CONTEXT_ID              ,_param->_nb_inst_branch_predict);
     738  DELETE1_SC_SIGNAL( in_PREDICT_RAS_HIT                     ,_param->_nb_inst_branch_predict);
     739  DELETE1_SC_SIGNAL(out_PREDICT_RAS_PUSH                    ,_param->_nb_inst_branch_predict);
     740  DELETE1_SC_SIGNAL(out_PREDICT_RAS_ADDRESS_PUSH            ,_param->_nb_inst_branch_predict);
     741  DELETE1_SC_SIGNAL( in_PREDICT_RAS_ADDRESS_POP             ,_param->_nb_inst_branch_predict);
     742//DELETE1_SC_SIGNAL( in_PREDICT_RAS_INDEX                   ,_param->_nb_inst_branch_predict);
     743  DELETE1_SC_SIGNAL(out_PREDICT_UPT_VAL                     ,_param->_nb_inst_branch_predict);
     744  DELETE1_SC_SIGNAL( in_PREDICT_UPT_ACK                     ,_param->_nb_inst_branch_predict);
     745  DELETE1_SC_SIGNAL(out_PREDICT_UPT_CONTEXT_ID              ,_param->_nb_inst_branch_predict);
     746  DELETE1_SC_SIGNAL(out_PREDICT_UPT_BTB_ADDRESS_SRC         ,_param->_nb_inst_branch_predict);
     747  DELETE1_SC_SIGNAL(out_PREDICT_UPT_BTB_ADDRESS_DEST        ,_param->_nb_inst_branch_predict);
     748  DELETE1_SC_SIGNAL(out_PREDICT_UPT_BTB_CONDITION           ,_param->_nb_inst_branch_predict);
     749  DELETE1_SC_SIGNAL(out_PREDICT_UPT_BTB_LAST_TAKE           ,_param->_nb_inst_branch_predict);
     750  DELETE1_SC_SIGNAL(out_PREDICT_UPT_BTB_IS_ACCURATE         ,_param->_nb_inst_branch_predict);
     751//DELETE1_SC_SIGNAL(out_PREDICT_UPT_DIR_HISTORY             ,_param->_nb_inst_branch_predict);
     752  DELETE1_SC_SIGNAL(out_PREDICT_UPT_RAS_ADDRESS             ,_param->_nb_inst_branch_predict);
     753//DELETE1_SC_SIGNAL(out_PREDICT_UPT_RAS_INDEX               ,_param->_nb_inst_branch_predict);
    451754  DELETE1_SC_SIGNAL( in_DEPTH_UPT_NB_BRANCH                 ,_param->_nb_context);
    452755  DELETE1_SC_SIGNAL( in_DEPTH_UPT_TAIL                      ,_param->_nb_context);
     756  DELETE1_SC_SIGNAL(out_DEPTH_NB_BRANCH                     ,_param->_nb_context);
     757  DELETE1_SC_SIGNAL(out_DEPTH_TAIL                          ,_param->_nb_context);
     758
     759  DELETE2_SC_SIGNAL( in_DECOD_VAL                        ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     760  DELETE2_SC_SIGNAL(out_DECOD_ACK                        ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     761  DELETE2_SC_SIGNAL( in_DECOD_CONTEXT_ID                 ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     762  DELETE2_SC_SIGNAL( in_DECOD_MATCH_INST_IFETCH_PTR      ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     763  DELETE2_SC_SIGNAL( in_DECOD_BRANCH_STATE               ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     764  DELETE2_SC_SIGNAL( in_DECOD_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     765  DELETE2_SC_SIGNAL( in_DECOD_BRANCH_CONDITION           ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     766  DELETE2_SC_SIGNAL( in_DECOD_BRANCH_DIRECTION           ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     767  DELETE2_SC_SIGNAL( in_DECOD_ADDRESS_SRC                ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     768  DELETE2_SC_SIGNAL( in_DECOD_ADDRESS_DEST               ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     769  DELETE1_SC_SIGNAL(out_DECOD_BTB_VAL                    ,_param->_nb_inst_branch_decod);
     770  DELETE1_SC_SIGNAL( in_DECOD_BTB_ACK                    ,_param->_nb_inst_branch_decod);
     771  DELETE1_SC_SIGNAL(out_DECOD_BTB_CONTEXT_ID             ,_param->_nb_inst_branch_decod);
     772  DELETE1_SC_SIGNAL(out_DECOD_BTB_ADDRESS_SRC            ,_param->_nb_inst_branch_decod);
     773  DELETE1_SC_SIGNAL(out_DECOD_BTB_ADDRESS_DEST           ,_param->_nb_inst_branch_decod);
     774  DELETE1_SC_SIGNAL(out_DECOD_BTB_CONDITION              ,_param->_nb_inst_branch_decod);
     775  DELETE1_SC_SIGNAL(out_DECOD_BTB_LAST_TAKE              ,_param->_nb_inst_branch_decod);
     776  DELETE1_SC_SIGNAL(out_DECOD_BTB_MISS_PREDICTION        ,_param->_nb_inst_branch_decod);
     777  DELETE1_SC_SIGNAL(out_DECOD_BTB_IS_ACCURATE            ,_param->_nb_inst_branch_decod);
     778  DELETE1_SC_SIGNAL(out_DECOD_RAS_VAL                    ,_param->_nb_inst_branch_decod);
     779  DELETE1_SC_SIGNAL( in_DECOD_RAS_ACK                    ,_param->_nb_inst_branch_decod);
     780  DELETE1_SC_SIGNAL(out_DECOD_RAS_CONTEXT_ID             ,_param->_nb_inst_branch_decod);
     781  DELETE1_SC_SIGNAL( in_DECOD_RAS_HIT                    ,_param->_nb_inst_branch_decod);
     782  DELETE1_SC_SIGNAL(out_DECOD_RAS_PUSH                   ,_param->_nb_inst_branch_decod);
     783  DELETE1_SC_SIGNAL(out_DECOD_RAS_ADDRESS_PUSH           ,_param->_nb_inst_branch_decod);
     784  DELETE1_SC_SIGNAL( in_DECOD_RAS_ADDRESS_POP            ,_param->_nb_inst_branch_decod);
     785//DELETE1_SC_SIGNAL( in_DECOD_RAS_INDEX                  ,_param->_nb_inst_branch_decod);
     786  DELETE1_SC_SIGNAL(out_DECOD_RAS_MISS_PREDICTION        ,_param->_nb_inst_branch_decod);
     787  DELETE1_SC_SIGNAL(out_DECOD_UPT_VAL                    ,_param->_nb_inst_branch_decod);
     788  DELETE1_SC_SIGNAL( in_DECOD_UPT_ACK                    ,_param->_nb_inst_branch_decod);
     789  DELETE1_SC_SIGNAL(out_DECOD_UPT_CONTEXT_ID             ,_param->_nb_inst_branch_decod);
     790  DELETE1_SC_SIGNAL(out_DECOD_UPT_BTB_ADDRESS_SRC        ,_param->_nb_inst_branch_decod);
     791  DELETE1_SC_SIGNAL(out_DECOD_UPT_BTB_ADDRESS_DEST       ,_param->_nb_inst_branch_decod);
     792  DELETE1_SC_SIGNAL(out_DECOD_UPT_BTB_CONDITION          ,_param->_nb_inst_branch_decod);
     793  DELETE1_SC_SIGNAL(out_DECOD_UPT_BTB_LAST_TAKE          ,_param->_nb_inst_branch_decod);
     794  DELETE1_SC_SIGNAL(out_DECOD_UPT_RAS_ADDRESS            ,_param->_nb_inst_branch_decod);
     795//DELETE1_SC_SIGNAL(out_DECOD_UPT_RAS_INDEX              ,_param->_nb_inst_branch_decod);
     796  DELETE1_SC_SIGNAL(out_DECOD_UPT_MISS_IFETCH            ,_param->_nb_inst_branch_decod);
     797  DELETE1_SC_SIGNAL(out_DECOD_UPT_MISS_DECOD             ,_param->_nb_inst_branch_decod);
     798  DELETE1_SC_SIGNAL(out_DECOD_UPT_UPDATE_PREDICTION_ID   ,_param->_nb_inst_branch_decod);
     799
     800  DELETE1_SC_SIGNAL(out_UPDATE_BTB_VAL                  ,_param->_nb_inst_branch_update);
     801  DELETE1_SC_SIGNAL( in_UPDATE_BTB_ACK                  ,_param->_nb_inst_branch_update);
     802//DELETE1_SC_SIGNAL(out_UPDATE_BTB_CONTEXT_ID           ,_param->_nb_inst_branch_update);
     803//DELETE1_SC_SIGNAL(out_UPDATE_BTB_ADDRESS_SRC          ,_param->_nb_inst_branch_update);
     804//DELETE1_SC_SIGNAL(out_UPDATE_BTB_ADDRESS_DEST         ,_param->_nb_inst_branch_update);
     805//DELETE1_SC_SIGNAL(out_UPDATE_BTB_CONDITION            ,_param->_nb_inst_branch_update);
     806//DELETE1_SC_SIGNAL(out_UPDATE_BTB_LAST_TAKE            ,_param->_nb_inst_branch_update);
     807//DELETE1_SC_SIGNAL(out_UPDATE_BTB_MISS_PREDICTION      ,_param->_nb_inst_branch_update);
     808  DELETE1_SC_SIGNAL(out_UPDATE_DIR_VAL                  ,_param->_nb_inst_branch_update);
     809  DELETE1_SC_SIGNAL( in_UPDATE_DIR_ACK                  ,_param->_nb_inst_branch_update);
     810//DELETE1_SC_SIGNAL(out_UPDATE_DIR_ADDRESS              ,_param->_nb_inst_branch_update);
     811//DELETE1_SC_SIGNAL(out_UPDATE_DIR_HISTORY              ,_param->_nb_inst_branch_update);
     812//DELETE1_SC_SIGNAL(out_UPDATE_DIR_DIRECTION            ,_param->_nb_inst_branch_update);
     813  DELETE1_SC_SIGNAL(out_UPDATE_RAS_VAL                  ,_param->_nb_inst_branch_update);
     814  DELETE1_SC_SIGNAL( in_UPDATE_RAS_ACK                  ,_param->_nb_inst_branch_update);
     815//DELETE1_SC_SIGNAL(out_UPDATE_RAS_CONTEXT_ID           ,_param->_nb_inst_branch_update);
     816//DELETE1_SC_SIGNAL(out_UPDATE_RAS_PUSH                 ,_param->_nb_inst_branch_update);
     817//DELETE1_SC_SIGNAL(out_UPDATE_RAS_ADDRESS              ,_param->_nb_inst_branch_update);
     818//DELETE1_SC_SIGNAL(out_UPDATE_RAS_INDEX                ,_param->_nb_inst_branch_update);
     819//DELETE1_SC_SIGNAL(out_UPDATE_RAS_MISS_PREDICTION      ,_param->_nb_inst_branch_update);
     820//DELETE1_SC_SIGNAL(out_UPDATE_RAS_PREDICTION_IFETCH    ,_param->_nb_inst_branch_update);
     821  DELETE1_SC_SIGNAL( in_UPDATE_UPT_VAL                  ,_param->_nb_inst_branch_update);
     822  DELETE1_SC_SIGNAL(out_UPDATE_UPT_ACK                  ,_param->_nb_inst_branch_update);
     823//DELETE1_SC_SIGNAL( in_UPDATE_UPT_CONTEXT_ID           ,_param->_nb_inst_branch_update);
     824//DELETE1_SC_SIGNAL( in_UPDATE_UPT_MISS_PREDICTION      ,_param->_nb_inst_branch_update);
     825//DELETE1_SC_SIGNAL( in_UPDATE_UPT_DIRECTION_GOOD       ,_param->_nb_inst_branch_update);
     826  DELETE1_SC_SIGNAL( in_UPDATE_UPT_BTB_VAL              ,_param->_nb_inst_branch_update);
     827//DELETE1_SC_SIGNAL( in_UPDATE_UPT_BTB_ADDRESS_SRC      ,_param->_nb_inst_branch_update);
     828//DELETE1_SC_SIGNAL( in_UPDATE_UPT_BTB_ADDRESS_DEST     ,_param->_nb_inst_branch_update);
     829//DELETE1_SC_SIGNAL( in_UPDATE_UPT_BTB_CONDITION        ,_param->_nb_inst_branch_update);
     830  DELETE1_SC_SIGNAL( in_UPDATE_UPT_DIR_VAL              ,_param->_nb_inst_branch_update);
     831//DELETE1_SC_SIGNAL( in_UPDATE_UPT_DIR_HISTORY          ,_param->_nb_inst_branch_update);
     832  DELETE1_SC_SIGNAL( in_UPDATE_UPT_RAS_VAL              ,_param->_nb_inst_branch_update);
     833//DELETE1_SC_SIGNAL( in_UPDATE_UPT_RAS_PUSH             ,_param->_nb_inst_branch_update);
     834//DELETE1_SC_SIGNAL( in_UPDATE_UPT_RAS_ADDRESS          ,_param->_nb_inst_branch_update);
     835//DELETE1_SC_SIGNAL( in_UPDATE_UPT_RAS_INDEX            ,_param->_nb_inst_branch_update);
     836//DELETE1_SC_SIGNAL( in_UPDATE_UPT_RAS_PREDICTION_IFETCH,_param->_nb_inst_branch_update);
     837
    453838    }
    454839#endif
    455840
    456841  delete _Prediction_unit_Glue;
     842
    457843#ifdef STATISTICS
    458844  delete _parameters_statistics;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue/include/Parameters.h

    r81 r82  
    2424  {
    2525    //-----[ fields ]------------------------------------------------------------
    26   public : uint32_t   _nb_context               ;
     26  public : uint32_t   _nb_context               ;// == nb_ifetch_unit
     27  public : uint32_t   _nb_decod_unit            ;
     28//public : uint32_t   _nb_ooo_engine            ;
    2729  public : uint32_t   _size_address             ;
    28   public : uint32_t * _nb_instruction           ;
    29   public : uint32_t * _size_depth               ;
    30   public : uint32_t   _nb_inst_predict          ;
    31   public : uint32_t   _nb_inst_decod            ;
    32   public : uint32_t   _nb_inst_update           ;
     30  public : uint32_t * _nb_instruction           ;//[nb_context]
     31  public : uint32_t * _size_depth               ;//[nb_context]
     32  public : uint32_t * _nb_inst_decod            ;//[nb_decod_unit]
     33//public : uint32_t * _nb_inst_update           ;//[nb_ooo_engine]
     34  public : uint32_t   _nb_inst_branch_predict   ;
     35  public : uint32_t   _nb_inst_branch_decod     ;
     36  public : uint32_t   _nb_inst_branch_update    ;
    3337//public : uint32_t   _nb_inst_branch_complete  ;
    3438
    3539  public : uint32_t   _size_context_id          ;
    36   public : uint32_t * _size_inst_ifetch_ptr     ;
     40  public : uint32_t * _size_inst_ifetch_ptr     ;//[nb_context]
     41  public : uint32_t   _max_size_depth           ;
    3742
    3843  public : bool       _have_port_context_id     ;
    39   public : bool     * _have_port_depth          ;   
    40   public : bool     * _have_port_inst_ifetch_ptr;
     44  public : bool       _have_port_max_depth      ;
     45  public : bool     * _have_port_depth          ;//[nb_context]
     46  public : bool     * _have_port_inst_ifetch_ptr;//[nb_context]
    4147
    4248    //-----[ methods ]-----------------------------------------------------------
    43   public : Parameters  (uint32_t   nb_context     ,
    44                         uint32_t   size_address   ,
    45                         uint32_t * nb_instruction ,
    46                         uint32_t * size_depth     ,
    47                         uint32_t   nb_inst_predict,
    48                         uint32_t   nb_inst_decod  ,
    49                         uint32_t   nb_inst_update );
     49  public : Parameters  (uint32_t   nb_context            ,
     50                        uint32_t   nb_decod_unit         ,
     51//                      uint32_t   nb_ooo_engine         ,
     52                        uint32_t   size_address          ,
     53                        uint32_t * nb_instruction        ,
     54                        uint32_t * size_depth            ,
     55                        uint32_t * nb_inst_decod         ,
     56//                      uint32_t * nb_inst_update        ,
     57                        uint32_t   nb_inst_branch_predict,
     58                        uint32_t   nb_inst_branch_decod  ,
     59                        uint32_t   nb_inst_branch_update );
    5060//   public : Parameters  (Parameters & param) ;
    5161  public : ~Parameters () ;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue/include/Prediction_unit_Glue.h

    r81 r82  
    7575  public    : SC_OUT(Tprediction_ptr_t  )  ** out_PREDICT_BRANCH_UPDATE_PREDICTION_ID ; //[nb_context]
    7676
    77   public    : SC_OUT(Tcontrol_t         )  ** out_PREDICT_BTB_VAL                     ; //[nb_inst_predict]
    78   public    : SC_IN (Tcontrol_t         )  **  in_PREDICT_BTB_ACK                     ; //[nb_inst_predict]
    79   public    : SC_OUT(Tcontext_t         )  ** out_PREDICT_BTB_CONTEXT_ID              ; //[nb_inst_predict]
    80   public    : SC_OUT(Taddress_t         )  ** out_PREDICT_BTB_ADDRESS                 ; //[nb_inst_predict]
    81   public    : SC_IN (Tcontrol_t         )  **  in_PREDICT_BTB_HIT                     ; //[nb_inst_predict]
    82   public    : SC_IN (Taddress_t         )  **  in_PREDICT_BTB_ADDRESS_SRC             ; //[nb_inst_predict]
    83   public    : SC_IN (Taddress_t         )  **  in_PREDICT_BTB_ADDRESS_DEST            ; //[nb_inst_predict]
    84   public    : SC_IN (Tbranch_condition_t)  **  in_PREDICT_BTB_CONDITION               ; //[nb_inst_predict]
    85 //public    : SC_IN (Tcontrol_t         )  **  in_PREDICT_BTB_LAST_TAKE               ; //[nb_inst_predict]  DIR.LAST_TAKE
    86   public    : SC_IN (Tcontrol_t         )  **  in_PREDICT_BTB_IS_ACCURATE             ; //[nb_inst_predict]
     77  public    : SC_OUT(Tcontrol_t         )  ** out_PREDICT_BTB_VAL                     ; //[nb_inst_branch_predict]
     78  public    : SC_IN (Tcontrol_t         )  **  in_PREDICT_BTB_ACK                     ; //[nb_inst_branch_predict]
     79  public    : SC_OUT(Tcontext_t         )  ** out_PREDICT_BTB_CONTEXT_ID              ; //[nb_inst_branch_predict]
     80  public    : SC_OUT(Taddress_t         )  ** out_PREDICT_BTB_ADDRESS                 ; //[nb_inst_branch_predict]
     81  public    : SC_IN (Tcontrol_t         )  **  in_PREDICT_BTB_HIT                     ; //[nb_inst_branch_predict]
     82  public    : SC_IN (Taddress_t         )  **  in_PREDICT_BTB_ADDRESS_SRC             ; //[nb_inst_branch_predict]
     83  public    : SC_IN (Taddress_t         )  **  in_PREDICT_BTB_ADDRESS_DEST            ; //[nb_inst_branch_predict]
     84  public    : SC_IN (Tbranch_condition_t)  **  in_PREDICT_BTB_CONDITION               ; //[nb_inst_branch_predict]
     85//public    : SC_IN (Tcontrol_t         )  **  in_PREDICT_BTB_LAST_TAKE               ; //[nb_inst_branch_predict]  DIR.LAST_TAKE
     86  public    : SC_IN (Tcontrol_t         )  **  in_PREDICT_BTB_IS_ACCURATE             ; //[nb_inst_branch_predict]
    8787                                                                                                       
    88   public    : SC_OUT(Tcontrol_t         )  ** out_PREDICT_DIR_VAL                     ; //[nb_inst_predict]
    89   public    : SC_IN (Tcontrol_t         )  **  in_PREDICT_DIR_ACK                     ; //[nb_inst_predict]
    90   public    : SC_OUT(Taddress_t         )  ** out_PREDICT_DIR_ADDRESS_SRC             ; //[nb_inst_predict]
    91   public    : SC_OUT(Tcontrol_t         )  ** out_PREDICT_DIR_STATIC                  ; //[nb_inst_predict]
    92 //public    : SC_OUT(Tcontrol_t         )  ** out_PREDICT_DIR_LAST_TAKE               ; //[nb_inst_predict]  BTB.LAST_TAKE
    93 //public    : SC_IN (Thistory_t         )  **  in_PREDICT_DIR_HISTORY                 ; //[nb_inst_predict]  UPT.DIR_HISTORY
    94   public    : SC_IN (Tcontrol_t         )  **  in_PREDICT_DIR_DIRECTION               ; //[nb_inst_predict]
    95 
    96   public    : SC_OUT(Tcontrol_t         )  ** out_PREDICT_RAS_VAL                     ; //[nb_inst_predict]
    97   public    : SC_IN (Tcontrol_t         )  **  in_PREDICT_RAS_ACK                     ; //[nb_inst_predict]
    98   public    : SC_OUT(Tcontext_t         )  ** out_PREDICT_RAS_CONTEXT_ID              ; //[nb_inst_predict]
    99   public    : SC_IN (Tcontrol_t         )  **  in_PREDICT_RAS_HIT                     ; //[nb_inst_predict] 
    100   public    : SC_OUT(Tcontrol_t         )  ** out_PREDICT_RAS_PUSH                    ; //[nb_inst_predict]
    101   public    : SC_OUT(Taddress_t         )  ** out_PREDICT_RAS_ADDRESS_PUSH            ; //[nb_inst_predict]
    102   public    : SC_IN (Taddress_t         )  **  in_PREDICT_RAS_ADDRESS_POP             ; //[nb_inst_predict]
    103 //public    : SC_IN (Tptr_t             )  **  in_PREDICT_RAS_INDEX                   ; //[nb_inst_predict]  UPT.RAS_INDEX
     88  public    : SC_OUT(Tcontrol_t         )  ** out_PREDICT_DIR_VAL                     ; //[nb_inst_branch_predict]
     89  public    : SC_IN (Tcontrol_t         )  **  in_PREDICT_DIR_ACK                     ; //[nb_inst_branch_predict]
     90  public    : SC_OUT(Taddress_t         )  ** out_PREDICT_DIR_ADDRESS_SRC             ; //[nb_inst_branch_predict]
     91  public    : SC_OUT(Tcontrol_t         )  ** out_PREDICT_DIR_STATIC                  ; //[nb_inst_branch_predict]
     92//public    : SC_OUT(Tcontrol_t         )  ** out_PREDICT_DIR_LAST_TAKE               ; //[nb_inst_branch_predict]  BTB.LAST_TAKE
     93//public    : SC_IN (Thistory_t         )  **  in_PREDICT_DIR_HISTORY                 ; //[nb_inst_branch_predict]  UPT.DIR_HISTORY
     94  public    : SC_IN (Tcontrol_t         )  **  in_PREDICT_DIR_DIRECTION               ; //[nb_inst_branch_predict]
     95
     96  public    : SC_OUT(Tcontrol_t         )  ** out_PREDICT_RAS_VAL                     ; //[nb_inst_branch_predict]
     97  public    : SC_IN (Tcontrol_t         )  **  in_PREDICT_RAS_ACK                     ; //[nb_inst_branch_predict]
     98  public    : SC_OUT(Tcontext_t         )  ** out_PREDICT_RAS_CONTEXT_ID              ; //[nb_inst_branch_predict]
     99  public    : SC_IN (Tcontrol_t         )  **  in_PREDICT_RAS_HIT                     ; //[nb_inst_branch_predict] 
     100  public    : SC_OUT(Tcontrol_t         )  ** out_PREDICT_RAS_PUSH                    ; //[nb_inst_branch_predict]
     101  public    : SC_OUT(Taddress_t         )  ** out_PREDICT_RAS_ADDRESS_PUSH            ; //[nb_inst_branch_predict]
     102  public    : SC_IN (Taddress_t         )  **  in_PREDICT_RAS_ADDRESS_POP             ; //[nb_inst_branch_predict]
     103//public    : SC_IN (Tptr_t             )  **  in_PREDICT_RAS_INDEX                   ; //[nb_inst_branch_predict]  UPT.RAS_INDEX
    104104                                                                                                       
    105   public    : SC_OUT(Tcontrol_t         )  ** out_PREDICT_UPT_VAL                     ; //[nb_inst_predict]
    106   public    : SC_IN (Tcontrol_t         )  **  in_PREDICT_UPT_ACK                     ; //[nb_inst_predict]
    107   public    : SC_OUT(Tcontext_t         )  ** out_PREDICT_UPT_CONTEXT_ID              ; //[nb_inst_predict]
    108   public    : SC_OUT(Taddress_t         )  ** out_PREDICT_UPT_BTB_ADDRESS_SRC         ; //[nb_inst_predict]* BTB.ADDRESS_SRC
    109   public    : SC_OUT(Taddress_t         )  ** out_PREDICT_UPT_BTB_ADDRESS_DEST        ; //[nb_inst_predict]
    110   public    : SC_OUT(Tbranch_condition_t)  ** out_PREDICT_UPT_BTB_CONDITION           ; //[nb_inst_predict]* BTB.CONDITION
    111   public    : SC_OUT(Tcontrol_t         )  ** out_PREDICT_UPT_BTB_LAST_TAKE           ; //[nb_inst_predict]
    112   public    : SC_OUT(Tcontrol_t         )  ** out_PREDICT_UPT_BTB_IS_ACCURATE         ; //[nb_inst_predict]
    113 //public    : SC_OUT(Thistory_t         )  ** out_PREDICT_UPT_DIR_HISTORY             ; //[nb_inst_predict]  DIR.HISTORY
    114   public    : SC_OUT(Taddress_t         )  ** out_PREDICT_UPT_RAS_ADDRESS             ; //[nb_inst_predict]* RAS.ADDRESS_POP
    115 //public    : SC_OUT(Tptr_t             )  ** out_PREDICT_UPT_RAS_INDEX               ; //[nb_inst_predict]  RAS.INDEX
     105  public    : SC_OUT(Tcontrol_t         )  ** out_PREDICT_UPT_VAL                     ; //[nb_inst_branch_predict]
     106  public    : SC_IN (Tcontrol_t         )  **  in_PREDICT_UPT_ACK                     ; //[nb_inst_branch_predict]
     107  public    : SC_OUT(Tcontext_t         )  ** out_PREDICT_UPT_CONTEXT_ID              ; //[nb_inst_branch_predict]
     108  public    : SC_OUT(Taddress_t         )  ** out_PREDICT_UPT_BTB_ADDRESS_SRC         ; //[nb_inst_branch_predict]* BTB.ADDRESS_SRC
     109  public    : SC_OUT(Taddress_t         )  ** out_PREDICT_UPT_BTB_ADDRESS_DEST        ; //[nb_inst_branch_predict]
     110  public    : SC_OUT(Tbranch_condition_t)  ** out_PREDICT_UPT_BTB_CONDITION           ; //[nb_inst_branch_predict]* BTB.CONDITION
     111  public    : SC_OUT(Tcontrol_t         )  ** out_PREDICT_UPT_BTB_LAST_TAKE           ; //[nb_inst_branch_predict]
     112  public    : SC_OUT(Tcontrol_t         )  ** out_PREDICT_UPT_BTB_IS_ACCURATE         ; //[nb_inst_branch_predict]
     113//public    : SC_OUT(Thistory_t         )  ** out_PREDICT_UPT_DIR_HISTORY             ; //[nb_inst_branch_predict]  DIR.HISTORY
     114  public    : SC_OUT(Taddress_t         )  ** out_PREDICT_UPT_RAS_ADDRESS             ; //[nb_inst_branch_predict]* RAS.ADDRESS_POP
     115//public    : SC_OUT(Tptr_t             )  ** out_PREDICT_UPT_RAS_INDEX               ; //[nb_inst_branch_predict]  RAS.INDEX
    116116                                                                                     
    117117    // ~~~~~[ Interface : "decod" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~           
    118   public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_BTB_VAL                       ; //[nb_inst_decod]
    119   public    : SC_IN (Tcontrol_t         )  **  in_DECOD_BTB_ACK                       ; //[nb_inst_decod]
    120   public    : SC_OUT(Tcontext_t         )  ** out_DECOD_BTB_CONTEXT_ID                ; //[nb_inst_decod]
    121   public    : SC_OUT(Taddress_t         )  ** out_DECOD_BTB_ADDRESS_SRC               ; //[nb_inst_decod]
    122   public    : SC_OUT(Taddress_t         )  ** out_DECOD_BTB_ADDRESS_DEST              ; //[nb_inst_decod]
    123   public    : SC_OUT(Tbranch_condition_t)  ** out_DECOD_BTB_CONDITION                 ; //[nb_inst_decod]
    124   public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_BTB_LAST_TAKE                 ; //[nb_inst_decod]
    125   public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_BTB_MISS_PREDICTION           ; //[nb_inst_decod]
     118  public    : SC_IN (Tcontrol_t         ) ***  in_DECOD_VAL                           ; //[nb_decod_unit][nb_inst_decod]
     119  public    : SC_OUT(Tcontrol_t         ) *** out_DECOD_ACK                           ; //[nb_decod_unit][nb_inst_decod]
     120  public    : SC_IN (Tcontext_t         ) ***  in_DECOD_CONTEXT_ID                    ; //[nb_decod_unit][nb_inst_decod]
     121  public    : SC_IN (Tcontrol_t         ) ***  in_DECOD_MATCH_INST_IFETCH_PTR         ; //[nb_decod_unit][nb_inst_decod]
     122  public    : SC_IN (Tbranch_state_t    ) ***  in_DECOD_BRANCH_STATE                  ; //[nb_decod_unit][nb_inst_decod]
     123  public    : SC_IN (Tprediction_ptr_t  ) ***  in_DECOD_BRANCH_UPDATE_PREDICTION_ID   ; //[nb_decod_unit][nb_inst_decod]
     124  public    : SC_IN (Tbranch_condition_t) ***  in_DECOD_BRANCH_CONDITION              ; //[nb_decod_unit][nb_inst_decod]
     125  public    : SC_IN (Tcontrol_t         ) ***  in_DECOD_BRANCH_DIRECTION              ; //[nb_decod_unit][nb_inst_decod]
     126  public    : SC_IN (Taddress_t         ) ***  in_DECOD_ADDRESS_SRC                   ; //[nb_decod_unit][nb_inst_decod]
     127  public    : SC_IN (Taddress_t         ) ***  in_DECOD_ADDRESS_DEST                  ; //[nb_decod_unit][nb_inst_decod]
     128
     129  public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_BTB_VAL                       ; //[nb_inst_branch_decod]
     130  public    : SC_IN (Tcontrol_t         )  **  in_DECOD_BTB_ACK                       ; //[nb_inst_branch_decod]
     131  public    : SC_OUT(Tcontext_t         )  ** out_DECOD_BTB_CONTEXT_ID                ; //[nb_inst_branch_decod]
     132  public    : SC_OUT(Taddress_t         )  ** out_DECOD_BTB_ADDRESS_SRC               ; //[nb_inst_branch_decod]
     133  public    : SC_OUT(Taddress_t         )  ** out_DECOD_BTB_ADDRESS_DEST              ; //[nb_inst_branch_decod]
     134  public    : SC_OUT(Tbranch_condition_t)  ** out_DECOD_BTB_CONDITION                 ; //[nb_inst_branch_decod]
     135  public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_BTB_LAST_TAKE                 ; //[nb_inst_branch_decod]
     136  public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_BTB_MISS_PREDICTION           ; //[nb_inst_branch_decod]
     137  public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_BTB_IS_ACCURATE               ; //[nb_inst_branch_decod]
    126138                                                                                     
    127   public    : SC_OUT(Tcontrol_t)           ** out_DECOD_RAS_VAL                       ; //[nb_inst_decod]
    128   public    : SC_IN (Tcontrol_t)           **  in_DECOD_RAS_ACK                       ; //[nb_inst_decod]
    129   public    : SC_OUT(Tcontext_t)           ** out_DECOD_RAS_CONTEXT_ID                ; //[nb_inst_decod]
    130   public    : SC_IN (Tcontrol_t)           **  in_DECOD_RAS_HIT                       ; //[nb_inst_decod]
    131   public    : SC_OUT(Tcontrol_t)           ** out_DECOD_RAS_PUSH                      ; //[nb_inst_decod]
    132   public    : SC_OUT(Taddress_t)           ** out_DECOD_RAS_ADDRESS_PUSH              ; //[nb_inst_decod]
    133   public    : SC_IN (Taddress_t)           **  in_DECOD_RAS_ADDRESS_POP               ; //[nb_inst_decod]
    134   public    : SC_IN (Tptr_t    )           **  in_DECOD_RAS_INDEX                     ; //[nb_inst_decod]
    135   public    : SC_OUT(Tcontrol_t)           ** out_DECOD_RAS_MISS_PREDICTION           ; //[nb_inst_decod]
    136                                                                                      
    137   public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_UPT_VAL                       ; //[nb_inst_decod]
    138   public    : SC_IN (Tcontrol_t         )  **  in_DECOD_UPT_ACK                       ; //[nb_inst_decod]
    139   public    : SC_OUT(Tcontext_t         )  ** out_DECOD_UPT_CONTEXT_ID                ; //[nb_inst_decod]
    140   public    : SC_OUT(Taddress_t         )  ** out_DECOD_UPT_BTB_ADDRESS_SRC           ; //[nb_inst_decod]
    141   public    : SC_OUT(Taddress_t         )  ** out_DECOD_UPT_BTB_ADDRESS_DEST          ; //[nb_inst_decod]
    142   public    : SC_OUT(Tbranch_condition_t)  ** out_DECOD_UPT_BTB_CONDITION             ; //[nb_inst_decod]
    143   public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_UPT_BTB_LAST_TAKE             ; //[nb_inst_decod]
    144   public    : SC_OUT(Taddress_t         )  ** out_DECOD_UPT_RAS_ADDRESS               ; //[nb_inst_decod]
    145   public    : SC_OUT(Tptr_t             )  ** out_DECOD_UPT_RAS_INDEX                 ; //[nb_inst_decod]
    146   public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_UPT_MISS_PREDICTION           ; //[nb_inst_decod]
    147   public    : SC_OUT(Tprediction_ptr_t  )  ** out_DECOD_UPT_UPDATE_PREDICTION_ID      ; //[nb_inst_decod]
     139  public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_RAS_VAL                       ; //[nb_inst_branch_decod]
     140  public    : SC_IN (Tcontrol_t         )  **  in_DECOD_RAS_ACK                       ; //[nb_inst_branch_decod]
     141  public    : SC_OUT(Tcontext_t         )  ** out_DECOD_RAS_CONTEXT_ID                ; //[nb_inst_branch_decod]
     142  public    : SC_IN (Tcontrol_t         )  **  in_DECOD_RAS_HIT                       ; //[nb_inst_branch_decod]
     143  public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_RAS_PUSH                      ; //[nb_inst_branch_decod]
     144  public    : SC_OUT(Taddress_t         )  ** out_DECOD_RAS_ADDRESS_PUSH              ; //[nb_inst_branch_decod]
     145  public    : SC_IN (Taddress_t         )  **  in_DECOD_RAS_ADDRESS_POP               ; //[nb_inst_branch_decod]
     146//public    : SC_IN (Tptr_t             )  **  in_DECOD_RAS_INDEX                     ; //[nb_inst_branch_decod] UPT.RAS_INDEX
     147  public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_RAS_MISS_PREDICTION           ; //[nb_inst_branch_decod]
     148                                                                                     
     149  public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_UPT_VAL                       ; //[nb_inst_branch_decod]
     150  public    : SC_IN (Tcontrol_t         )  **  in_DECOD_UPT_ACK                       ; //[nb_inst_branch_decod]
     151  public    : SC_OUT(Tcontext_t         )  ** out_DECOD_UPT_CONTEXT_ID                ; //[nb_inst_branch_decod]
     152  public    : SC_OUT(Taddress_t         )  ** out_DECOD_UPT_BTB_ADDRESS_SRC           ; //[nb_inst_branch_decod]
     153  public    : SC_OUT(Taddress_t         )  ** out_DECOD_UPT_BTB_ADDRESS_DEST          ; //[nb_inst_branch_decod]
     154  public    : SC_OUT(Tbranch_condition_t)  ** out_DECOD_UPT_BTB_CONDITION             ; //[nb_inst_branch_decod]
     155  public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_UPT_BTB_LAST_TAKE             ; //[nb_inst_branch_decod]
     156  public    : SC_OUT(Taddress_t         )  ** out_DECOD_UPT_RAS_ADDRESS               ; //[nb_inst_branch_decod]
     157//public    : SC_OUT(Tptr_t             )  ** out_DECOD_UPT_RAS_INDEX                 ; //[nb_inst_branch_decod] RAS.INDEX
     158  public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_UPT_MISS_IFETCH               ; //[nb_inst_branch_decod]
     159  public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_UPT_MISS_DECOD                ; //[nb_inst_branch_decod]
     160  public    : SC_OUT(Tprediction_ptr_t  )  ** out_DECOD_UPT_UPDATE_PREDICTION_ID      ; //[nb_inst_branch_decod]
    148161                                                                                     
    149162    // ~~~~~[ Interface : "update" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~           
    150   public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_BTB_VAL                      ; //[nb_inst_update]
    151   public    : SC_IN (Tcontrol_t         )  **  in_UPDATE_BTB_ACK                      ; //[nb_inst_update]
    152   public    : SC_OUT(Tcontext_t         )  ** out_UPDATE_BTB_CONTEXT_ID               ; //[nb_inst_update]
    153   public    : SC_OUT(Taddress_t         )  ** out_UPDATE_BTB_ADDRESS_SRC              ; //[nb_inst_update]
    154   public    : SC_OUT(Taddress_t         )  ** out_UPDATE_BTB_ADDRESS_DEST             ; //[nb_inst_update]
    155   public    : SC_OUT(Tbranch_condition_t)  ** out_UPDATE_BTB_CONDITION                ; //[nb_inst_update]
    156   public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_BTB_LAST_TAKE                ; //[nb_inst_update]
    157   public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_BTB_MISS_PREDICTION          ; //[nb_inst_update]
    158                                                                                      
    159   public    : SC_OUT(Tcontrol_t)           ** out_UPDATE_DIR_VAL                      ; //[nb_inst_update]
    160   public    : SC_IN (Tcontrol_t)           **  in_UPDATE_DIR_ACK                      ; //[nb_inst_update]
    161   public    : SC_OUT(Taddress_t)           ** out_UPDATE_DIR_ADDRESS                  ; //[nb_inst_update]
    162   public    : SC_OUT(Thistory_t)           ** out_UPDATE_DIR_HISTORY                  ; //[nb_inst_update]
    163   public    : SC_OUT(Tcontrol_t)           ** out_UPDATE_DIR_DIRECTION                ; //[nb_inst_update]
    164                                                                                      
    165   public    : SC_OUT(Tcontrol_t)           ** out_UPDATE_RAS_VAL                      ; //[nb_inst_update]
    166   public    : SC_IN (Tcontrol_t)           **  in_UPDATE_RAS_ACK                      ; //[nb_inst_update]
    167   public    : SC_OUT(Tcontext_t)           ** out_UPDATE_RAS_CONTEXT_ID               ; //[nb_inst_update]
    168   public    : SC_OUT(Tcontrol_t)           ** out_UPDATE_RAS_PUSH                     ; //[nb_inst_update]
    169   public    : SC_OUT(Taddress_t)           ** out_UPDATE_RAS_ADDRESS                  ; //[nb_inst_update]
    170   public    : SC_OUT(Tptr_t    )           ** out_UPDATE_RAS_INDEX                    ; //[nb_inst_update]
    171   public    : SC_OUT(Tcontrol_t)           ** out_UPDATE_RAS_MISS_PREDICTION          ; //[nb_inst_update]
    172   public    : SC_OUT(Tcontrol_t)           ** out_UPDATE_RAS_PREDICTION_IFETCH        ; //[nb_inst_update]
    173                                                                                      
    174   public    : SC_IN (Tcontrol_t         )  **  in_UPDATE_UPT_VAL                      ; //[nb_inst_update]
    175   public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_UPT_ACK                      ; //[nb_inst_update]
    176   public    : SC_IN (Tcontext_t         )  **  in_UPDATE_UPT_CONTEXT_ID               ; //[nb_inst_update]
    177   public    : SC_IN (Tcontrol_t         )  **  in_UPDATE_UPT_MISS_PREDICTION          ; //[nb_inst_update]
    178   public    : SC_IN (Tcontrol_t         )  **  in_UPDATE_UPT_DIRECTION_GOOD           ; //[nb_inst_update]
    179   public    : SC_IN (Tcontrol_t         )  **  in_UPDATE_UPT_BTB_VAL                  ; //[nb_inst_update]
    180   public    : SC_IN (Taddress_t         )  **  in_UPDATE_UPT_BTB_ADDRESS_SRC          ; //[nb_inst_update]
    181   public    : SC_IN (Taddress_t         )  **  in_UPDATE_UPT_BTB_ADDRESS_DEST         ; //[nb_inst_update]
    182   public    : SC_IN (Tbranch_condition_t)  **  in_UPDATE_UPT_BTB_CONDITION            ; //[nb_inst_update]
    183   public    : SC_IN (Tcontrol_t         )  **  in_UPDATE_UPT_DIR_VAL                  ; //[nb_inst_update]
    184   public    : SC_IN (Thistory_t         )  **  in_UPDATE_UPT_DIR_HISTORY              ; //[nb_inst_update]
    185   public    : SC_IN (Tcontrol_t         )  **  in_UPDATE_UPT_RAS_VAL                  ; //[nb_inst_update]
    186   public    : SC_IN (Taddress_t         )  **  in_UPDATE_UPT_RAS_ADDRESS              ; //[nb_inst_update]
    187   public    : SC_IN (Tptr_t             )  **  in_UPDATE_UPT_RAS_INDEX                ; //[nb_inst_update]
    188   public    : SC_IN (Tcontrol_t         )  **  in_UPDATE_UPT_RAS_PREDICTION_IFETCH    ; //[nb_inst_update]
     163  public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_BTB_VAL                      ; //[nb_inst_branch_update]
     164  public    : SC_IN (Tcontrol_t         )  **  in_UPDATE_BTB_ACK                      ; //[nb_inst_branch_update]
     165//public    : SC_OUT(Tcontext_t         )  ** out_UPDATE_BTB_CONTEXT_ID               ; //[nb_inst_branch_update] UPT.CONTEXT_ID
     166//public    : SC_OUT(Taddress_t         )  ** out_UPDATE_BTB_ADDRESS_SRC              ; //[nb_inst_branch_update] UPT.BTB_ADDRESS_SRC
     167//public    : SC_OUT(Taddress_t         )  ** out_UPDATE_BTB_ADDRESS_DEST             ; //[nb_inst_branch_update] UPT.BTB_ADDRESS_DEST
     168//public    : SC_OUT(Tbranch_condition_t)  ** out_UPDATE_BTB_CONDITION                ; //[nb_inst_branch_update]*UPT.BTB_CONDITION
     169//public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_BTB_LAST_TAKE                ; //[nb_inst_branch_update] UPT.DIRECTION_GOOD
     170//public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_BTB_MISS_PREDICTION          ; //[nb_inst_branch_update] UPT.MISS_PREDICTION
     171                                                                                     
     172  public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_DIR_VAL                      ; //[nb_inst_branch_update]
     173  public    : SC_IN (Tcontrol_t         )  **  in_UPDATE_DIR_ACK                      ; //[nb_inst_branch_update]
     174//public    : SC_OUT(Taddress_t         )  ** out_UPDATE_DIR_ADDRESS                  ; //[nb_inst_branch_update] UPT.BTB_ADDRESS_SRC
     175//public    : SC_OUT(Thistory_t         )  ** out_UPDATE_DIR_HISTORY                  ; //[nb_inst_branch_update] UPT.DIR_HISTORY
     176//public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_DIR_DIRECTION                ; //[nb_inst_branch_update] UPT.DIRECTION_GOOD
     177                                                                                     
     178  public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_RAS_VAL                      ; //[nb_inst_branch_update]
     179  public    : SC_IN (Tcontrol_t         )  **  in_UPDATE_RAS_ACK                      ; //[nb_inst_branch_update]
     180//public    : SC_OUT(Tcontext_t         )  ** out_UPDATE_RAS_CONTEXT_ID               ; //[nb_inst_branch_update] UPT.CONTEXT_ID
     181//public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_RAS_PUSH                     ; //[nb_inst_branch_update] UPT.RAS_PUSH
     182//public    : SC_OUT(Taddress_t         )  ** out_UPDATE_RAS_ADDRESS                  ; //[nb_inst_branch_update] UPT.RAS_ADDRESS
     183//public    : SC_OUT(Tptr_t             )  ** out_UPDATE_RAS_INDEX                    ; //[nb_inst_branch_update] UPT.RAS_INDEX
     184//public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_RAS_MISS_PREDICTION          ; //[nb_inst_branch_update] UPT.MISS_PREDICTION
     185//public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_RAS_PREDICTION_IFETCH        ; //[nb_inst_branch_update] UPT.RAS_PREDICTION_IFETCH
     186                                                                                     
     187  public    : SC_IN (Tcontrol_t         )  **  in_UPDATE_UPT_VAL                      ; //[nb_inst_branch_update]
     188  public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_UPT_ACK                      ; //[nb_inst_branch_update]
     189//public    : SC_IN (Tcontext_t         )  **  in_UPDATE_UPT_CONTEXT_ID               ; //[nb_inst_branch_update] BTB.CONTEXT_ID, RAS.CONTEXT_ID
     190//public    : SC_IN (Tcontrol_t         )  **  in_UPDATE_UPT_MISS_PREDICTION          ; //[nb_inst_branch_update] BTB.MISS_PREDICTION, RAS.MISS_PREDICTION
     191//public    : SC_IN (Tcontrol_t         )  **  in_UPDATE_UPT_DIRECTION_GOOD           ; //[nb_inst_branch_update] BTB.LAST_TAKE, DIR.DIRECTION
     192  public    : SC_IN (Tcontrol_t         )  **  in_UPDATE_UPT_BTB_VAL                  ; //[nb_inst_branch_update]
     193//public    : SC_IN (Taddress_t         )  **  in_UPDATE_UPT_BTB_ADDRESS_SRC          ; //[nb_inst_branch_update] DIR.ADDRESS, BTB.ADDRESS_SRC
     194//public    : SC_IN (Taddress_t         )  **  in_UPDATE_UPT_BTB_ADDRESS_DEST         ; //[nb_inst_branch_update] BTB.ADDRESS_DEST
     195//public    : SC_IN (Tbranch_condition_t)  **  in_UPDATE_UPT_BTB_CONDITION            ; //[nb_inst_branch_update]*BTB.CONDITION
     196  public    : SC_IN (Tcontrol_t         )  **  in_UPDATE_UPT_DIR_VAL                  ; //[nb_inst_branch_update]
     197//public    : SC_IN (Thistory_t         )  **  in_UPDATE_UPT_DIR_HISTORY              ; //[nb_inst_branch_update] DIR.HISTORY
     198  public    : SC_IN (Tcontrol_t         )  **  in_UPDATE_UPT_RAS_VAL                  ; //[nb_inst_branch_update]
     199//public    : SC_IN (Taddress_t         )  **  in_UPDATE_UPT_RAS_ADDRESS              ; //[nb_inst_branch_update] RAS.ADDRESS
     200//public    : SC_IN (Tcontrol_t         )  **  in_UPDATE_UPT_RAS_PUSH                 ; //[nb_inst_branch_update] RAS.PUSH
     201//public    : SC_IN (Tptr_t             )  **  in_UPDATE_UPT_RAS_INDEX                ; //[nb_inst_branch_update] RAS.INDEX
     202//public    : SC_IN (Tcontrol_t         )  **  in_UPDATE_UPT_RAS_PREDICTION_IFETCH    ; //[nb_inst_branch_update] RAS.PREDICTION_IFETCH
    189203                                                                                     
    190204    // ~~~~~[ Interface : "depth" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~           
    191205  public    : SC_IN (Tdepth_t           )  **  in_DEPTH_UPT_NB_BRANCH                 ; //[nb_context]
    192206  public    : SC_IN (Tdepth_t           )  **  in_DEPTH_UPT_TAIL                      ; //[nb_context]
     207  public    : SC_OUT(Tdepth_t           )  ** out_DEPTH_NB_BRANCH                     ; //[nb_context]
     208  public    : SC_OUT(Tdepth_t           )  ** out_DEPTH_TAIL                          ; //[nb_context]
    193209
    194210    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    … …  
    196212    // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    197213  private   : uint32_t                         reg_PREDICT_PRIORITY;
     214  private   : uint32_t                         reg_DECOD_PRIORITY;
    198215
    199216    // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    … …  
    233250//public  : void        genMoore                  (void);
    234251  public  : void        genMealy_predict          (void);
    235 //   public  : void        genMealy_decod            (void);
    236 //   public  : void        genMealy_update           (void);
     252  public  : void        genMealy_decod            (void);
     253  public  : void        genMealy_update           (void);
    237254#endif                                         
    238255

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

    r81 r82  
    77
    88#include "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue/include/Parameters.h"
     9#include "Common/include/Max.h"
    910
    1011namespace morpheo {
    … …  
    1920#undef  FUNCTION
    2021#define FUNCTION "Prediction_unit_Glue::Parameters"
    21   Parameters::Parameters (uint32_t   nb_context     ,
    22                           uint32_t   size_address   ,
    23                           uint32_t * nb_instruction ,
    24                           uint32_t * size_depth     ,
    25                           uint32_t   nb_inst_predict,
    26                           uint32_t   nb_inst_decod  ,
    27                           uint32_t   nb_inst_update )
     22  Parameters::Parameters (uint32_t   nb_context            ,
     23                          uint32_t   nb_decod_unit         ,
     24//                        uint32_t   nb_ooo_engine         ,
     25                          uint32_t   size_address          ,
     26                          uint32_t * nb_instruction        ,
     27                          uint32_t * size_depth            ,
     28                          uint32_t * nb_inst_decod         ,
     29//                        uint32_t * nb_inst_update        ,
     30                          uint32_t   nb_inst_branch_predict,
     31                          uint32_t   nb_inst_branch_decod  ,
     32                          uint32_t   nb_inst_branch_update )
    2833  {
    2934    log_printf(FUNC,Prediction_unit_Glue,FUNCTION,"Begin");
    3035
    31     _nb_context                = nb_context             ;
    32     _size_address              = size_address           ;
    33     _nb_instruction            = nb_instruction         ;
    34     _size_depth                = size_depth             ;
    35     _nb_inst_predict           = nb_inst_predict        ;
    36     _nb_inst_decod             = nb_inst_decod          ;
    37     _nb_inst_update            = nb_inst_update         ;
    38 
     36    _nb_context                = nb_context     ;
     37    _size_address              = size_address   ;
     38    _nb_instruction            = nb_instruction ;
     39    _size_depth                = size_depth     ;
     40    _nb_decod_unit             = nb_decod_unit  ;
     41    _nb_inst_decod             = nb_inst_decod  ;
     42//     _nb_ooo_engine             = nb_ooo_engine  ;
     43//     _nb_inst_update            = nb_inst_update ;
     44    _nb_inst_branch_predict    = nb_inst_branch_predict;
     45    _nb_inst_branch_decod      = nb_inst_branch_decod  ;
     46    _nb_inst_branch_update     = nb_inst_branch_update ;
     47     
    3948    _size_context_id           = log2(_nb_context);
    4049    _size_inst_ifetch_ptr      = new uint32_t [_nb_context];
     50    _max_size_depth            = max<uint32_t>(_size_depth,_nb_context);
    4151
    4252    _have_port_context_id      = (_size_context_id>0);
     53    _have_port_max_depth       = (_max_size_depth>0);
    4354    _have_port_depth           = new bool [_nb_context];
    4455    _have_port_inst_ifetch_ptr = new bool [_nb_context];

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

    r81 r82  
    2727    Parameters_test test ("Prediction_unit_Glue");
    2828
    29     if (_nb_inst_predict > _nb_context)
     29    if (_nb_inst_branch_predict > _nb_context)
    3030      test.error("nb_inst_predict must be <= nb_context\n");
    3131

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

    r81 r82  
    2727
    2828    xml.balise_open("prediction_unit_glue");
    29     xml.singleton_begin("nb_context     "); xml.attribut("value",toString(_nb_context     )); xml.singleton_end();
    30     xml.singleton_begin("size_address   "); xml.attribut("value",toString(_size_address   )); xml.singleton_end();
    31     xml.singleton_begin("nb_inst_predict"); xml.attribut("value",toString(_nb_inst_predict)); xml.singleton_end();
    32     xml.singleton_begin("nb_inst_decod  "); xml.attribut("value",toString(_nb_inst_decod  )); xml.singleton_end();
    33     xml.singleton_begin("nb_inst_update "); xml.attribut("value",toString(_nb_inst_update )); xml.singleton_end();
     29    xml.singleton_begin("nb_context            "); xml.attribut("value",toString(_nb_context            )); xml.singleton_end();
     30    xml.singleton_begin("nb_decod_unit         "); xml.attribut("value",toString(_nb_decod_unit         )); xml.singleton_end();
     31//     xml.singleton_begin("nb_ooo_engine         "); xml.attribut("value",toString(_nb_ooo_engine         )); xml.singleton_end();
     32    xml.singleton_begin("size_address          "); xml.attribut("value",toString(_size_address          )); xml.singleton_end();
     33    xml.singleton_begin("nb_inst_branch_predict"); xml.attribut("value",toString(_nb_inst_branch_predict)); xml.singleton_end();
     34    xml.singleton_begin("nb_inst_branch_decod  "); xml.attribut("value",toString(_nb_inst_branch_decod  )); xml.singleton_end();
     35    xml.singleton_begin("nb_inst_branch_update "); xml.attribut("value",toString(_nb_inst_branch_update )); xml.singleton_end();
     36
     37//     xml.singleton_begin("nb_inst_decod  "); xml.attribut("value",toString(_nb_inst_decod  )); xml.singleton_end();
     38//     xml.singleton_begin("nb_inst_update "); xml.attribut("value",toString(_nb_inst_update )); xml.singleton_end();
    3439    for (uint32_t i=0;i<_nb_context; i++)
    3540      {
    … …  
    3843        xml.  attribut("id"  ,toString(i));
    3944        xml. balise_open_end();
    40         xml.  singleton_begin("nb_instruction "); xml.attribut("value",toString(_nb_instruction [i])); xml.singleton_end();
    41         xml.  singleton_begin("size_depth     "); xml.attribut("value",toString(_size_depth     [i])); xml.singleton_end();
     45        xml.  singleton_begin("nb_instruction        "); xml.attribut("value",toString(_nb_instruction        [i])); xml.singleton_end();
     46        xml.  singleton_begin("size_depth            "); xml.attribut("value",toString(_size_depth            [i])); xml.singleton_end();
    4247        xml. balise_close();
    4348      }
     49    for (uint32_t i=0;i<_nb_decod_unit; i++)
     50      {
     51        xml. balise_open_begin("component");
     52        xml.  attribut("type","decod_unit");
     53        xml.  attribut("id"  ,toString(i));
     54        xml. balise_open_end();
     55        xml.  singleton_begin("nb_inst_decod         "); xml.attribut("value",toString(_nb_inst_decod         [i])); xml.singleton_end();
     56        xml. balise_close();
     57      }
     58//     for (uint32_t i=0;i<_nb_ooo_engine; i++)
     59//       {
     60//         xml. balise_open_begin("component");
     61//         xml.  attribut("type","ooo_engine");
     62//         xml.  attribut("id"  ,toString(i));
     63//         xml. balise_open_end();
     64//      xml.  singleton_begin("nb_inst_update        "); xml.attribut("value",toString(_nb_inst_update        [i])); xml.singleton_end();
     65//         xml. balise_close();
     66//       }
     67
    4468    xml.balise_close();
    4569

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

    r81 r82  
    9292                      << (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
    9393          }
    94         for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     94        for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    9595          {
    9696            sensitive << (*( in_PREDICT_BTB_ACK              [i]))
    … …  
    110110                      << (*( in_PREDICT_UPT_ACK              [i]));
    111111          }
     112        for (uint32_t i=0; i<_param->_nb_context; i++)
     113          {
     114            sensitive << (*(in_DEPTH_UPT_NB_BRANCH [i]));
     115            if (_param->_have_port_depth[i])
     116              sensitive << (*(in_DEPTH_UPT_TAIL      [i]));
     117          }
    112118
    113119# ifdef SYSTEMCASS_SPECIFIC
    … …  
    115121        for (uint32_t x=0; x<_param->_nb_context; x++)
    116122          {
     123            if (_param->_have_port_depth[x])
     124              {
     125                (*(out_DEPTH_TAIL                          [x])) (*( in_DEPTH_UPT_TAIL                      [x]));
     126              }
     127                (*(out_DEPTH_NB_BRANCH                     [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [x]));
     128
    117129            for (uint32_t i=0; i<_param->_nb_context; i++)
    118130              {
    … …  
    121133                (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
    122134                (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
    123               }
    124             for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     135                if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
     136                  {
     137                (*(out_PREDICT_ACK                         [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
     138                  }
     139                (*(out_PREDICT_ACK                         [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
     140              }
     141            for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    125142              {
    126143                (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_BTB_ACK              [i]));
    … …  
    147164                (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
    148165                (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
    149               }
    150             for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     166                if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
     167                  {
     168                (*(out_PREDICT_PC_NEXT                     [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
     169                  }
     170                (*(out_PREDICT_PC_NEXT                     [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
     171              }
     172            for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    151173              {
    152174                (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_BTB_ACK              [i]));
    … …  
    173195                (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
    174196                (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
    175               }
    176             for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     197                if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
     198                  {
     199                (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
     200                  }
     201                (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
     202              }
     203            for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    177204              {
    178205                (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_BTB_ACK              [i]));
    … …  
    201228                (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
    202229                (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
    203               }
    204             for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     230                if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
     231                  {
     232                (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
     233                  }
     234                (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
     235              }
     236            for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    205237              {
    206238                (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_BTB_ACK              [i]));
    … …  
    228260                (*(out_PREDICT_BRANCH_STATE                [x]))(*( in_PREDICT_PC_CURRENT                  [i]));
    229261                (*(out_PREDICT_BRANCH_STATE                [x]))(*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
    230               }
    231             for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     262                if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
     263                  {
     264                (*(out_PREDICT_BRANCH_STATE                [x]))(*( in_DEPTH_UPT_TAIL                      [i]));
     265                  }
     266                (*(out_PREDICT_BRANCH_STATE                [x]))(*( in_DEPTH_UPT_NB_BRANCH                 [i]));
     267              }
     268            for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    232269              {
    233270                (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_BTB_ACK              [i]));
    … …  
    256293                (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
    257294                (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
    258               }
    259             for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     295                if (_param->_have_port_depth [i])
     296                  {
     297                (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
     298                  }
     299                (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
     300              }
     301            for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    260302              {
    261303                (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_BTB_ACK              [i]));
    … …  
    285327                    (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_PC_CURRENT                  [i]));
    286328                    (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
    287                   }
    288                 for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     329                    if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
     330                      {
     331                    (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_DEPTH_UPT_TAIL                      [i]));
     332                      }
     333                    (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
     334                  }
     335                for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    289336                  {
    290337                    (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_BTB_ACK              [i]));
    … …  
    307354          }
    308355
    309         for (uint32_t x=0; x<_param->_nb_inst_predict; x++)
     356        for (uint32_t x=0; x<_param->_nb_inst_branch_predict; x++)
    310357          {
    311358            for (uint32_t i=0; i<_param->_nb_context; i++)
    … …  
    315362                (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
    316363                (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
    317               }
    318             for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     364                if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
     365                  {
     366                (*(out_PREDICT_BTB_VAL              [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
     367                  }
     368                (*(out_PREDICT_BTB_VAL              [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
     369              }
     370            for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    319371              {
    320372                (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_BTB_ACK              [i]));
    … …  
    343395                (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
    344396                (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
    345               }
    346             for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     397                if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
     398                  {
     399                (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
     400                  }
     401                (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
     402              }
     403            for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    347404              {
    348405                (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_ACK              [i]));
    … …  
    370427                (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
    371428                (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
    372               }
    373             for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     429                if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
     430                  {
     431                (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
     432                  }
     433                (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
     434              }
     435            for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    374436              {
    375437                (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_BTB_ACK              [i]));
    … …  
    396458                (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
    397459                (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
    398               }
    399             for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     460                if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
     461                  {
     462                (*(out_PREDICT_DIR_VAL              [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
     463                  }
     464                (*(out_PREDICT_DIR_VAL              [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
     465              }
     466            for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    400467              {
    401468                (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_BTB_ACK              [i]));
    … …  
    422489                (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
    423490                (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
    424               }
    425             for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     491                if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
     492                  {
     493                (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
     494                  }
     495                (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
     496              }
     497            for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    426498              {
    427499                (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_BTB_ACK              [i]));
    … …  
    448520                (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
    449521                (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
    450               }
    451             for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     522                if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
     523                  {
     524                (*(out_PREDICT_DIR_STATIC           [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
     525                  }
     526                (*(out_PREDICT_DIR_STATIC           [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
     527              }
     528            for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    452529              {
    453530                (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_BTB_ACK              [i]));
    … …  
    474551//              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
    475552//              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
     553//              if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
     554//                {
     555//              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
     556//                }
     557//              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
    476558//            }
    477 //          for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     559//          for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    478560//            {
    479561//              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_BTB_ACK              [i]));
    … …  
    500582                (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
    501583                (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
    502               }
    503             for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     584                if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
     585                  {
     586                (*(out_PREDICT_RAS_VAL              [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
     587                  }
     588                (*(out_PREDICT_RAS_VAL              [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
     589              }
     590            for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    504591              {
    505592                (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_BTB_ACK              [i]));
    … …  
    528615                (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
    529616                (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
    530               }
    531             for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     617                if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
     618                  {
     619                (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
     620                  }
     621                (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
     622              }
     623            for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    532624              {
    533625                (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_ACK              [i]));
    … …  
    555647                (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
    556648                (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
    557               }
    558             for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     649                if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
     650                  {
     651                (*(out_PREDICT_RAS_PUSH             [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
     652                  }
     653                (*(out_PREDICT_RAS_PUSH             [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
     654              }
     655            for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    559656              {
    560657                (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_BTB_ACK              [i]));
    … …  
    581678                (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
    582679                (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
    583               }
    584             for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     680                if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
     681                  {
     682                (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
     683                  }
     684                (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
     685              }
     686            for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    585687              {
    586688                (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_BTB_ACK              [i]));
    … …  
    607709                (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
    608710                (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
    609               }
    610             for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     711                if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
     712                  {
     713                (*(out_PREDICT_UPT_VAL              [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
     714                  }
     715                (*(out_PREDICT_UPT_VAL              [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
     716              }
     717            for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    611718              {
    612719                (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_BTB_ACK              [i]));
    … …  
    635742                (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
    636743                (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
    637               }
    638             for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     744                if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
     745                  {
     746                (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
     747                  }
     748                (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
     749              }
     750            for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    639751              {
    640752                (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_ACK              [i]));
    … …  
    662774                (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
    663775                (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
    664               }
    665             for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     776                if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
     777                  {
     778                (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
     779                  }
     780                (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
     781              }
     782            for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    666783              {
    667784                (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_BTB_ACK              [i]));
    … …  
    688805                (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
    689806                (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
    690               }
    691             for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     807                if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
     808                  {
     809                (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
     810                  }
     811                (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
     812              }
     813            for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    692814              {
    693815                (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_BTB_ACK              [i]));
    … …  
    714836                (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
    715837                (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
    716               }
    717             for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     838                if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
     839                  {
     840                (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
     841                  }
     842                (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
     843              }
     844            for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    718845              {
    719846                (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_BTB_ACK              [i]));
    … …  
    740867                (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
    741868                (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
    742               }
    743             for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     869                if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
     870                  {
     871                (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
     872                  }
     873                (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
     874              }
     875            for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    744876              {
    745877                (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_BTB_ACK              [i]));
    … …  
    766898                (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
    767899                (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
    768               }
    769             for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     900                if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
     901                  {
     902                (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
     903                  }
     904                (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
     905              }
     906            for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    770907              {
    771908                (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_BTB_ACK              [i]));
    … …  
    792929//              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
    793930//              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
     931//              if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
     932//                {
     933//              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
     934//                }
     935//              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
    794936//            }
    795 //          for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     937//          for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    796938//            {
    797939//              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_BTB_ACK              [i]));
    … …  
    818960                (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
    819961                (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
    820               }
    821             for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     962                if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
     963                  {
     964                (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
     965                  }
     966                (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
     967              }
     968            for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    822969              {
    823970                (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_BTB_ACK              [i]));
    … …  
    844991//              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
    845992//              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
     993//              if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
     994//                {
     995//              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
     996//                }
     997//              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
    846998//            }
    847 //          for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     999//          for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    8481000//            {
    8491001//              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_BTB_ACK              [i]));
    … …  
    8651017          }
    8661018# endif   
     1019
     1020        log_printf(INFO,Prediction_unit_Glue,FUNCTION,"Method - genMealy_decod");
     1021
     1022        SC_METHOD (genMealy_decod);
     1023        dont_initialize ();
     1024        sensitive << (*(in_CLOCK)).neg(); // use internal register
     1025        for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
     1026          for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
     1027            {
     1028              sensitive << (*(in_DECOD_VAL                         [i][j]))
     1029                        << (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]))
     1030                        << (*(in_DECOD_BRANCH_STATE                [i][j]))
     1031                        << (*(in_DECOD_BRANCH_CONDITION            [i][j]))
     1032                        << (*(in_DECOD_BRANCH_DIRECTION            [i][j]))
     1033                        << (*(in_DECOD_ADDRESS_SRC                 [i][j]))
     1034                        << (*(in_DECOD_ADDRESS_DEST                [i][j]));
     1035
     1036              if (_param->_have_port_context_id)
     1037                sensitive << (*(in_DECOD_CONTEXT_ID                  [i][j]));
     1038              if (_param->_have_port_max_depth)
     1039                sensitive << (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
     1040            }
     1041        for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
     1042          {
     1043            sensitive << (*(in_DECOD_BTB_ACK                     [i]   ))
     1044                      << (*(in_DECOD_RAS_ACK                     [i]   ))
     1045                      << (*(in_DECOD_RAS_HIT                     [i]   )) 
     1046                      << (*(in_DECOD_RAS_ADDRESS_POP             [i]   ))
     1047//                    << (*(in_DECOD_RAS_INDEX                   [i]   ))
     1048                      << (*(in_DECOD_UPT_ACK                     [i]   )) ;
     1049          }
     1050
     1051# ifdef SYSTEMCASS_SPECIFIC
     1052        // List dependency information
    8671053       
     1054        for (uint32_t x=0; x<_param->_nb_decod_unit; x++)
     1055          for (uint32_t y=0; y<_param->_nb_inst_decod[x]; y++)
     1056            {
     1057              for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
     1058                for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
     1059                  {
     1060                    (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_VAL                         [i][j]));
     1061                    if (_param->_have_port_context_id)
     1062                    (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
     1063                    (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
     1064                    (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_BRANCH_STATE                [i][j]));
     1065                    if (_param->_have_port_max_depth)
     1066                    (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
     1067                    (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
     1068                    (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
     1069                    (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
     1070                    (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
     1071                  }
     1072              for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
     1073                {
     1074                    (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_BTB_ACK                     [i]   ));
     1075                    (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_RAS_ACK                     [i]   ));
     1076                    (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_RAS_HIT                     [i]   ));
     1077                    (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
     1078//                  (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_RAS_INDEX                   [i]   ));
     1079                    (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_UPT_ACK                     [i]   ));
     1080                }
     1081            }
     1082
     1083        for (uint32_t x=0; x<_param->_nb_inst_branch_decod; x++)
     1084          {
     1085              for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
     1086                for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
     1087                  {
     1088                    (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_VAL                         [i][j]));
     1089                    if (_param->_have_port_context_id)
     1090                    (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
     1091                    (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
     1092                    (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
     1093                    if (_param->_have_port_max_depth)
     1094                    (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
     1095                    (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
     1096                    (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
     1097                    (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
     1098                    (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
     1099                  }
     1100              for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
     1101                {
     1102                    (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
     1103                    (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
     1104                    (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
     1105                    (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
     1106//                  (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
     1107                    (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
     1108                  }
     1109
     1110              if (_param->_have_port_context_id)
     1111                {
     1112              for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
     1113                for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
     1114                  {
     1115                    (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_VAL                         [i][j]));
     1116                    (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
     1117                    (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
     1118                    (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
     1119                    if (_param->_have_port_max_depth)
     1120                    (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
     1121                    (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
     1122                    (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
     1123                    (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
     1124                    (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
     1125                  }
     1126              for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
     1127                {
     1128                    (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
     1129                    (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
     1130                    (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
     1131                    (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
     1132//                  (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
     1133                    (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
     1134                }
     1135                }
     1136
     1137              for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
     1138                for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
     1139                  {
     1140                    (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_VAL                         [i][j]));
     1141                    if (_param->_have_port_context_id)
     1142                    (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
     1143                    (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
     1144                    (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
     1145                    if (_param->_have_port_max_depth)
     1146                    (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
     1147                    (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
     1148                    (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
     1149                    (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
     1150                    (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
     1151                  }
     1152              for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
     1153                {
     1154                    (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
     1155                    (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
     1156                    (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
     1157                    (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
     1158//                  (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
     1159                    (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
     1160                  }
     1161
     1162              for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
     1163                for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
     1164                  {
     1165                    (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_VAL                         [i][j]));
     1166                    if (_param->_have_port_context_id)
     1167                    (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
     1168                    (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
     1169                    (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
     1170                    if (_param->_have_port_max_depth)
     1171                    (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
     1172                    (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
     1173                    (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
     1174                    (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
     1175                    (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
     1176                  }
     1177              for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
     1178                {
     1179                    (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
     1180                    (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
     1181                    (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
     1182                    (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
     1183//                  (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
     1184                    (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
     1185                  }
     1186
     1187              for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
     1188                for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
     1189                  {
     1190                    (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_VAL                         [i][j]));
     1191                    if (_param->_have_port_context_id)
     1192                    (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
     1193                    (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
     1194                    (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
     1195                    if (_param->_have_port_max_depth)
     1196                    (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
     1197                    (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
     1198                    (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
     1199                    (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
     1200                    (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
     1201                  }
     1202              for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
     1203                {
     1204                    (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
     1205                    (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
     1206                    (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
     1207                    (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
     1208//                  (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
     1209                    (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
     1210                  }
     1211
     1212              for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
     1213                for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
     1214                  {
     1215                    (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_VAL                         [i][j]));
     1216                    if (_param->_have_port_context_id)
     1217                    (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
     1218                    (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
     1219                    (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
     1220                    if (_param->_have_port_max_depth)
     1221                    (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
     1222                    (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
     1223                    (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
     1224                    (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
     1225                    (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
     1226                  }
     1227              for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
     1228                {
     1229                    (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
     1230                    (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
     1231                    (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
     1232                    (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
     1233//                  (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
     1234                    (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
     1235                  }
     1236
     1237              for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
     1238                for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
     1239                  {
     1240                    (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_VAL                         [i][j]));
     1241                    if (_param->_have_port_context_id)
     1242                    (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
     1243                    (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
     1244                    (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
     1245                    if (_param->_have_port_max_depth)
     1246                    (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
     1247                    (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
     1248                    (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
     1249                    (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
     1250                    (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
     1251                  }
     1252              for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
     1253                {
     1254                    (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
     1255                    (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
     1256                    (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
     1257                    (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
     1258//                  (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
     1259                    (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
     1260                  }
     1261
     1262              for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
     1263                for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
     1264                  {
     1265                    (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_VAL                         [i][j]));
     1266                    if (_param->_have_port_context_id)
     1267                    (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
     1268                    (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
     1269                    (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
     1270                    if (_param->_have_port_max_depth)
     1271                    (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
     1272                    (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
     1273                    (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
     1274                    (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
     1275                    (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
     1276                  }
     1277              for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
     1278                {
     1279                    (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
     1280                    (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
     1281                    (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
     1282                    (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
     1283//                  (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
     1284                    (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
     1285                  }
     1286
     1287              for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
     1288                for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
     1289                  {
     1290                    (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_VAL                         [i][j]));
     1291                    if (_param->_have_port_context_id)
     1292                    (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
     1293                    (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
     1294                    (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
     1295                    if (_param->_have_port_max_depth)
     1296                    (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
     1297                    (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
     1298                    (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
     1299                    (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
     1300                    (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
     1301                  }
     1302              for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
     1303                {
     1304                    (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
     1305                    (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
     1306                    (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
     1307                    (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
     1308//                  (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
     1309                    (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
     1310                  }
     1311
     1312              if (_param->_have_port_context_id)
     1313                {   
     1314              for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
     1315                for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
     1316                  {
     1317                    (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_VAL                         [i][j]));
     1318                    (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
     1319                    (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
     1320                    (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
     1321                    if (_param->_have_port_max_depth)
     1322                    (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
     1323                    (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
     1324                    (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
     1325                    (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
     1326                    (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
     1327                  }
     1328              for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
     1329                {
     1330                    (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
     1331                    (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
     1332                    (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
     1333                    (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
     1334//                  (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
     1335                    (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
     1336                  }
     1337                }
     1338
     1339              for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
     1340                for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
     1341                  {
     1342                    (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_VAL                         [i][j]));
     1343                    if (_param->_have_port_context_id)
     1344                    (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
     1345                    (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
     1346                    (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
     1347                    if (_param->_have_port_max_depth)
     1348                    (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
     1349                    (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
     1350                    (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
     1351                    (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
     1352                    (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
     1353                  }
     1354              for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
     1355                {
     1356                    (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
     1357                    (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
     1358                    (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
     1359                    (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
     1360//                  (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
     1361                    (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
     1362                  }
     1363
     1364              for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
     1365                for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
     1366                  {
     1367                    (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_VAL                         [i][j]));
     1368                    if (_param->_have_port_context_id)
     1369                    (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
     1370                    (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
     1371                    (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
     1372                    if (_param->_have_port_max_depth)
     1373                    (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
     1374                    (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
     1375                    (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
     1376                    (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
     1377                    (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
     1378                  }
     1379              for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
     1380                {
     1381                    (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
     1382                    (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
     1383                    (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
     1384                    (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
     1385//                  (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
     1386                    (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
     1387                  }
     1388
     1389              for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
     1390                for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
     1391                  {
     1392                    (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_VAL                         [i][j]));
     1393                    if (_param->_have_port_context_id)
     1394                    (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
     1395                    (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
     1396                    (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
     1397                    if (_param->_have_port_max_depth)
     1398                    (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
     1399                    (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
     1400                    (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
     1401                    (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
     1402                    (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
     1403                  }
     1404              for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
     1405                {
     1406                    (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
     1407                    (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
     1408                    (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
     1409                    (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
     1410//                  (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
     1411                    (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
     1412                  }
     1413
     1414              for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
     1415                for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
     1416                  {
     1417                    (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_VAL                         [i][j]));
     1418                    if (_param->_have_port_context_id)
     1419                    (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
     1420                    (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
     1421                    (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
     1422                    if (_param->_have_port_max_depth)
     1423                    (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
     1424                    (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
     1425                    (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
     1426                    (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
     1427                    (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
     1428                  }
     1429              for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
     1430                {
     1431                    (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
     1432                    (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
     1433                    (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
     1434                    (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
     1435//                  (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
     1436                    (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
     1437                  }
     1438
     1439              if (_param->_have_port_context_id)
     1440                {
     1441              for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
     1442                for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
     1443                  {
     1444                    (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_VAL                         [i][j]));
     1445                    (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
     1446                    (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
     1447                    (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
     1448                    if (_param->_have_port_max_depth)
     1449                    (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
     1450                    (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
     1451                    (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
     1452                    (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
     1453                    (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
     1454                  }
     1455              for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
     1456                {
     1457                    (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
     1458                    (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
     1459                    (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
     1460                    (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
     1461//                  (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
     1462                    (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
     1463                  }
     1464                }
     1465
     1466              for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
     1467                for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
     1468                  {
     1469                    (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_VAL                         [i][j]));
     1470                    if (_param->_have_port_context_id)
     1471                    (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
     1472                    (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
     1473                    (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
     1474                    if (_param->_have_port_max_depth)
     1475                    (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
     1476                    (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
     1477                    (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
     1478                    (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
     1479                    (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
     1480                  }
     1481              for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
     1482                {
     1483                    (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
     1484                    (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
     1485                    (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
     1486                    (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
     1487//                  (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
     1488                    (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
     1489                  }
     1490
     1491              for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
     1492                for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
     1493                  {
     1494                    (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_VAL                         [i][j]));
     1495                    if (_param->_have_port_context_id)
     1496                    (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
     1497                    (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
     1498                    (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
     1499                    if (_param->_have_port_max_depth)
     1500                    (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
     1501                    (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
     1502                    (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
     1503                    (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
     1504                    (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
     1505                  }
     1506              for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
     1507                {
     1508                    (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
     1509                    (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
     1510                    (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
     1511                    (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
     1512//                  (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
     1513                    (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
     1514                  }
     1515
     1516              for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
     1517                for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
     1518                  {
     1519                    (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_VAL                         [i][j]));
     1520                    if (_param->_have_port_context_id)
     1521                    (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
     1522                    (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
     1523                    (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
     1524                    if (_param->_have_port_max_depth)
     1525                    (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
     1526                    (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
     1527                    (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
     1528                    (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
     1529                    (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
     1530                  }
     1531              for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
     1532                {
     1533                    (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
     1534                    (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
     1535                    (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
     1536                    (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
     1537//                  (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
     1538                    (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
     1539                  }
     1540
     1541              for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
     1542                for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
     1543                  {
     1544                    (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_VAL                         [i][j]));
     1545                    if (_param->_have_port_context_id)
     1546                    (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
     1547                    (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
     1548                    (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
     1549                    if (_param->_have_port_max_depth)
     1550                    (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
     1551                    (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
     1552                    (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
     1553                    (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
     1554                    (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
     1555                  }
     1556              for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
     1557                {
     1558                    (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
     1559                    (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
     1560                    (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
     1561                    (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
     1562//                  (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
     1563                    (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
     1564                  }
     1565
     1566              for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
     1567                for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
     1568                  {
     1569                    (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_VAL                         [i][j]));
     1570                    if (_param->_have_port_context_id)
     1571                    (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
     1572                    (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
     1573                    (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
     1574                    if (_param->_have_port_max_depth)
     1575                    (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
     1576                    (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
     1577                    (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
     1578                    (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
     1579                    (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
     1580                  }
     1581              for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
     1582                {
     1583                    (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
     1584                    (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
     1585                    (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
     1586                    (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
     1587//                  (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
     1588                    (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
     1589                  }
     1590
     1591//            for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
     1592//              for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
     1593//                {
     1594//                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_VAL                         [i][j]));
     1595//                  if (_param->_have_port_context_id)
     1596//                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
     1597//                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
     1598//                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
     1599//                  if (_param->_have_port_max_depth)
     1600//                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
     1601//                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
     1602//                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
     1603//                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
     1604//                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
     1605//                }
     1606//            for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
     1607//              {
     1608//                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
     1609//                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
     1610//                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
     1611//                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
     1612//                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
     1613//                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
     1614//                }
     1615
     1616              for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
     1617                for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
     1618                  {
     1619                    (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_VAL                         [i][j]));
     1620                    if (_param->_have_port_context_id)
     1621                    (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
     1622                    (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
     1623                    (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
     1624                    if (_param->_have_port_max_depth)
     1625                    (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
     1626                    (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
     1627                    (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
     1628                    (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
     1629                    (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
     1630                  }
     1631              for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
     1632                {
     1633                    (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
     1634                    (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
     1635                    (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
     1636                    (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
     1637//                  (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
     1638                    (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
     1639                  }
     1640
     1641              for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
     1642                for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
     1643                  {
     1644                    (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_VAL                         [i][j]));
     1645                    if (_param->_have_port_context_id)
     1646                    (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
     1647                    (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
     1648                    (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
     1649                    if (_param->_have_port_max_depth)
     1650                    (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
     1651                    (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
     1652                    (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
     1653                    (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
     1654                    (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
     1655                  }
     1656              for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
     1657                {
     1658                    (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
     1659                    (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
     1660                    (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
     1661                    (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
     1662//                  (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
     1663                    (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
     1664                  }
     1665
     1666              if (_param->_have_port_max_depth)
     1667                {
     1668              for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
     1669                for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
     1670                  {
     1671                    (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_VAL                         [i][j]));
     1672                    if (_param->_have_port_context_id)
     1673                    (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
     1674                    (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
     1675                    (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
     1676                    (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
     1677                    (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
     1678                    (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
     1679                    (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
     1680                    (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
     1681                  }
     1682              for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
     1683                {
     1684                    (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
     1685                    (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
     1686                    (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
     1687                    (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
     1688//                  (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
     1689                    (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
     1690                }
     1691                }
     1692          }
     1693# endif
     1694
     1695        log_printf(INFO,Prediction_unit_Glue,FUNCTION,"Method - genMealy_update");
     1696
     1697        SC_METHOD (genMealy_update);
     1698        dont_initialize ();
     1699//      sensitive << (*(in_CLOCK)).neg(); // don't use internal register
     1700        for (uint32_t i=0; i<_param->_nb_inst_branch_update; i++)
     1701          sensitive << (*(in_UPDATE_BTB_ACK           [i]))
     1702                    << (*(in_UPDATE_DIR_ACK           [i]))
     1703                    << (*(in_UPDATE_RAS_ACK           [i]))
     1704                    << (*(in_UPDATE_UPT_VAL           [i]))
     1705                    << (*(in_UPDATE_UPT_BTB_VAL       [i]))
     1706                    << (*(in_UPDATE_UPT_DIR_VAL       [i]))
     1707                    << (*(in_UPDATE_UPT_RAS_VAL       [i]));
     1708
     1709# ifdef SYSTEMCASS_SPECIFIC
     1710        // List dependency information
     1711        for (uint32_t x=0; x<_param->_nb_inst_branch_update; x++)
     1712//        for (uint32_t i=0; i<_param->_nb_inst_branch_update; i++)
     1713            {
     1714              uint32_t i=x;
     1715
     1716              (*(out_UPDATE_BTB_VAL           [x])) (*(in_UPDATE_BTB_ACK           [i]));
     1717              (*(out_UPDATE_BTB_VAL           [x])) (*(in_UPDATE_DIR_ACK           [i]));
     1718              (*(out_UPDATE_BTB_VAL           [x])) (*(in_UPDATE_RAS_ACK           [i]));
     1719              (*(out_UPDATE_BTB_VAL           [x])) (*(in_UPDATE_UPT_VAL           [i]));
     1720              (*(out_UPDATE_BTB_VAL           [x])) (*(in_UPDATE_UPT_BTB_VAL       [i]));
     1721              (*(out_UPDATE_BTB_VAL           [x])) (*(in_UPDATE_UPT_DIR_VAL       [i]));
     1722              (*(out_UPDATE_BTB_VAL           [x])) (*(in_UPDATE_UPT_RAS_VAL       [i]));
     1723
     1724              (*(out_UPDATE_DIR_VAL           [x])) (*(in_UPDATE_BTB_ACK           [i]));
     1725              (*(out_UPDATE_DIR_VAL           [x])) (*(in_UPDATE_DIR_ACK           [i]));
     1726              (*(out_UPDATE_DIR_VAL           [x])) (*(in_UPDATE_RAS_ACK           [i]));
     1727              (*(out_UPDATE_DIR_VAL           [x])) (*(in_UPDATE_UPT_VAL           [i]));
     1728              (*(out_UPDATE_DIR_VAL           [x])) (*(in_UPDATE_UPT_BTB_VAL       [i]));
     1729              (*(out_UPDATE_DIR_VAL           [x])) (*(in_UPDATE_UPT_DIR_VAL       [i]));
     1730              (*(out_UPDATE_DIR_VAL           [x])) (*(in_UPDATE_UPT_RAS_VAL       [i]));
     1731
     1732              (*(out_UPDATE_RAS_VAL           [x])) (*(in_UPDATE_BTB_ACK           [i]));
     1733              (*(out_UPDATE_RAS_VAL           [x])) (*(in_UPDATE_DIR_ACK           [i]));
     1734              (*(out_UPDATE_RAS_VAL           [x])) (*(in_UPDATE_RAS_ACK           [i]));
     1735              (*(out_UPDATE_RAS_VAL           [x])) (*(in_UPDATE_UPT_VAL           [i]));
     1736              (*(out_UPDATE_RAS_VAL           [x])) (*(in_UPDATE_UPT_BTB_VAL       [i]));
     1737              (*(out_UPDATE_RAS_VAL           [x])) (*(in_UPDATE_UPT_DIR_VAL       [i]));
     1738              (*(out_UPDATE_RAS_VAL           [x])) (*(in_UPDATE_UPT_RAS_VAL       [i]));
     1739
     1740              (*(out_UPDATE_UPT_ACK           [x])) (*(in_UPDATE_BTB_ACK           [i]));
     1741              (*(out_UPDATE_UPT_ACK           [x])) (*(in_UPDATE_DIR_ACK           [i]));
     1742              (*(out_UPDATE_UPT_ACK           [x])) (*(in_UPDATE_RAS_ACK           [i]));
     1743              (*(out_UPDATE_UPT_ACK           [x])) (*(in_UPDATE_UPT_VAL           [i]));
     1744              (*(out_UPDATE_UPT_ACK           [x])) (*(in_UPDATE_UPT_BTB_VAL       [i]));
     1745              (*(out_UPDATE_UPT_ACK           [x])) (*(in_UPDATE_UPT_DIR_VAL       [i]));
     1746              (*(out_UPDATE_UPT_ACK           [x])) (*(in_UPDATE_UPT_RAS_VAL       [i]));
     1747            }
     1748# endif
    8681749#endif
    8691750      }

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue/src/Prediction_unit_Glue_allocation.cpp

    r81 r82  
    1616namespace prediction_unit {
    1717namespace prediction_unit_glue {
    18 
    19 
    2018
    2119#undef  FUNCTION
    … …  
    7977     
    8078      {
    81         ALLOC1_INTERFACE("predict_btb",OUT,NORTH,"Interface with ifetch unit",_param->_nb_inst_predict);
     79        ALLOC1_INTERFACE("predict_btb",OUT,NORTH,"Interface with ifetch unit",_param->_nb_inst_branch_predict);
    8280       
    8381        ALLOC1_VALACK_OUT(out_PREDICT_BTB_VAL         ,VAL);
    … …  
    9492     
    9593      {
    96         ALLOC1_INTERFACE("predict_dir",OUT,NORTH,"Interface with ifetch unit",_param->_nb_inst_predict);
     94        ALLOC1_INTERFACE("predict_dir",OUT,NORTH,"Interface with ifetch unit",_param->_nb_inst_branch_predict);
    9795       
    9896        ALLOC1_VALACK_OUT(out_PREDICT_DIR_VAL        ,VAL);
    … …  
    106104     
    107105      {
    108         ALLOC1_INTERFACE("predict_ras",OUT,NORTH,"Interface with ifetch unit",_param->_nb_inst_predict);
     106        ALLOC1_INTERFACE("predict_ras",OUT,NORTH,"Interface with ifetch unit",_param->_nb_inst_branch_predict);
    109107       
    110108        ALLOC1_VALACK_OUT(out_PREDICT_RAS_VAL         ,VAL);
    … …  
    119117     
    120118      {
    121         ALLOC1_INTERFACE("predict_upt",OUT,NORTH,"Interface with ifetch unit",_param->_nb_inst_predict);
     119        ALLOC1_INTERFACE("predict_upt",OUT,NORTH,"Interface with ifetch unit",_param->_nb_inst_branch_predict);
    122120       
    123121        ALLOC1_VALACK_OUT(out_PREDICT_UPT_VAL             ,VAL);
    … …  
    135133    }
    136134   
     135    // ~~~~~[ Interface : "decod" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~           
     136    {
     137      {
     138        ALLOC2_INTERFACE("decod",IN,SOUTH,"Interface with decod unit",_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_interface_it1]);
     139       
     140        _ALLOC2_VALACK_IN ( in_DECOD_VAL                        ,VAL,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     141        _ALLOC2_VALACK_OUT(out_DECOD_ACK                        ,ACK,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     142        _ALLOC2_SIGNAL_IN ( in_DECOD_CONTEXT_ID                 ,"context_id"                 ,Tcontext_t         ,_param->_size_context_id      ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     143        _ALLOC2_SIGNAL_IN ( in_DECOD_MATCH_INST_IFETCH_PTR      ,"match_inst_ifetch_ptr"      ,Tcontrol_t         ,1                             ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     144        _ALLOC2_SIGNAL_IN ( in_DECOD_BRANCH_STATE               ,"branch_state"               ,Tbranch_state_t    ,_param->_size_branch_state    ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     145        _ALLOC2_SIGNAL_IN ( in_DECOD_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t  ,_param->_max_size_depth       ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     146        _ALLOC2_SIGNAL_IN ( in_DECOD_BRANCH_CONDITION           ,"branch_condition"           ,Tbranch_condition_t,_param->_size_branch_condition,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     147        _ALLOC2_SIGNAL_IN ( in_DECOD_BRANCH_DIRECTION           ,"branch_direction"           ,Tcontrol_t         ,1                             ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     148        _ALLOC2_SIGNAL_IN ( in_DECOD_ADDRESS_SRC                ,"address_src"                ,Taddress_t         ,_param->_size_address         ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     149        _ALLOC2_SIGNAL_IN ( in_DECOD_ADDRESS_DEST               ,"address_dest"               ,Taddress_t         ,_param->_size_address         ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
     150      }
     151
     152      {
     153        ALLOC1_INTERFACE("decod_btb",OUT,NORTH,"Interface with decod unit",_param->_nb_inst_branch_decod);
     154
     155        ALLOC1_VALACK_OUT(out_DECOD_BTB_VAL            ,VAL);
     156        ALLOC1_VALACK_IN ( in_DECOD_BTB_ACK            ,ACK);
     157        ALLOC1_SIGNAL_OUT(out_DECOD_BTB_CONTEXT_ID     ,"context_id"     ,Tcontext_t         ,_param->_size_context_id);
     158        ALLOC1_SIGNAL_OUT(out_DECOD_BTB_ADDRESS_SRC    ,"address_src"    ,Taddress_t         ,_param->_size_address);
     159        ALLOC1_SIGNAL_OUT(out_DECOD_BTB_ADDRESS_DEST   ,"address_dest"   ,Taddress_t         ,_param->_size_address);
     160        ALLOC1_SIGNAL_OUT(out_DECOD_BTB_CONDITION      ,"condition"      ,Tbranch_condition_t,_param->_size_branch_condition);
     161        ALLOC1_SIGNAL_OUT(out_DECOD_BTB_LAST_TAKE      ,"last_take"      ,Tcontrol_t         ,1);
     162        ALLOC1_SIGNAL_OUT(out_DECOD_BTB_MISS_PREDICTION,"miss_prediction",Tcontrol_t         ,1);
     163        ALLOC1_SIGNAL_OUT(out_DECOD_BTB_IS_ACCURATE    ,"is_accurate"    ,Tcontrol_t         ,1);
     164      }
     165
     166      {
     167        ALLOC1_INTERFACE("decod_ras",OUT,NORTH,"Interface with decod unit",_param->_nb_inst_branch_decod);
     168                                                                                     
     169        ALLOC1_VALACK_OUT(out_DECOD_RAS_VAL            ,VAL);
     170        ALLOC1_VALACK_IN ( in_DECOD_RAS_ACK            ,ACK);
     171        ALLOC1_SIGNAL_OUT(out_DECOD_RAS_CONTEXT_ID     ,"context_id"     ,Tcontext_t,_param->_size_context_id);
     172        ALLOC1_SIGNAL_IN ( in_DECOD_RAS_HIT            ,"hit"            ,Tcontrol_t,1);
     173        ALLOC1_SIGNAL_OUT(out_DECOD_RAS_PUSH           ,"push"           ,Tcontrol_t,1);
     174        ALLOC1_SIGNAL_OUT(out_DECOD_RAS_ADDRESS_PUSH   ,"address_push"   ,Taddress_t,_param->_size_address);
     175        ALLOC1_SIGNAL_IN ( in_DECOD_RAS_ADDRESS_POP    ,"address_pop"    ,Taddress_t,_param->_size_address);
     176//      ALLOC1_SIGNAL_IN ( in_DECOD_RAS_INDEX          ,"index"          ,Tptr_t    ,_param->_size_ras_index);
     177        ALLOC1_SIGNAL_OUT(out_DECOD_RAS_MISS_PREDICTION,"miss_prediction",Tcontrol_t,1);
     178      }
     179
     180      {
     181        ALLOC1_INTERFACE("decod_upt",OUT,NORTH,"Interface with decod unit",_param->_nb_inst_branch_decod);
     182                                                                                     
     183        ALLOC1_VALACK_OUT(out_DECOD_UPT_VAL                 ,VAL);
     184        ALLOC1_VALACK_IN ( in_DECOD_UPT_ACK                 ,ACK);
     185        ALLOC1_SIGNAL_OUT(out_DECOD_UPT_CONTEXT_ID          ,"context_id"          ,Tcontext_t         ,_param->_size_context_id);
     186        ALLOC1_SIGNAL_OUT(out_DECOD_UPT_BTB_ADDRESS_SRC     ,"btb_address_src"     ,Taddress_t         ,_param->_size_address);
     187        ALLOC1_SIGNAL_OUT(out_DECOD_UPT_BTB_ADDRESS_DEST    ,"btb_address_dest"    ,Taddress_t         ,_param->_size_address);
     188        ALLOC1_SIGNAL_OUT(out_DECOD_UPT_BTB_CONDITION       ,"btb_condition"       ,Tbranch_condition_t,_param->_size_branch_condition);
     189        ALLOC1_SIGNAL_OUT(out_DECOD_UPT_BTB_LAST_TAKE       ,"btb_last_take"       ,Tcontrol_t         ,1);
     190        ALLOC1_SIGNAL_OUT(out_DECOD_UPT_RAS_ADDRESS         ,"ras_address"         ,Taddress_t         ,_param->_size_address);
     191//      ALLOC1_SIGNAL_OUT(out_DECOD_UPT_RAS_INDEX           ,"ras_index"           ,Tptr_t             ,_param->_size_ras_index);
     192        ALLOC1_SIGNAL_OUT(out_DECOD_UPT_MISS_IFETCH         ,"miss_ifetch"         ,Tcontrol_t         ,1);
     193        ALLOC1_SIGNAL_OUT(out_DECOD_UPT_MISS_DECOD          ,"miss_decod"          ,Tcontrol_t         ,1);
     194        ALLOC1_SIGNAL_OUT(out_DECOD_UPT_UPDATE_PREDICTION_ID,"update_prediction_id",Tprediction_ptr_t  ,_param->_max_size_depth);
     195      }
     196    }
     197
     198    // ~~~~~[ Interface : "update" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~           
     199    {
     200      {
     201        ALLOC1_INTERFACE("update_btb",OUT,SOUTH,"Interface with update unit",_param->_nb_inst_branch_update);
     202
     203        ALLOC1_VALACK_OUT(out_UPDATE_BTB_VAL                  ,VAL);
     204        ALLOC1_VALACK_IN ( in_UPDATE_BTB_ACK                  ,ACK);
     205//      ALLOC1_SIGNAL_OUT(out_UPDATE_BTB_CONTEXT_ID           ,"context_id"           ,Tcontext_t         ,_param->_size_context_id);
     206//      ALLOC1_SIGNAL_OUT(out_UPDATE_BTB_ADDRESS_SRC          ,"address_src"          ,Taddress_t         ,_param->_size_address);
     207//      ALLOC1_SIGNAL_OUT(out_UPDATE_BTB_ADDRESS_DEST         ,"address_dest"         ,Taddress_t         ,_param->_size_address);
     208//      ALLOC1_SIGNAL_OUT(out_UPDATE_BTB_CONDITION            ,"condition"            ,Tbranch_condition_t,_param->_size_branch_condition);
     209//      ALLOC1_SIGNAL_OUT(out_UPDATE_BTB_LAST_TAKE            ,"last_take"            ,Tcontrol_t         ,1);
     210//      ALLOC1_SIGNAL_OUT(out_UPDATE_BTB_MISS_PREDICTION      ,"miss_prediction"      ,Tcontrol_t         ,1);
     211      }
     212
     213      {
     214        ALLOC1_INTERFACE("update_dir",OUT,NORTH,"Interface with update unit",_param->_nb_inst_branch_update);
     215
     216        ALLOC1_VALACK_OUT(out_UPDATE_DIR_VAL                  ,VAL);
     217        ALLOC1_VALACK_IN ( in_UPDATE_DIR_ACK                  ,ACK);
     218//      ALLOC1_SIGNAL_OUT(out_UPDATE_DIR_ADDRESS              ,"address"              ,Taddress_t         ,_param->_size_address);
     219//      ALLOC1_SIGNAL_OUT(out_UPDATE_DIR_HISTORY              ,"history"              ,Thistory_t         ,_param->_size_history);
     220//      ALLOC1_SIGNAL_OUT(out_UPDATE_DIR_DIRECTION            ,"direction"            ,Tcontrol_t         ,1);
     221      }
     222
     223      {
     224        ALLOC1_INTERFACE("update_ras",OUT,NORTH,"Interface with update unit",_param->_nb_inst_branch_update);
     225
     226        ALLOC1_VALACK_OUT(out_UPDATE_RAS_VAL                  ,VAL);
     227        ALLOC1_VALACK_IN ( in_UPDATE_RAS_ACK                  ,ACK);
     228//      ALLOC1_SIGNAL_OUT(out_UPDATE_RAS_CONTEXT_ID           ,"context_id"           ,Tcontext_t         ,_param->_size_context_id);
     229//      ALLOC1_SIGNAL_OUT(out_UPDATE_RAS_PUSH                 ,"push"                 ,Tcontrol_t         ,1);
     230//      ALLOC1_SIGNAL_OUT(out_UPDATE_RAS_ADDRESS              ,"address"              ,Taddress_t         ,_param->_size_address);
     231//      ALLOC1_SIGNAL_OUT(out_UPDATE_RAS_INDEX                ,"index"                ,Tptr_t             ,_param->_size_ras_index);
     232//      ALLOC1_SIGNAL_OUT(out_UPDATE_RAS_MISS_PREDICTION      ,"miss_prediction"      ,Tcontrol_t         ,1);
     233//      ALLOC1_SIGNAL_OUT(out_UPDATE_RAS_PREDICTION_IFETCH    ,"prediction_ifetch"    ,Tcontrol_t         ,1);
     234      }
     235
     236      {
     237        ALLOC1_INTERFACE("update_upt",IN ,NORTH,"Interface with update unit",_param->_nb_inst_branch_update);
     238
     239        ALLOC1_VALACK_IN ( in_UPDATE_UPT_VAL                  ,VAL);
     240        ALLOC1_VALACK_OUT(out_UPDATE_UPT_ACK                  ,ACK);
     241//      ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_CONTEXT_ID           ,"context_id"           ,Tcontext_t         ,_param->_size_context_id);
     242//      ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_MISS_PREDICTION      ,"miss_prediction"      ,Tcontrol_t         ,1);
     243//      ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_DIRECTION_GOOD       ,"direction_good"       ,Tcontrol_t         ,1);
     244        ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_BTB_VAL              ,"btb_val"              ,Tcontrol_t         ,1);
     245//      ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_BTB_ADDRESS_SRC      ,"btb_address_src"      ,Taddress_t         ,_param->_size_address);
     246//      ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_BTB_ADDRESS_DEST     ,"btb_address_dest"     ,Taddress_t         ,_param->_size_address);
     247//      ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_BTB_CONDITION        ,"btb_condition"        ,Tbranch_condition_t,_param->_size_branch_condition);
     248        ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_DIR_VAL              ,"dir_val"              ,Tcontrol_t         ,1);
     249//      ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_DIR_HISTORY          ,"dir_history"          ,Thistory_t         ,_param->_size_history);
     250        ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_RAS_VAL              ,"ras_val"              ,Tcontrol_t         ,1);
     251//      ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_RAS_PUSH             ,"ras_push"             ,Tcontrol_t         ,1);
     252//      ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_RAS_ADDRESS          ,"ras_address"          ,Taddress_t         ,_param->_size_address);
     253//      ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_RAS_INDEX            ,"ras_index"            ,Tptr_t             ,_param->_size_ras_index);
     254//      ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_RAS_PREDICTION_IFETCH,"ras_prediction_ifetch",Tcontrol_t         ,1);
     255      }
     256    }
     257
    137258    // ~~~~~[ Interface : "depth" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~           
    138259    {
    139260      ALLOC1_INTERFACE("depth",IN,NORTH,"Interface with depth",_param->_nb_context);
    140      
    141       ALLOC1_SIGNAL_IN (in_DEPTH_UPT_NB_BRANCH,"upt_nb_branch",Tdepth_t,_param->_size_depth[alloc_signal_it1]);
    142       ALLOC1_SIGNAL_IN (in_DEPTH_UPT_TAIL     ,"upt_tail"     ,Tdepth_t,_param->_size_depth[alloc_signal_it1]);
    143     }
     261
     262      ALLOC1_SIGNAL_IN ( in_DEPTH_UPT_NB_BRANCH,"upt_nb_branch",Tdepth_t,_param->_size_depth[alloc_signal_it1]+1);
     263      ALLOC1_SIGNAL_IN ( in_DEPTH_UPT_TAIL     ,"upt_tail"     ,Tdepth_t,_param->_size_depth[alloc_signal_it1]);
     264      ALLOC1_SIGNAL_OUT(out_DEPTH_NB_BRANCH    ,"nb_branch"    ,Tdepth_t,_param->_size_depth[alloc_signal_it1]+1);
     265      ALLOC1_SIGNAL_OUT(out_DEPTH_TAIL         ,"tail"         ,Tdepth_t,_param->_size_depth[alloc_signal_it1]);
     266    }
     267
     268    // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
     269
     270#ifndef NO_INIT
     271    reg_PREDICT_PRIORITY = 0;
     272    reg_DECOD_PRIORITY   = 0;
     273#endif
    144274
    145275    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue/src/Prediction_unit_Glue_deallocation.cpp

    r81 r82  
    2929        delete    in_NRESET;
    3030
     31
    3132        // ~~~~~[ Interface : "predict" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    3233        DELETE1_SIGNAL( in_PREDICT_VAL                        ,_param->_nb_context     ,1);
    … …  
    4142        DELETE1_SIGNAL(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_context     ,_param->_size_depth [alloc_signal_it1]);
    4243        DELETE2_SIGNAL(out_PREDICT_INSTRUCTION_ENABLE         ,_param->_nb_context     ,_param->_nb_instruction[alloc_signal_it1],1);
    43         DELETE1_SIGNAL(out_PREDICT_BTB_VAL                    ,_param->_nb_inst_predict,1);
    44         DELETE1_SIGNAL( in_PREDICT_BTB_ACK                    ,_param->_nb_inst_predict,1);
    45         DELETE1_SIGNAL(out_PREDICT_BTB_CONTEXT_ID             ,_param->_nb_inst_predict,_param->_size_context_id);
    46         DELETE1_SIGNAL(out_PREDICT_BTB_ADDRESS                ,_param->_nb_inst_predict,_param->_size_address);
    47         DELETE1_SIGNAL( in_PREDICT_BTB_HIT                    ,_param->_nb_inst_predict,1);
    48         DELETE1_SIGNAL( in_PREDICT_BTB_ADDRESS_SRC            ,_param->_nb_inst_predict,_param->_size_address);
    49         DELETE1_SIGNAL( in_PREDICT_BTB_ADDRESS_DEST           ,_param->_nb_inst_predict,_param->_size_address);
    50         DELETE1_SIGNAL( in_PREDICT_BTB_CONDITION              ,_param->_nb_inst_predict,_param->_size_branch_condition);
    51 //      DELETE1_SIGNAL( in_PREDICT_BTB_LAST_TAKE              ,_param->_nb_inst_predict,1);
    52         DELETE1_SIGNAL( in_PREDICT_BTB_IS_ACCURATE            ,_param->_nb_inst_predict,1);
    53         DELETE1_SIGNAL(out_PREDICT_DIR_VAL                    ,_param->_nb_inst_predict,1);
    54         DELETE1_SIGNAL( in_PREDICT_DIR_ACK                    ,_param->_nb_inst_predict,1);
    55         DELETE1_SIGNAL(out_PREDICT_DIR_ADDRESS_SRC            ,_param->_nb_inst_predict,_param->_size_address);
    56         DELETE1_SIGNAL(out_PREDICT_DIR_STATIC                 ,_param->_nb_inst_predict,1);
    57 //      DELETE1_SIGNAL(out_PREDICT_DIR_LAST_TAKE              ,_param->_nb_inst_predict,1);
    58 //      DELETE1_SIGNAL( in_PREDICT_DIR_HISTORY                ,_param->_nb_inst_predict,_param->_size_history);
    59         DELETE1_SIGNAL( in_PREDICT_DIR_DIRECTION              ,_param->_nb_inst_predict,1);
    60         DELETE1_SIGNAL(out_PREDICT_RAS_VAL                    ,_param->_nb_inst_predict,1);
    61         DELETE1_SIGNAL( in_PREDICT_RAS_ACK                    ,_param->_nb_inst_predict,1);
    62         DELETE1_SIGNAL(out_PREDICT_RAS_CONTEXT_ID             ,_param->_nb_inst_predict,_param->_size_context_id);
    63         DELETE1_SIGNAL( in_PREDICT_RAS_HIT                    ,_param->_nb_inst_predict,1);
    64         DELETE1_SIGNAL(out_PREDICT_RAS_PUSH                   ,_param->_nb_inst_predict,1);
    65         DELETE1_SIGNAL(out_PREDICT_RAS_ADDRESS_PUSH           ,_param->_nb_inst_predict,_param->_size_address);
    66         DELETE1_SIGNAL( in_PREDICT_RAS_ADDRESS_POP            ,_param->_nb_inst_predict,_param->_size_address);
    67 //      DELETE1_SIGNAL( in_PREDICT_RAS_INDEX                  ,_param->_nb_inst_predict,_param->_size_ras_index);
    68         DELETE1_SIGNAL(out_PREDICT_UPT_VAL                    ,_param->_nb_inst_predict,1);
    69         DELETE1_SIGNAL( in_PREDICT_UPT_ACK                    ,_param->_nb_inst_predict,1);
    70         DELETE1_SIGNAL(out_PREDICT_UPT_CONTEXT_ID             ,_param->_nb_inst_predict,_param->_size_context_id);
    71         DELETE1_SIGNAL(out_PREDICT_UPT_BTB_ADDRESS_SRC        ,_param->_nb_inst_predict,_param->_size_address);
    72         DELETE1_SIGNAL(out_PREDICT_UPT_BTB_ADDRESS_DEST       ,_param->_nb_inst_predict,_param->_size_address);
    73         DELETE1_SIGNAL(out_PREDICT_UPT_BTB_CONDITION          ,_param->_nb_inst_predict,_param->_size_branch_condition);
    74         DELETE1_SIGNAL(out_PREDICT_UPT_BTB_LAST_TAKE          ,_param->_nb_inst_predict,1);
    75         DELETE1_SIGNAL(out_PREDICT_UPT_BTB_IS_ACCURATE        ,_param->_nb_inst_predict,1);
    76 //      DELETE1_SIGNAL(out_PREDICT_UPT_DIR_HISTORY            ,_param->_nb_inst_predict,_param->_size_history);
    77         DELETE1_SIGNAL(out_PREDICT_UPT_RAS_ADDRESS            ,_param->_nb_inst_predict,_param->_size_address);
    78 //      DELETE1_SIGNAL(out_PREDICT_UPT_RAS_INDEX              ,_param->_nb_inst_predict,_param->_size_ras_index);
     44        DELETE1_SIGNAL(out_PREDICT_BTB_VAL                    ,_param->_nb_inst_branch_predict,1);
     45        DELETE1_SIGNAL( in_PREDICT_BTB_ACK                    ,_param->_nb_inst_branch_predict,1);
     46        DELETE1_SIGNAL(out_PREDICT_BTB_CONTEXT_ID             ,_param->_nb_inst_branch_predict,_param->_size_context_id);
     47        DELETE1_SIGNAL(out_PREDICT_BTB_ADDRESS                ,_param->_nb_inst_branch_predict,_param->_size_address);
     48        DELETE1_SIGNAL( in_PREDICT_BTB_HIT                    ,_param->_nb_inst_branch_predict,1);
     49        DELETE1_SIGNAL( in_PREDICT_BTB_ADDRESS_SRC            ,_param->_nb_inst_branch_predict,_param->_size_address);
     50        DELETE1_SIGNAL( in_PREDICT_BTB_ADDRESS_DEST           ,_param->_nb_inst_branch_predict,_param->_size_address);
     51        DELETE1_SIGNAL( in_PREDICT_BTB_CONDITION              ,_param->_nb_inst_branch_predict,_param->_size_branch_condition);
     52//      DELETE1_SIGNAL( in_PREDICT_BTB_LAST_TAKE              ,_param->_nb_inst_branch_predict,1);
     53        DELETE1_SIGNAL( in_PREDICT_BTB_IS_ACCURATE            ,_param->_nb_inst_branch_predict,1);
     54        DELETE1_SIGNAL(out_PREDICT_DIR_VAL                    ,_param->_nb_inst_branch_predict,1);
     55        DELETE1_SIGNAL( in_PREDICT_DIR_ACK                    ,_param->_nb_inst_branch_predict,1);
     56        DELETE1_SIGNAL(out_PREDICT_DIR_ADDRESS_SRC            ,_param->_nb_inst_branch_predict,_param->_size_address);
     57        DELETE1_SIGNAL(out_PREDICT_DIR_STATIC                 ,_param->_nb_inst_branch_predict,1);
     58//      DELETE1_SIGNAL(out_PREDICT_DIR_LAST_TAKE              ,_param->_nb_inst_branch_predict,1);
     59//      DELETE1_SIGNAL( in_PREDICT_DIR_HISTORY                ,_param->_nb_inst_branch_predict,_param->_size_history);
     60        DELETE1_SIGNAL( in_PREDICT_DIR_DIRECTION              ,_param->_nb_inst_branch_predict,1);
     61        DELETE1_SIGNAL(out_PREDICT_RAS_VAL                    ,_param->_nb_inst_branch_predict,1);
     62        DELETE1_SIGNAL( in_PREDICT_RAS_ACK                    ,_param->_nb_inst_branch_predict,1);
     63        DELETE1_SIGNAL(out_PREDICT_RAS_CONTEXT_ID             ,_param->_nb_inst_branch_predict,_param->_size_context_id);
     64        DELETE1_SIGNAL( in_PREDICT_RAS_HIT                    ,_param->_nb_inst_branch_predict,1);
     65        DELETE1_SIGNAL(out_PREDICT_RAS_PUSH                   ,_param->_nb_inst_branch_predict,1);
     66        DELETE1_SIGNAL(out_PREDICT_RAS_ADDRESS_PUSH           ,_param->_nb_inst_branch_predict,_param->_size_address);
     67        DELETE1_SIGNAL( in_PREDICT_RAS_ADDRESS_POP            ,_param->_nb_inst_branch_predict,_param->_size_address);
     68//      DELETE1_SIGNAL( in_PREDICT_RAS_INDEX                  ,_param->_nb_inst_branch_predict,_param->_size_ras_index);
     69        DELETE1_SIGNAL(out_PREDICT_UPT_VAL                    ,_param->_nb_inst_branch_predict,1);
     70        DELETE1_SIGNAL( in_PREDICT_UPT_ACK                    ,_param->_nb_inst_branch_predict,1);
     71        DELETE1_SIGNAL(out_PREDICT_UPT_CONTEXT_ID             ,_param->_nb_inst_branch_predict,_param->_size_context_id);
     72        DELETE1_SIGNAL(out_PREDICT_UPT_BTB_ADDRESS_SRC        ,_param->_nb_inst_branch_predict,_param->_size_address);
     73        DELETE1_SIGNAL(out_PREDICT_UPT_BTB_ADDRESS_DEST       ,_param->_nb_inst_branch_predict,_param->_size_address);
     74        DELETE1_SIGNAL(out_PREDICT_UPT_BTB_CONDITION          ,_param->_nb_inst_branch_predict,_param->_size_branch_condition);
     75        DELETE1_SIGNAL(out_PREDICT_UPT_BTB_LAST_TAKE          ,_param->_nb_inst_branch_predict,1);
     76        DELETE1_SIGNAL(out_PREDICT_UPT_BTB_IS_ACCURATE        ,_param->_nb_inst_branch_predict,1);
     77//      DELETE1_SIGNAL(out_PREDICT_UPT_DIR_HISTORY            ,_param->_nb_inst_branch_predict,_param->_size_history);
     78        DELETE1_SIGNAL(out_PREDICT_UPT_RAS_ADDRESS            ,_param->_nb_inst_branch_predict,_param->_size_address);
     79//      DELETE1_SIGNAL(out_PREDICT_UPT_RAS_INDEX              ,_param->_nb_inst_branch_predict,_param->_size_ras_index);
     80
     81        // ~~~~~[ Interface : "decod" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     82        DELETE2_SIGNAL( in_DECOD_VAL                        ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],1);
     83        DELETE2_SIGNAL(out_DECOD_ACK                        ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],1);
     84        DELETE2_SIGNAL( in_DECOD_CONTEXT_ID                 ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],_param->_size_context_id      );
     85        DELETE2_SIGNAL( in_DECOD_MATCH_INST_IFETCH_PTR      ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],1                             );
     86        DELETE2_SIGNAL( in_DECOD_BRANCH_STATE               ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],_param->_size_branch_state    );
     87        DELETE2_SIGNAL( in_DECOD_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],_param->_max_size_depth       );
     88        DELETE2_SIGNAL( in_DECOD_BRANCH_CONDITION           ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],_param->_size_branch_condition);
     89        DELETE2_SIGNAL( in_DECOD_BRANCH_DIRECTION           ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],1                             );
     90        DELETE2_SIGNAL( in_DECOD_ADDRESS_SRC                ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],_param->_size_address         );
     91        DELETE2_SIGNAL( in_DECOD_ADDRESS_DEST               ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],_param->_size_address         );
     92        DELETE1_SIGNAL(out_DECOD_BTB_VAL            ,_param->_nb_inst_branch_decod,1);
     93        DELETE1_SIGNAL( in_DECOD_BTB_ACK            ,_param->_nb_inst_branch_decod,1);
     94        DELETE1_SIGNAL(out_DECOD_BTB_CONTEXT_ID     ,_param->_nb_inst_branch_decod,_param->_size_context_id);
     95        DELETE1_SIGNAL(out_DECOD_BTB_ADDRESS_SRC    ,_param->_nb_inst_branch_decod,_param->_size_address);
     96        DELETE1_SIGNAL(out_DECOD_BTB_ADDRESS_DEST   ,_param->_nb_inst_branch_decod,_param->_size_address);
     97        DELETE1_SIGNAL(out_DECOD_BTB_CONDITION      ,_param->_nb_inst_branch_decod,_param->_size_branch_condition);
     98        DELETE1_SIGNAL(out_DECOD_BTB_LAST_TAKE      ,_param->_nb_inst_branch_decod,1);
     99        DELETE1_SIGNAL(out_DECOD_BTB_MISS_PREDICTION,_param->_nb_inst_branch_decod,1);
     100        DELETE1_SIGNAL(out_DECOD_BTB_IS_ACCURATE    ,_param->_nb_inst_branch_decod,1);
     101
     102        DELETE1_SIGNAL(out_DECOD_RAS_VAL            ,_param->_nb_inst_branch_decod,1);
     103        DELETE1_SIGNAL( in_DECOD_RAS_ACK            ,_param->_nb_inst_branch_decod,1);
     104        DELETE1_SIGNAL(out_DECOD_RAS_CONTEXT_ID     ,_param->_nb_inst_branch_decod,_param->_size_context_id);
     105        DELETE1_SIGNAL( in_DECOD_RAS_HIT            ,_param->_nb_inst_branch_decod,1);
     106        DELETE1_SIGNAL(out_DECOD_RAS_PUSH           ,_param->_nb_inst_branch_decod,1);
     107        DELETE1_SIGNAL(out_DECOD_RAS_ADDRESS_PUSH   ,_param->_nb_inst_branch_decod,_param->_size_address);
     108        DELETE1_SIGNAL( in_DECOD_RAS_ADDRESS_POP    ,_param->_nb_inst_branch_decod,_param->_size_address);
     109//      DELETE1_SIGNAL( in_DECOD_RAS_INDEX          ,_param->_nb_inst_branch_decod,_param->_size_ras_index);
     110        DELETE1_SIGNAL(out_DECOD_RAS_MISS_PREDICTION,_param->_nb_inst_branch_decod,1);
     111
     112        DELETE1_SIGNAL(out_DECOD_UPT_VAL                 ,_param->_nb_inst_branch_decod,1);
     113        DELETE1_SIGNAL( in_DECOD_UPT_ACK                 ,_param->_nb_inst_branch_decod,1);
     114        DELETE1_SIGNAL(out_DECOD_UPT_CONTEXT_ID          ,_param->_nb_inst_branch_decod,_param->_size_context_id);
     115        DELETE1_SIGNAL(out_DECOD_UPT_BTB_ADDRESS_SRC     ,_param->_nb_inst_branch_decod,_param->_size_address);
     116        DELETE1_SIGNAL(out_DECOD_UPT_BTB_ADDRESS_DEST    ,_param->_nb_inst_branch_decod,_param->_size_address);
     117        DELETE1_SIGNAL(out_DECOD_UPT_BTB_CONDITION       ,_param->_nb_inst_branch_decod,_param->_size_branch_condition);
     118        DELETE1_SIGNAL(out_DECOD_UPT_BTB_LAST_TAKE       ,_param->_nb_inst_branch_decod,1);
     119        DELETE1_SIGNAL(out_DECOD_UPT_RAS_ADDRESS         ,_param->_nb_inst_branch_decod,_param->_size_address);
     120//      DELETE1_SIGNAL(out_DECOD_UPT_RAS_INDEX           ,_param->_nb_inst_branch_decod,_param->_size_ras_index);
     121        DELETE1_SIGNAL(out_DECOD_UPT_MISS_IFETCH         ,_param->_nb_inst_branch_decod,1);
     122        DELETE1_SIGNAL(out_DECOD_UPT_MISS_DECOD          ,_param->_nb_inst_branch_decod,1);
     123        DELETE1_SIGNAL(out_DECOD_UPT_UPDATE_PREDICTION_ID,_param->_nb_inst_branch_decod,_param->_max_size_depth);
     124
     125        // ~~~~~[ Interface : "update" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~       
     126        DELETE1_SIGNAL(out_UPDATE_BTB_VAL                  ,_param->_nb_inst_branch_update,1);
     127        DELETE1_SIGNAL( in_UPDATE_BTB_ACK                  ,_param->_nb_inst_branch_update,1);
     128//      DELETE1_SIGNAL(out_UPDATE_BTB_CONTEXT_ID           ,_param->_nb_inst_branch_update,_param->_size_context_id);
     129//      DELETE1_SIGNAL(out_UPDATE_BTB_ADDRESS_SRC          ,_param->_nb_inst_branch_update,_param->_size_address);
     130//      DELETE1_SIGNAL(out_UPDATE_BTB_ADDRESS_DEST         ,_param->_nb_inst_branch_update,_param->_size_address);
     131//      DELETE1_SIGNAL(out_UPDATE_BTB_CONDITION            ,_param->_nb_inst_branch_update,_param->_size_branch_condition);
     132//      DELETE1_SIGNAL(out_UPDATE_BTB_LAST_TAKE            ,_param->_nb_inst_branch_update,1);
     133//      DELETE1_SIGNAL(out_UPDATE_BTB_MISS_PREDICTION      ,_param->_nb_inst_branch_update,1);
     134
     135        DELETE1_SIGNAL(out_UPDATE_DIR_VAL                  ,_param->_nb_inst_branch_update,1);
     136        DELETE1_SIGNAL( in_UPDATE_DIR_ACK                  ,_param->_nb_inst_branch_update,1);
     137//      DELETE1_SIGNAL(out_UPDATE_DIR_ADDRESS              ,_param->_nb_inst_branch_update,_param->_size_address);
     138//      DELETE1_SIGNAL(out_UPDATE_DIR_HISTORY              ,_param->_nb_inst_branch_update,_param->_size_history);
     139//      DELETE1_SIGNAL(out_UPDATE_DIR_DIRECTION            ,_param->_nb_inst_branch_update,1);
     140
     141        DELETE1_SIGNAL(out_UPDATE_RAS_VAL                  ,_param->_nb_inst_branch_update,1);
     142        DELETE1_SIGNAL( in_UPDATE_RAS_ACK                  ,_param->_nb_inst_branch_update,1);
     143//      DELETE1_SIGNAL(out_UPDATE_RAS_CONTEXT_ID           ,_param->_nb_inst_branch_update,_param->_size_context_id);
     144//      DELETE1_SIGNAL(out_UPDATE_RAS_PUSH                 ,_param->_nb_inst_branch_update,1);
     145//      DELETE1_SIGNAL(out_UPDATE_RAS_ADDRESS              ,_param->_nb_inst_branch_update,_param->_size_address);
     146//      DELETE1_SIGNAL(out_UPDATE_RAS_INDEX                ,_param->_nb_inst_branch_update,_param->_size_ras_index);
     147//      DELETE1_SIGNAL(out_UPDATE_RAS_MISS_PREDICTION      ,_param->_nb_inst_branch_update,1);
     148//      DELETE1_SIGNAL(out_UPDATE_RAS_PREDICTION_IFETCH    ,_param->_nb_inst_branch_update,1);
     149
     150        DELETE1_SIGNAL( in_UPDATE_UPT_VAL                  ,_param->_nb_inst_branch_update,1);
     151        DELETE1_SIGNAL(out_UPDATE_UPT_ACK                  ,_param->_nb_inst_branch_update,1);
     152//      DELETE1_SIGNAL( in_UPDATE_UPT_CONTEXT_ID           ,_param->_nb_inst_branch_update,_param->_size_context_id);
     153//      DELETE1_SIGNAL( in_UPDATE_UPT_MISS_PREDICTION      ,_param->_nb_inst_branch_update,1);
     154//      DELETE1_SIGNAL( in_UPDATE_UPT_DIRECTION_GOOD       ,_param->_nb_inst_branch_update,1);
     155        DELETE1_SIGNAL( in_UPDATE_UPT_BTB_VAL              ,_param->_nb_inst_branch_update,1);
     156//      DELETE1_SIGNAL( in_UPDATE_UPT_BTB_ADDRESS_SRC      ,_param->_nb_inst_branch_update,_param->_size_address);
     157//      DELETE1_SIGNAL( in_UPDATE_UPT_BTB_ADDRESS_DEST     ,_param->_nb_inst_branch_update,_param->_size_address);
     158//      DELETE1_SIGNAL( in_UPDATE_UPT_BTB_CONDITION        ,_param->_nb_inst_branch_update,_param->_size_branch_condition);
     159        DELETE1_SIGNAL( in_UPDATE_UPT_DIR_VAL              ,_param->_nb_inst_branch_update,1);
     160//      DELETE1_SIGNAL( in_UPDATE_UPT_DIR_HISTORY          ,_param->_nb_inst_branch_update,_param->_size_history);
     161        DELETE1_SIGNAL( in_UPDATE_UPT_RAS_VAL              ,_param->_nb_inst_branch_update,1);
     162//      DELETE1_SIGNAL( in_UPDATE_UPT_RAS_PUSH             ,_param->_nb_inst_branch_update,1);
     163//      DELETE1_SIGNAL( in_UPDATE_UPT_RAS_ADDRESS          ,_param->_nb_inst_branch_update,_param->_size_address);
     164//      DELETE1_SIGNAL( in_UPDATE_UPT_RAS_INDEX            ,_param->_nb_inst_branch_update,_param->_size_ras_index);
     165//      DELETE1_SIGNAL( in_UPDATE_UPT_RAS_PREDICTION_IFETCH,_param->_nb_inst_branch_update,1);
    79166
    80167        // ~~~~~[ Interface : "depth" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~       
    81         DELETE1_SIGNAL( in_DEPTH_UPT_NB_BRANCH,_param->_nb_context,_param->_size_depth[alloc_signal_it1]);
     168        DELETE1_SIGNAL( in_DEPTH_UPT_NB_BRANCH,_param->_nb_context,_param->_size_depth[alloc_signal_it1]+1);
    82169        DELETE1_SIGNAL( in_DEPTH_UPT_TAIL     ,_param->_nb_context,_param->_size_depth[alloc_signal_it1]);
     170        DELETE1_SIGNAL(out_DEPTH_NB_BRANCH    ,_param->_nb_context,_param->_size_depth[alloc_signal_it1]+1);
     171        DELETE1_SIGNAL(out_DEPTH_TAIL         ,_param->_nb_context,_param->_size_depth[alloc_signal_it1]);
    83172      }
    84173    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue/src/Prediction_unit_Glue_genMealy_predict.cpp

    r81 r82  
    2626    Tcontrol_t ack [_param->_nb_context];
    2727    for (uint32_t i=0; i<_param->_nb_context; i++)
    28       ack [i] = 0;
    29    
    30     for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
     28      {
     29        ack [i] = 0;
     30
     31        if (_param->_have_port_depth[i])
     32          {
     33            PORT_WRITE(out_DEPTH_TAIL      [i],PORT_READ(in_DEPTH_UPT_TAIL      [i]));
     34          }
     35            PORT_WRITE(out_DEPTH_NB_BRANCH [i],PORT_READ(in_DEPTH_UPT_NB_BRANCH [i]));
     36      }
     37
     38    for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
    3139      {
    3240        log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"PREDICT [%d]",i);
    … …  
    136144                        {
    137145                          branch_state = BRANCH_STATE_SPEC_NTAKE;
    138                           pc_next      = address_src+8; // +4 = delay slot
     146                          pc_next      = address_src+2; // +1 = delay slot
    139147                        }
    140148                      break;
    … …  
    191199                    PORT_WRITE(out_PREDICT_RAS_CONTEXT_ID   [i], context);
    192200                    PORT_WRITE(out_PREDICT_RAS_PUSH         [i], push);
    193                     PORT_WRITE(out_PREDICT_RAS_ADDRESS_PUSH [i], address_src+8);
     201                    PORT_WRITE(out_PREDICT_RAS_ADDRESS_PUSH [i], address_src+2);
    194202
    195203                    is_accurate &= PORT_READ(in_PREDICT_RAS_HIT [i]); // if miss - prediction is not accurate
    … …  
    221229//                               (use_upt and PORT_READ(in_PREDICT_UPT_ACK [i])));
    222230
    223                 dir_val = (PORT_READ(in_PREDICT_BTB_ACK [i]) and
    224                            (use_ras and PORT_READ(in_PREDICT_RAS_ACK [i])) and
    225                            (use_upt and PORT_READ(in_PREDICT_UPT_ACK [i])));
    226 
    227                 ras_val = (PORT_READ(in_PREDICT_BTB_ACK [i]) and
    228                            (use_dir and PORT_READ(in_PREDICT_DIR_ACK [i])) and
    229                            (use_upt and PORT_READ(in_PREDICT_UPT_ACK [i])));
    230 
    231                 upt_val = (PORT_READ(in_PREDICT_BTB_ACK [i]) and
    232                            (use_dir and PORT_READ(in_PREDICT_DIR_ACK [i])) and
    233                            (use_ras and PORT_READ(in_PREDICT_RAS_ACK [i])));
     231                dir_val = (use_dir and
     232                           PORT_READ(in_PREDICT_BTB_ACK [i]) and
     233                           (not use_ras or (use_ras and PORT_READ(in_PREDICT_RAS_ACK [i]))) and
     234                           (not use_upt or (use_upt and PORT_READ(in_PREDICT_UPT_ACK [i]))));
     235
     236                ras_val = (use_ras and
     237                           PORT_READ(in_PREDICT_BTB_ACK [i]) and
     238                           (not use_dir or (use_dir and PORT_READ(in_PREDICT_DIR_ACK [i]))) and
     239                           (not use_upt or (use_upt and PORT_READ(in_PREDICT_UPT_ACK [i]))));
     240
     241                upt_val = (use_upt and
     242                           PORT_READ(in_PREDICT_BTB_ACK [i]) and
     243                           (not use_dir or (use_dir and PORT_READ(in_PREDICT_DIR_ACK [i]))) and
     244                           (not use_ras or (use_ras and PORT_READ(in_PREDICT_RAS_ACK [i]))));
    234245
    235246//              pc_next      - is previously computed
    … …  
    238249                Taddress_t address_src_lsb  = address_src%_param->_nb_instruction [context];
    239250
     251                log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * address_src     : 0x%x",address_src);
     252                log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * address_src_lsb : %d",address_src_lsb);
    240253                if (address_src_lsb == (_param->_nb_instruction [context]-1))
    241254                  {
    242255                    // branch is in the last slot of the packet
     256                    log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * branch is in the last slot of the packet");
     257               
    243258                    address_msb        = _param->_nb_instruction [context]; // == (address_src_lsb+1)
    244259                    pc_next_is_ds_take = 1;
    … …  
    250265                    pc_next_is_ds_take = 0;
    251266                  }
     267                log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * address_msb     : %d",address_msb);
    252268
    253269                inst_ifetch_ptr             = address_src_lsb;
    254                 branch_update_prediction_id = (PORT_READ(in_DEPTH_UPT_TAIL[context])+PORT_READ(in_DEPTH_UPT_NB_BRANCH [context]))%_param->_size_depth[context];
     270                branch_update_prediction_id = (_param->_have_port_depth[context])?((PORT_READ(in_DEPTH_UPT_TAIL[context])+PORT_READ(in_DEPTH_UPT_NB_BRANCH [context]))%_param->_size_depth[context]):0;
    255271              }
    256272            else
    … …  
    270286              PORT_WRITE(out_PREDICT_PC_NEXT                     [context]   , pc_next                    );
    271287              PORT_WRITE(out_PREDICT_PC_NEXT_IS_DS_TAKE          [context]   , pc_next_is_ds_take         );
     288
     289              log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"  * instruction enable :");
     290              log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * nb_inst : %d",_param->_nb_instruction [context]);
     291              log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * [0:%d[ = 0",address_lsb);
     292              log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * [%d:%d[ = 1",address_lsb,((pc_current_is_ds_take)?1:address_msb));
     293              log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * [%d:%d[ = 0",((pc_current_is_ds_take)?1:address_msb),_param->_nb_instruction [context]);
     294
    272295              for (uint32_t j=0; j<address_lsb; j++)
    273296              PORT_WRITE(out_PREDICT_INSTRUCTION_ENABLE          [context][j], 0); // Before the address : not valid

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue/src/Prediction_unit_Glue_transition.cpp

    r81 r82  
    2727      {
    2828        reg_PREDICT_PRIORITY = 0;
     29        reg_DECOD_PRIORITY   = 0;
    2930      }
    3031    else
    3132      {
    3233        // Round robin priority
    33         reg_PREDICT_PRIORITY = (reg_PREDICT_PRIORITY+_param->_nb_inst_predict)%_param->_nb_context;
     34        reg_PREDICT_PRIORITY = (reg_PREDICT_PRIORITY+_param->_nb_inst_branch_predict)%_param->_nb_context;
     35        reg_DECOD_PRIORITY   = (reg_DECOD_PRIORITY  +1)%_param->_nb_decod_unit;
    3436      }
    3537#if defined(STATISTICS) or defined(VHDL_TESTBENCH)
Note: See TracChangeset for help on using the changeset viewer.