Ignore:
Timestamp:
Apr 15, 2008, 8:40:01 PM (16 years ago)
Author:
rosiere
Message:
  • Finish Environment (and test)
  • Continue predictor_unit
  • Add external tools
  • svn keyword "Id" set
Location:
trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/SelfTest/src
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/SelfTest/src/main.cpp

    • Property svn:keywords set to Id
    r78 r81  
    88#include "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/SelfTest/include/test.h"
    99
    10 #define NB_PARAMS 0
     10#define NB_PARAMS 7
    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 (_(" * ()\n"));
     16  err (_(" * nb_context                           (uint32_t)\n"));
     17  err (_(" * size_queue              [nb_context] (uint32_t)\n"));
     18  err (_(" * size_address                         (uint32_t)\n"));
     19  err (_(" * nb_inst_predict                      (uint32_t)\n"));
     20  err (_(" * nb_inst_decod                        (uint32_t)\n"));
     21  err (_(" * nb_inst_branch_complete              (uint32_t)\n"));
     22  err (_(" * nb_inst_update                       (uint32_t)\n"));
     23  err (_(" * size_history                         (uint32_t)\n"));
     24  err (_(" * size_ras_index          [nb_context] (uint32_t)\n"));
    1725
    1826  exit (1);
     
    2533#endif
    2634{
    27   if (argc != static_cast<int>(2+NB_PARAMS))
     35  if (argc <= static_cast<int>(2+NB_PARAMS))
    2836    usage (argc, argv);
    2937
     
    3139
    3240  string name = argv[x++];
    33 //const uint32_t size_data = atoi(argv[x++]);
    34 //const uint32_t nb_port   = atoi(argv[x++]);
     41
     42  uint32_t   _nb_context              = fromString<uint32_t>(argv[x++]);
     43
     44  if (argc != static_cast<int>(2+NB_PARAMS+2*_nb_context))
     45    usage (argc, argv);
     46
     47  uint32_t * _size_queue              = new uint32_t [_nb_context];
     48  for (uint32_t i=0; i<_nb_context; i++)
     49    _size_queue [i] = fromString<uint32_t>(argv[x++]);
     50  uint32_t   _size_address            = fromString<uint32_t>(argv[x++]);
     51  uint32_t   _nb_inst_predict         = fromString<uint32_t>(argv[x++]);
     52  uint32_t   _nb_inst_decod           = fromString<uint32_t>(argv[x++]);
     53  uint32_t   _nb_inst_branch_complete = fromString<uint32_t>(argv[x++]);
     54  uint32_t   _nb_inst_update          = fromString<uint32_t>(argv[x++]);
     55  uint32_t   _size_history            = fromString<uint32_t>(argv[x++]);
     56  uint32_t * _size_ras_index          = new uint32_t [_nb_context];
     57  for (uint32_t i=0; i<_nb_context; i++)
     58    _size_ras_index [i] = fromString<uint32_t>(argv[x++]);
    3559
    3660  int _return = EXIT_SUCCESS;
     
    3862    {
    3963      morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::Parameters * param = new morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::Parameters
    40         (//size_data,
    41          //nb_port 
    42         );
     64        (_nb_context             ,
     65         _size_queue             ,
     66         _size_address           ,
     67         _nb_inst_predict        ,
     68         _nb_inst_decod          ,
     69         _nb_inst_branch_complete,
     70         _nb_inst_update         ,
     71         _size_history           ,
     72         _size_ras_index         );
    4373     
    4474      msg(_("%s"),param->print(1).c_str());
     
    5787    }
    5888
     89
     90  delete [] _size_ras_index;
     91  delete [] _size_queue;
     92
    5993  return (_return);
    6094}
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/SelfTest/src/test.cpp

    • Property svn:keywords set to Id
    r78 r81  
    77 */
    88
     9#define NB_ITERATION  8
     10#define CYCLE_MAX     (128*NB_ITERATION)
     11
    912#include "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/SelfTest/include/test.h"
    1013#include "Common/include/Test.h"
    1114#include "Behavioural/include/Allocation.h"
    12 
    13 #define NB_ITERATION  1
    14 #define CYCLE_MAX     (128*NB_ITERATION)
    15 
    16 #define LABEL(str...)                                                   \
    17   {                                                                     \
    18     msg (_("{%d} "),static_cast<uint32_t>(sc_simulation_time()));       \
    19     msg (str);                                                          \
    20     msg (_("\n"));                                                      \
    21   } while(0)
    22 
    23 #define SC_START(cycle_offset)                                                       \
    24   do                                                                                 \
    25     {                                                                                \
    26       /*cout << "SC_START (begin)" << endl;*/                                        \
    27                                                                                      \
    28       uint32_t cycle_current = static_cast<uint32_t>(sc_simulation_time());          \
    29       if (cycle_offset != 0)                                                         \
    30         {                                                                            \
    31           cout << "##########[ cycle "<< cycle_current+cycle_offset << " ]" << endl; \
    32         }                                                                            \
    33                                                                                      \
    34       if (cycle_current > CYCLE_MAX)                                                 \
    35         {                                                                            \
    36           TEST_KO("Maximal cycles Reached");                                         \
    37         }                                                                            \
    38                                                                                      \
    39       sc_start(cycle_offset);                                                        \
    40                                                                                      \
    41       /*cout << "SC_START (end  )" << endl;*/                                        \
    42     } while(0)
    4315
    4416void test (string name,
     
    5123#endif
    5224
    53   Update_Prediction_Table * _Update_Prediction_Table = new Update_Prediction_Table (name.c_str(),
     25  Tusage_t _usage = USE_ALL;
     26
     27//   _usage = usage_unset(_usage,USE_SYSTEMC              );
     28//   _usage = usage_unset(_usage,USE_VHDL                 );
     29//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
     30//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
     31//   _usage = usage_unset(_usage,USE_POSITION             );
     32//   _usage = usage_unset(_usage,USE_STATISTICS           );
     33//   _usage = usage_unset(_usage,USE_INFORMATION          );
     34   
     35  Update_Prediction_Table * _Update_Prediction_Table = new Update_Prediction_Table
     36    (name.c_str(),
    5437#ifdef STATISTICS
    55                                              _parameters_statistics,
     38     _parameters_statistics,
    5639#endif
    57                                              _param);
     40     _param,
     41     _usage);
    5842 
    5943#ifdef SYSTEMC
     
    6549  sc_clock              *  in_CLOCK  = new sc_clock ("clock", 1.0, 0.5);         
    6650  sc_signal<Tcontrol_t> *  in_NRESET = new sc_signal<Tcontrol_t> ("NRESET");
     51
     52  ALLOC1_SC_SIGNAL( in_PREDICT_VAL                    ," in_PREDICT_VAL                    ",Tcontrol_t         ,_param->_nb_inst_predict);
     53  ALLOC1_SC_SIGNAL(out_PREDICT_ACK                    ,"out_PREDICT_ACK                    ",Tcontrol_t         ,_param->_nb_inst_predict);
     54  ALLOC1_SC_SIGNAL( in_PREDICT_CONTEXT_ID             ," in_PREDICT_CONTEXT_ID             ",Tcontext_t         ,_param->_nb_inst_predict);
     55  ALLOC1_SC_SIGNAL( in_PREDICT_BTB_ADDRESS_SRC        ," in_PREDICT_BTB_ADDRESS_SRC        ",Taddress_t         ,_param->_nb_inst_predict);
     56  ALLOC1_SC_SIGNAL( in_PREDICT_BTB_ADDRESS_DEST       ," in_PREDICT_BTB_ADDRESS_DEST       ",Taddress_t         ,_param->_nb_inst_predict);
     57  ALLOC1_SC_SIGNAL( in_PREDICT_BTB_CONDITION          ," in_PREDICT_BTB_CONDITION          ",Tbranch_condition_t,_param->_nb_inst_predict);
     58  ALLOC1_SC_SIGNAL( in_PREDICT_BTB_LAST_TAKE          ," in_PREDICT_BTB_LAST_TAKE          ",Tcontrol_t         ,_param->_nb_inst_predict);
     59  ALLOC1_SC_SIGNAL( in_PREDICT_BTB_IS_ACCURATE        ," in_PREDICT_BTB_IS_ACCURATE        ",Tcontrol_t         ,_param->_nb_inst_predict);
     60  ALLOC1_SC_SIGNAL( in_PREDICT_DIR_HISTORY            ," in_PREDICT_DIR_HISTORY            ",Thistory_t         ,_param->_nb_inst_predict);
     61  ALLOC1_SC_SIGNAL( in_PREDICT_RAS_ADDRESS            ," in_PREDICT_RAS_ADDRESS            ",Taddress_t         ,_param->_nb_inst_predict);
     62  ALLOC1_SC_SIGNAL( in_PREDICT_RAS_INDEX              ," in_PREDICT_RAS_INDEX              ",Tptr_t             ,_param->_nb_inst_predict);
     63//ALLOC1_SC_SIGNAL(out_PREDICT_UPDATE_PREDICTION_ID   ,"out_PREDICT_UPDATE_PREDICTION_ID   ",Tprediction_ptr_t  ,_param->_nb_inst_predict);
     64  ALLOC1_SC_SIGNAL( in_DECOD_VAL                      ," in_DECOD_VAL                      ",Tcontrol_t         ,_param->_nb_inst_decod);
     65  ALLOC1_SC_SIGNAL(out_DECOD_ACK                      ,"out_DECOD_ACK                      ",Tcontrol_t         ,_param->_nb_inst_decod);
     66  ALLOC1_SC_SIGNAL( in_DECOD_CONTEXT_ID               ," in_DECOD_CONTEXT_ID               ",Tcontext_t         ,_param->_nb_inst_decod);
     67  ALLOC1_SC_SIGNAL( in_DECOD_BTB_ADDRESS_SRC          ," in_DECOD_BTB_ADDRESS_SRC          ",Taddress_t         ,_param->_nb_inst_decod);
     68  ALLOC1_SC_SIGNAL( in_DECOD_BTB_ADDRESS_DEST         ," in_DECOD_BTB_ADDRESS_DEST         ",Taddress_t         ,_param->_nb_inst_decod);
     69  ALLOC1_SC_SIGNAL( in_DECOD_BTB_CONDITION            ," in_DECOD_BTB_CONDITION            ",Tbranch_condition_t,_param->_nb_inst_decod);
     70  ALLOC1_SC_SIGNAL( in_DECOD_BTB_LAST_TAKE            ," in_DECOD_BTB_LAST_TAKE            ",Tcontrol_t         ,_param->_nb_inst_decod);
     71  ALLOC1_SC_SIGNAL( in_DECOD_RAS_ADDRESS              ," in_DECOD_RAS_ADDRESS              ",Taddress_t         ,_param->_nb_inst_decod);
     72  ALLOC1_SC_SIGNAL( in_DECOD_RAS_INDEX                ," in_DECOD_RAS_INDEX                ",Tptr_t             ,_param->_nb_inst_decod);
     73  ALLOC1_SC_SIGNAL( in_DECOD_MISS_PREDICTION          ," in_DECOD_MISS_PREDICTION          ",Tcontrol_t         ,_param->_nb_inst_decod);
     74  ALLOC1_SC_SIGNAL( in_DECOD_UPDATE_PREDICTION_ID     ," in_DECOD_UPDATE_PREDICTION_ID     ",Tprediction_ptr_t  ,_param->_nb_inst_decod);
     75//ALLOC1_SC_SIGNAL(out_DECOD_DEPTH                    ,"out_DECOD_DEPTH                    ",Tdepth_t           ,_param->_nb_inst_decod);
     76  ALLOC1_SC_SIGNAL( in_BRANCH_COMPLETE_VAL            ," in_BRANCH_COMPLETE_VAL            ",Tcontrol_t         ,_param->_nb_inst_branch_complete);
     77  ALLOC1_SC_SIGNAL(out_BRANCH_COMPLETE_ACK            ,"out_BRANCH_COMPLETE_ACK            ",Tcontrol_t         ,_param->_nb_inst_branch_complete);
     78  ALLOC1_SC_SIGNAL( in_BRANCH_COMPLETE_CONTEXT_ID     ," in_BRANCH_COMPLETE_CONTEXT_ID     ",Tcontext_t         ,_param->_nb_inst_branch_complete);
     79  ALLOC1_SC_SIGNAL( in_BRANCH_COMPLETE_DEPTH          ," in_BRANCH_COMPLETE_DEPTH          ",Tdepth_t           ,_param->_nb_inst_branch_complete);
     80  ALLOC1_SC_SIGNAL( in_BRANCH_COMPLETE_ADDRESS        ," in_BRANCH_COMPLETE_ADDRESS        ",Taddress_t         ,_param->_nb_inst_branch_complete);
     81  ALLOC1_SC_SIGNAL( in_BRANCH_COMPLETE_FLAG           ," in_BRANCH_COMPLETE_FLAG           ",Tcontrol_t         ,_param->_nb_inst_branch_complete);
     82  ALLOC1_SC_SIGNAL(out_BRANCH_COMPLETE_MISS_PREDICTION,"out_BRANCH_COMPLETE_MISS_PREDICTION",Tcontrol_t         ,_param->_nb_inst_branch_complete);
     83  ALLOC1_SC_SIGNAL(out_BRANCH_COMPLETE_TAKE           ,"out_BRANCH_COMPLETE_TAKE           ",Tcontrol_t         ,_param->_nb_inst_branch_complete);
     84  ALLOC1_SC_SIGNAL(out_BRANCH_COMPLETE_ADDRESS_SRC    ,"out_BRANCH_COMPLETE_ADDRESS_SRC    ",Taddress_t         ,_param->_nb_inst_branch_complete);
     85  ALLOC1_SC_SIGNAL(out_BRANCH_COMPLETE_ADDRESS_DEST   ,"out_BRANCH_COMPLETE_ADDRESS_DEST   ",Taddress_t         ,_param->_nb_inst_branch_complete);
     86  ALLOC1_SC_SIGNAL(out_UPDATE_VAL                     ,"out_UPDATE_VAL                     ",Tcontrol_t         ,_param->_nb_inst_update);
     87  ALLOC1_SC_SIGNAL( in_UPDATE_ACK                     ," in_UPDATE_ACK                     ",Tcontrol_t         ,_param->_nb_inst_update);
     88  ALLOC1_SC_SIGNAL(out_UPDATE_CONTEXT_ID              ,"out_UPDATE_CONTEXT_ID              ",Tcontext_t         ,_param->_nb_inst_update);
     89  ALLOC1_SC_SIGNAL(out_UPDATE_MISS_PREDICTION         ,"out_UPDATE_MISS_PREDICTION         ",Tcontrol_t         ,_param->_nb_inst_update);
     90  ALLOC1_SC_SIGNAL(out_UPDATE_DIRECTION_GOOD          ,"out_UPDATE_DIRECTION_GOOD          ",Tcontrol_t         ,_param->_nb_inst_update);
     91  ALLOC1_SC_SIGNAL(out_UPDATE_BTB_VAL                 ,"out_UPDATE_BTB_VAL                 ",Tcontrol_t         ,_param->_nb_inst_update);
     92  ALLOC1_SC_SIGNAL(out_UPDATE_BTB_ADDRESS_SRC         ,"out_UPDATE_BTB_ADDRESS_SRC         ",Taddress_t         ,_param->_nb_inst_update);
     93  ALLOC1_SC_SIGNAL(out_UPDATE_BTB_ADDRESS_DEST        ,"out_UPDATE_BTB_ADDRESS_DEST        ",Taddress_t         ,_param->_nb_inst_update);
     94  ALLOC1_SC_SIGNAL(out_UPDATE_BTB_CONDITION           ,"out_UPDATE_BTB_CONDITION           ",Tbranch_condition_t,_param->_nb_inst_update);
     95  ALLOC1_SC_SIGNAL(out_UPDATE_DIR_VAL                 ,"out_UPDATE_DIR_VAL                 ",Tcontrol_t         ,_param->_nb_inst_update);
     96  ALLOC1_SC_SIGNAL(out_UPDATE_DIR_HISTORY             ,"out_UPDATE_DIR_HISTORY             ",Thistory_t         ,_param->_nb_inst_update);
     97  ALLOC1_SC_SIGNAL(out_UPDATE_RAS_VAL                 ,"out_UPDATE_RAS_VAL                 ",Tcontrol_t         ,_param->_nb_inst_update);
     98  ALLOC1_SC_SIGNAL(out_UPDATE_RAS_ADDRESS             ,"out_UPDATE_RAS_ADDRESS             ",Taddress_t         ,_param->_nb_inst_update);
     99  ALLOC1_SC_SIGNAL(out_UPDATE_RAS_INDEX               ,"out_UPDATE_RAS_INDEX               ",Tptr_t             ,_param->_nb_inst_update);
     100  ALLOC1_SC_SIGNAL(out_UPDATE_RAS_PREDICTION_IFETCH   ,"out_UPDATE_RAS_PREDICTION_IFETCH   ",Tcontrol_t         ,_param->_nb_inst_update);
     101  ALLOC1_SC_SIGNAL(out_DEPTH_NB_BRANCH                ,"out_DEPTH_NB_BRANCH                ",Tdepth_t           ,_param->_nb_context);
     102  ALLOC1_SC_SIGNAL(out_DEPTH_TAIL                     ,"out_DEPTH_TAIL                     ",Tdepth_t           ,_param->_nb_context);
    67103 
    68104  /********************************************************
     
    75111  (*(_Update_Prediction_Table->in_NRESET))       (*(in_NRESET));
    76112
     113  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_PREDICT_VAL                    ,_param->_nb_inst_predict);
     114  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_PREDICT_ACK                    ,_param->_nb_inst_predict);
     115  if (_param->_have_port_context_id)
     116  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_PREDICT_CONTEXT_ID             ,_param->_nb_inst_predict);
     117  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_PREDICT_BTB_ADDRESS_SRC        ,_param->_nb_inst_predict);
     118  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_PREDICT_BTB_ADDRESS_DEST       ,_param->_nb_inst_predict);
     119  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_PREDICT_BTB_CONDITION          ,_param->_nb_inst_predict);
     120  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_PREDICT_BTB_LAST_TAKE          ,_param->_nb_inst_predict);
     121  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_PREDICT_BTB_IS_ACCURATE        ,_param->_nb_inst_predict);
     122  if (_param->_have_port_history)
     123  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_PREDICT_DIR_HISTORY            ,_param->_nb_inst_predict);
     124  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_PREDICT_RAS_ADDRESS            ,_param->_nb_inst_predict);
     125  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_PREDICT_RAS_INDEX              ,_param->_nb_inst_predict);
     126//if (_param->_have_port_depth)
     127//INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_PREDICT_UPDATE_PREDICTION_ID   ,_param->_nb_inst_predict);
     128  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_DECOD_VAL                      ,_param->_nb_inst_decod);
     129  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_DECOD_ACK                      ,_param->_nb_inst_decod);
     130  if (_param->_have_port_context_id)
     131  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_DECOD_CONTEXT_ID               ,_param->_nb_inst_decod);
     132  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_DECOD_BTB_ADDRESS_SRC          ,_param->_nb_inst_decod);
     133  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_DECOD_BTB_ADDRESS_DEST         ,_param->_nb_inst_decod);
     134  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_DECOD_BTB_CONDITION            ,_param->_nb_inst_decod);
     135  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_DECOD_BTB_LAST_TAKE            ,_param->_nb_inst_decod);
     136  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_DECOD_RAS_ADDRESS              ,_param->_nb_inst_decod);
     137  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_DECOD_RAS_INDEX                ,_param->_nb_inst_decod);
     138  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_DECOD_MISS_PREDICTION          ,_param->_nb_inst_decod);
     139  if (_param->_have_port_depth)
     140  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_DECOD_UPDATE_PREDICTION_ID     ,_param->_nb_inst_decod);
     141//if (_param->_have_port_depth)
     142//INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_DECOD_DEPTH                    ,_param->_nb_inst_decod);
     143  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_BRANCH_COMPLETE_VAL            ,_param->_nb_inst_branch_complete);
     144  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_BRANCH_COMPLETE_ACK            ,_param->_nb_inst_branch_complete);
     145  if (_param->_have_port_context_id)
     146  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_BRANCH_COMPLETE_CONTEXT_ID     ,_param->_nb_inst_branch_complete);
     147  if (_param->_have_port_depth)
     148  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_BRANCH_COMPLETE_DEPTH          ,_param->_nb_inst_branch_complete);
     149  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_BRANCH_COMPLETE_ADDRESS        ,_param->_nb_inst_branch_complete);
     150  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_BRANCH_COMPLETE_FLAG           ,_param->_nb_inst_branch_complete);
     151  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_BRANCH_COMPLETE_MISS_PREDICTION,_param->_nb_inst_branch_complete);
     152  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_BRANCH_COMPLETE_TAKE           ,_param->_nb_inst_branch_complete);
     153  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_BRANCH_COMPLETE_ADDRESS_SRC    ,_param->_nb_inst_branch_complete);
     154  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_BRANCH_COMPLETE_ADDRESS_DEST   ,_param->_nb_inst_branch_complete);
     155  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_UPDATE_VAL                     ,_param->_nb_inst_update);
     156  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_UPDATE_ACK                     ,_param->_nb_inst_update);
     157  if (_param->_have_port_context_id)
     158  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_UPDATE_CONTEXT_ID              ,_param->_nb_inst_update);
     159  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_UPDATE_MISS_PREDICTION         ,_param->_nb_inst_update);
     160  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_UPDATE_DIRECTION_GOOD          ,_param->_nb_inst_update);
     161  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_UPDATE_BTB_VAL                 ,_param->_nb_inst_update);
     162  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_UPDATE_BTB_ADDRESS_SRC         ,_param->_nb_inst_update);
     163  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_UPDATE_BTB_ADDRESS_DEST        ,_param->_nb_inst_update);
     164  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_UPDATE_BTB_CONDITION           ,_param->_nb_inst_update);
     165  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_UPDATE_DIR_VAL                 ,_param->_nb_inst_update);
     166  if (_param->_have_port_history)
     167  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_UPDATE_DIR_HISTORY             ,_param->_nb_inst_update);
     168  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_UPDATE_RAS_VAL                 ,_param->_nb_inst_update);
     169  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_UPDATE_RAS_ADDRESS             ,_param->_nb_inst_update);
     170  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_UPDATE_RAS_INDEX               ,_param->_nb_inst_update);
     171  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_UPDATE_RAS_PREDICTION_IFETCH   ,_param->_nb_inst_update);
     172  if (_param->_have_port_depth)
     173  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_DEPTH_NB_BRANCH                ,_param->_nb_context);
     174  if (_param->_have_port_depth)
     175  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_DEPTH_TAIL                     ,_param->_nb_context);
    77176
    78177  msg(_("<%s> : Start Simulation ............\n"),name.c_str());
     
    90189
    91190  srand(seed);
     191
     192  const  int32_t percent_transaction_predict         = 75;
     193  const  int32_t percent_transaction_decod           = 75;
     194  const  int32_t percent_transaction_branch_complete = 75;
     195  const  int32_t percent_transaction_update          = 75;
    92196
    93197  SC_START(0);
     
    104208    {
    105209      LABEL("Iteration %d",iteration);
    106 
     210     
     211      {
     212        uint32_t context = rand() % _param->_nb_context;
     213       
     214//      LABEL("KANE : %d",context);
     215
     216        LABEL("PREDICT - fill the queue");
     217       
     218        {
     219          uint32_t port = rand() % _param->_nb_inst_predict;
     220         
     221          for (uint32_t i=0; i<_param->_size_queue[context]; i++)
     222            {
     223             
     224              bool find = false;
     225              do
     226                {
     227                  in_PREDICT_VAL              [port]->write((rand()%100)<percent_transaction_predict);
     228                  in_PREDICT_CONTEXT_ID       [port]->write(context);
     229                  in_PREDICT_BTB_ADDRESS_SRC  [port]->write(0xdeadbeef+i);
     230                  in_PREDICT_BTB_ADDRESS_DEST [port]->write(0x21071981+i);
     231                  in_PREDICT_BTB_CONDITION    [port]->write(BRANCH_CONDITION_FLAG_SET);
     232                  in_PREDICT_BTB_LAST_TAKE    [port]->write(1);
     233                  in_PREDICT_BTB_IS_ACCURATE  [port]->write((rand()%100)<percent_transaction_predict);
     234                  in_PREDICT_DIR_HISTORY      [port]->write(i);
     235                  in_PREDICT_RAS_ADDRESS      [port]->write(0xdeaddead+i);
     236                  in_PREDICT_RAS_INDEX        [port]->write((0x12345678+i)%_param->_size_ras_index[context]);
     237                 
     238                  if (_param->_have_port_depth)
     239                    {
     240                      TEST(Tdepth_t,out_DEPTH_TAIL     [context]->read(), 0);
     241                      TEST(Tdepth_t,out_DEPTH_NB_BRANCH[context]->read(), i);
     242                    }
     243                  SC_START(0);
     244                 
     245                  LABEL("PREDICT         [%d] %d - %d (accurate : %d).",port,in_PREDICT_VAL [port]->read(),out_PREDICT_ACK [port]->read(), in_PREDICT_BTB_IS_ACCURATE [port]->read());
     246                 
     247                  if (in_PREDICT_VAL [port]->read() and out_PREDICT_ACK [port]->read())
     248                    {
     249                      LABEL("PREDICT         [%d] - Transaction accepted",port);
     250                      find = true;
     251                    }
     252                 
     253                  SC_START(1);
     254                 
     255                } while (not find);
     256              in_PREDICT_VAL              [port]->write(0);
     257             
     258              if (_param->_have_port_depth)
     259                {
     260                  TEST(Tdepth_t,out_DEPTH_TAIL     [context]->read(), 0);
     261                  TEST(Tdepth_t,out_DEPTH_NB_BRANCH[context]->read(), i+1);
     262                }
     263            }
     264        }
     265       
     266        LABEL("DECOD - hit ifetch");
     267       
     268        {
     269          uint32_t port = rand() % _param->_nb_inst_decod;
     270         
     271          for (uint32_t i=0; i<_param->_size_queue[context]; i++)
     272            {
     273             
     274              bool find = false;
     275              do
     276                {
     277                  in_DECOD_VAL                  [port]->write((rand()%100)<percent_transaction_decod);
     278                  in_DECOD_CONTEXT_ID           [port]->write(context);
     279                  in_DECOD_BTB_ADDRESS_SRC      [port]->write(0xdeadbeef+i);
     280                  in_DECOD_BTB_ADDRESS_DEST     [port]->write(0x21071981+i);
     281                  in_DECOD_BTB_CONDITION        [port]->write(BRANCH_CONDITION_FLAG_SET);
     282                  in_DECOD_BTB_LAST_TAKE        [port]->write(1);
     283                  in_DECOD_RAS_ADDRESS          [port]->write(0xdeaddead+i);
     284                  in_DECOD_RAS_INDEX            [port]->write((0x12345678+i)%_param->_size_ras_index[context]);
     285                  in_DECOD_MISS_PREDICTION      [port]->write(false);
     286                  in_DECOD_UPDATE_PREDICTION_ID [port]->write(i);
     287                 
     288                  if (_param->_have_port_depth)
     289                    {
     290                      TEST(Tdepth_t,out_DEPTH_TAIL     [context]->read(), 0);
     291                      TEST(Tdepth_t,out_DEPTH_NB_BRANCH[context]->read(), _param->_size_queue[context]);
     292                    }
     293                 
     294                  SC_START(0);
     295                 
     296                  LABEL("DECOD           [%d] %d - %d.",port,in_DECOD_VAL [port]->read(),out_DECOD_ACK [port]->read());
     297                 
     298                  if (in_DECOD_VAL [port]->read() and out_DECOD_ACK [port]->read())
     299                    {
     300                      LABEL("DECOD           [%d] - Transaction accepted",port);
     301                      find = true;
     302                    }
     303                 
     304                  SC_START(1);
     305                 
     306                } while (not find);
     307              in_DECOD_VAL              [port]->write(0);
     308             
     309              if (_param->_have_port_depth)
     310                {
     311                  TEST(Tdepth_t,out_DEPTH_TAIL     [context]->read(), 0);
     312                  TEST(Tdepth_t,out_DEPTH_NB_BRANCH[context]->read(), _param->_size_queue[context]);
     313                }
     314            }
     315        }
     316       
     317        LABEL("BRANCH_COMPLETE - hit ifetch");
     318       
     319        {
     320          uint32_t port = rand() % _param->_nb_inst_branch_complete;
     321         
     322          for (uint32_t i=0; i<_param->_size_queue[context]; i++)
     323            {
     324              bool find = false;
     325              do
     326                {
     327                  in_BRANCH_COMPLETE_VAL                  [port]->write((rand()%100)<percent_transaction_branch_complete);
     328                  in_BRANCH_COMPLETE_CONTEXT_ID           [port]->write(context);
     329                  in_BRANCH_COMPLETE_DEPTH                [port]->write(i);
     330                  in_BRANCH_COMPLETE_ADDRESS              [port]->write(0xcacacaca+i);
     331                  in_BRANCH_COMPLETE_FLAG                 [port]->write(1);
     332                 
     333                  if (_param->_have_port_depth)
     334                    {
     335                      TEST(Tdepth_t,out_DEPTH_TAIL     [context]->read(), 0);
     336                      TEST(Tdepth_t,out_DEPTH_NB_BRANCH[context]->read(), _param->_size_queue[context]);
     337                    }
     338                 
     339                  SC_START(0);
     340                 
     341                  LABEL("BRANCH_COMPLETE [%d] %d - %d.",port,in_BRANCH_COMPLETE_VAL [port]->read(),out_BRANCH_COMPLETE_ACK [port]->read());
     342                 
     343                  if (in_BRANCH_COMPLETE_VAL [port]->read() and out_BRANCH_COMPLETE_ACK [port]->read())
     344                    {
     345                      LABEL("BRANCH_COMPLETE [%d] - Transaction accepted",port);
     346                      find = true;
     347                     
     348                      TEST(Tcontrol_t,out_BRANCH_COMPLETE_MISS_PREDICTION[port]->read(),0);
     349                      TEST(Tcontrol_t,out_BRANCH_COMPLETE_TAKE           [port]->read(),1);
     350                      TEST(Taddress_t,out_BRANCH_COMPLETE_ADDRESS_SRC    [port]->read(),0xdeadbeef+i);
     351                      TEST(Taddress_t,out_BRANCH_COMPLETE_ADDRESS_DEST   [port]->read(),0x21071981+i);
     352                    }
     353                 
     354                  SC_START(1);
     355
     356                } while (not find);
     357              in_BRANCH_COMPLETE_VAL              [port]->write(0);
     358             
     359              if (_param->_have_port_depth)
     360                {
     361                  TEST(Tdepth_t,out_DEPTH_TAIL     [context]->read(), 0);
     362                  TEST(Tdepth_t,out_DEPTH_NB_BRANCH[context]->read(), _param->_size_queue[context]);
     363                }
     364            }
     365        }
     366       
     367        LABEL("UPDATE - hit ifetch");
     368       
     369        {
     370          uint32_t port = 0; //rand() % _param->_nb_inst_update;
     371         
     372          for (uint32_t i=0; i<_param->_size_queue[context]; i++)
     373            {
     374              bool find = false;
     375              do
     376                {
     377                  in_UPDATE_ACK [port]->write((rand()%100)<percent_transaction_update);
     378                 
     379                  SC_START(0);
     380                 
     381                  if (out_UPDATE_VAL [port]->read() and in_UPDATE_ACK [port]->read())
     382                    {
     383                      LABEL("UPDATE [%d] - Transaction accepted",port);
     384                     
     385                      find = true;
     386                     
     387                      TEST(Tcontext_t         ,out_UPDATE_CONTEXT_ID            [port]->read(), context);
     388                      TEST(Tcontrol_t         ,out_UPDATE_MISS_PREDICTION       [port]->read(), 0);
     389                      TEST(Tcontrol_t         ,out_UPDATE_DIRECTION_GOOD        [port]->read(), 1);
     390                      TEST(Tcontrol_t         ,out_UPDATE_BTB_VAL               [port]->read(), 1);
     391                      TEST(Taddress_t         ,out_UPDATE_BTB_ADDRESS_SRC       [port]->read(), 0xdeadbeef+i);
     392                      TEST(Taddress_t         ,out_UPDATE_BTB_ADDRESS_DEST      [port]->read(), 0x21071981+i);       
     393                      TEST(Tbranch_condition_t,out_UPDATE_BTB_CONDITION         [port]->read(), BRANCH_CONDITION_FLAG_SET);
     394                      TEST(Tcontrol_t         ,out_UPDATE_DIR_VAL               [port]->read(), 1);
     395                      if (_param->_have_port_history)
     396                        TEST(Thistory_t         ,out_UPDATE_DIR_HISTORY           [port]->read(), i);
     397                      TEST(Tcontrol_t         ,out_UPDATE_RAS_VAL               [port]->read(), 0);
     398                      TEST(Taddress_t         ,out_UPDATE_RAS_ADDRESS           [port]->read(), 0xdeaddead+i);
     399                      TEST(Tptr_t             ,out_UPDATE_RAS_INDEX             [port]->read(), (0x12345678+i)%_param->_size_ras_index[context]);
     400                      TEST(Tcontrol_t         ,out_UPDATE_RAS_PREDICTION_IFETCH [port]->read(), 1);
     401                    }
     402                 
     403                  SC_START(1);
     404                 
     405                } while (not find);
     406              in_UPDATE_ACK              [port]->write(0);
     407            }
     408         
     409          LABEL("Wait a moment");
     410          SC_START(2*_param->_size_queue[context]);
     411 
     412          // wait the garbage collector
     413          if (_param->_have_port_depth)
     414            while ((out_DEPTH_TAIL     [context]->read() != 0) and
     415                   (out_DEPTH_NB_BRANCH[context]->read() != 0))
     416              {
     417                LABEL("DEPTH [%d] nb_branch : %d - tail : %d",context,out_DEPTH_NB_BRANCH[context]->read(), out_DEPTH_TAIL [context]->read());
     418                SC_START(1);
     419              }
     420        }
     421      }
     422
     423      {
     424        uint32_t context = rand() % _param->_nb_context;
     425       
     426//      LABEL("KANE : %d",context);
     427
     428        LABEL("PREDICT - fill the queue");
     429       
     430        {
     431          uint32_t port = rand() % _param->_nb_inst_predict;
     432         
     433          for (uint32_t i=0; i<_param->_size_queue[context]; i++)
     434            {
     435             
     436              bool find = false;
     437              do
     438                {
     439                  in_PREDICT_VAL              [port]->write((rand()%100)<percent_transaction_predict);
     440                  in_PREDICT_CONTEXT_ID       [port]->write(context);
     441                  in_PREDICT_BTB_ADDRESS_SRC  [port]->write(0xdeadbeef+i);
     442                  in_PREDICT_BTB_ADDRESS_DEST [port]->write(0x21071981+i);
     443                  in_PREDICT_BTB_CONDITION    [port]->write(BRANCH_CONDITION_FLAG_SET);
     444                  in_PREDICT_BTB_LAST_TAKE    [port]->write(1);
     445                  in_PREDICT_BTB_IS_ACCURATE  [port]->write((rand()%100)<percent_transaction_predict);
     446                  in_PREDICT_DIR_HISTORY      [port]->write(i);
     447                  in_PREDICT_RAS_ADDRESS      [port]->write(0xdeaddead+i);
     448                  in_PREDICT_RAS_INDEX        [port]->write((0x12345678+i)%_param->_size_ras_index[context]);
     449                 
     450                  if (_param->_have_port_depth)
     451                    {
     452                      TEST(Tdepth_t,out_DEPTH_TAIL     [context]->read(), 0);
     453                      TEST(Tdepth_t,out_DEPTH_NB_BRANCH[context]->read(), i);
     454                    }
     455                  SC_START(0);
     456                 
     457                  LABEL("PREDICT         [%d] %d - %d (accurate : %d).",port,in_PREDICT_VAL [port]->read(),out_PREDICT_ACK [port]->read(), in_PREDICT_BTB_IS_ACCURATE [port]->read());
     458                 
     459                  if (in_PREDICT_VAL [port]->read() and out_PREDICT_ACK [port]->read())
     460                    {
     461                      LABEL("PREDICT         [%d] - Transaction accepted",port);
     462                      find = true;
     463                    }
     464                 
     465                  SC_START(1);
     466                 
     467                } while (not find);
     468              in_PREDICT_VAL              [port]->write(0);
     469             
     470              if (_param->_have_port_depth)
     471                {
     472                  TEST(Tdepth_t,out_DEPTH_TAIL     [context]->read(), 0);
     473                  TEST(Tdepth_t,out_DEPTH_NB_BRANCH[context]->read(), i+1);
     474                }
     475            }
     476        }
     477       
     478        LABEL("DECOD - hit ifetch");
     479       
     480        {
     481          uint32_t port = rand() % _param->_nb_inst_decod;
     482         
     483          for (uint32_t i=0; i<_param->_size_queue[context]; i++)
     484            {
     485             
     486              bool find = false;
     487              do
     488                {
     489                  in_DECOD_VAL                  [port]->write((rand()%100)<percent_transaction_decod);
     490                  in_DECOD_CONTEXT_ID           [port]->write(context);
     491                  in_DECOD_BTB_ADDRESS_SRC      [port]->write(0xdeadbeef+i);
     492                  in_DECOD_BTB_ADDRESS_DEST     [port]->write(0x21071981+i);
     493                  in_DECOD_BTB_CONDITION        [port]->write(BRANCH_CONDITION_FLAG_SET);
     494                  in_DECOD_BTB_LAST_TAKE        [port]->write(1);
     495                  in_DECOD_RAS_ADDRESS          [port]->write(0xdeaddead+i);
     496                  in_DECOD_RAS_INDEX            [port]->write((0x12345678+i)%_param->_size_ras_index[context]);
     497                  in_DECOD_MISS_PREDICTION      [port]->write(false);
     498                  in_DECOD_UPDATE_PREDICTION_ID [port]->write(i);
     499                 
     500                  if (_param->_have_port_depth)
     501                    {
     502                      TEST(Tdepth_t,out_DEPTH_TAIL     [context]->read(), 0);
     503                      TEST(Tdepth_t,out_DEPTH_NB_BRANCH[context]->read(), _param->_size_queue[context]);
     504                    }
     505                 
     506                  SC_START(0);
     507                 
     508                  LABEL("DECOD           [%d] %d - %d.",port,in_DECOD_VAL [port]->read(),out_DECOD_ACK [port]->read());
     509                 
     510                  if (in_DECOD_VAL [port]->read() and out_DECOD_ACK [port]->read())
     511                    {
     512                      LABEL("DECOD           [%d] - Transaction accepted",port);
     513                      find = true;
     514                    }
     515                 
     516                  SC_START(1);
     517                 
     518                } while (not find);
     519              in_DECOD_VAL              [port]->write(0);
     520             
     521              if (_param->_have_port_depth)
     522                {
     523                  TEST(Tdepth_t,out_DEPTH_TAIL     [context]->read(), 0);
     524                  TEST(Tdepth_t,out_DEPTH_NB_BRANCH[context]->read(), _param->_size_queue[context]);
     525                }
     526            }
     527        }
     528       
     529        LABEL("BRANCH_COMPLETE - hit ifetch");
     530       
     531        {
     532          uint32_t port = rand() % _param->_nb_inst_branch_complete;
     533         
     534            {
     535              uint32_t i=0;
     536              bool find = false;
     537              do
     538                {
     539                  in_BRANCH_COMPLETE_VAL                  [port]->write((rand()%100)<percent_transaction_branch_complete);
     540                  in_BRANCH_COMPLETE_CONTEXT_ID           [port]->write(context);
     541                  in_BRANCH_COMPLETE_DEPTH                [port]->write(i);
     542                  in_BRANCH_COMPLETE_ADDRESS              [port]->write(0xcacacaca+i);
     543                  in_BRANCH_COMPLETE_FLAG                 [port]->write(0);
     544                 
     545                  if (_param->_have_port_depth)
     546                    {
     547                      TEST(Tdepth_t,out_DEPTH_TAIL     [context]->read(), 0);
     548                      TEST(Tdepth_t,out_DEPTH_NB_BRANCH[context]->read(), _param->_size_queue[context]);
     549                    }
     550                 
     551                  SC_START(0);
     552                 
     553                  LABEL("BRANCH_COMPLETE [%d] %d - %d.",port,in_BRANCH_COMPLETE_VAL [port]->read(),out_BRANCH_COMPLETE_ACK [port]->read());
     554                 
     555                  if (in_BRANCH_COMPLETE_VAL [port]->read() and out_BRANCH_COMPLETE_ACK [port]->read())
     556                    {
     557                      LABEL("BRANCH_COMPLETE [%d] - Transaction accepted",port);
     558                      find = true;
     559                     
     560                      TEST(Tcontrol_t,out_BRANCH_COMPLETE_MISS_PREDICTION[port]->read(),1);
     561                      TEST(Tcontrol_t,out_BRANCH_COMPLETE_TAKE           [port]->read(),0);
     562                      TEST(Taddress_t,out_BRANCH_COMPLETE_ADDRESS_SRC    [port]->read(),0xdeadbeef+i);
     563                      TEST(Taddress_t,out_BRANCH_COMPLETE_ADDRESS_DEST   [port]->read(),0x21071981+i);
     564                    }
     565                 
     566                  SC_START(1);
     567
     568                } while (not find);
     569              in_BRANCH_COMPLETE_VAL              [port]->write(0);
     570            }
     571        }
     572       
     573        LABEL("UPDATE - miss ifetch");
     574       
     575        {
     576          uint32_t port = 0; //rand() % _param->_nb_inst_update;
     577         
     578//        for (uint32_t i=0; i<_param->_size_queue[context]; i++)
     579            {
     580              uint32_t i=0;
     581
     582              bool find = false;
     583              do
     584                {
     585                  in_UPDATE_ACK [port]->write((rand()%100)<percent_transaction_update);
     586                 
     587                  SC_START(0);
     588                 
     589                  if (out_UPDATE_VAL [port]->read() and in_UPDATE_ACK [port]->read())
     590                    {
     591                      LABEL("UPDATE [%d] - Transaction accepted",port);
     592                     
     593                      find = true;
     594                     
     595                      TEST(Tcontext_t         ,out_UPDATE_CONTEXT_ID            [port]->read(), context);
     596                      TEST(Tcontrol_t         ,out_UPDATE_MISS_PREDICTION       [port]->read(), 1);
     597                      TEST(Tcontrol_t         ,out_UPDATE_DIRECTION_GOOD        [port]->read(), 0);
     598                      TEST(Tcontrol_t         ,out_UPDATE_BTB_VAL               [port]->read(), 1);
     599                      TEST(Taddress_t         ,out_UPDATE_BTB_ADDRESS_SRC       [port]->read(), 0xdeadbeef+i);
     600                      TEST(Taddress_t         ,out_UPDATE_BTB_ADDRESS_DEST      [port]->read(), 0x21071981+i);       
     601                      TEST(Tbranch_condition_t,out_UPDATE_BTB_CONDITION         [port]->read(), BRANCH_CONDITION_FLAG_SET);
     602                      TEST(Tcontrol_t         ,out_UPDATE_DIR_VAL               [port]->read(), 1);
     603                      if (_param->_have_port_history)
     604                        TEST(Thistory_t         ,out_UPDATE_DIR_HISTORY           [port]->read(), i);
     605                      TEST(Tcontrol_t         ,out_UPDATE_RAS_VAL               [port]->read(), 0);
     606                      TEST(Taddress_t         ,out_UPDATE_RAS_ADDRESS           [port]->read(), 0xdeaddead+i);
     607                      TEST(Tptr_t             ,out_UPDATE_RAS_INDEX             [port]->read(), (0x12345678+i)%_param->_size_ras_index[context]);
     608                      TEST(Tcontrol_t         ,out_UPDATE_RAS_PREDICTION_IFETCH [port]->read(), 1);
     609                    }
     610                 
     611                  SC_START(1);
     612                 
     613                } while (not find);
     614              in_UPDATE_ACK              [port]->write(0);
     615            }
     616           
     617            LABEL("Wait a moment");
     618            SC_START(_param->_size_queue[context]);
     619           
     620            // wait the garbage collector
     621            if (_param->_have_port_depth)
     622              while ((out_DEPTH_TAIL     [context]->read() != 0) and
     623                     (out_DEPTH_NB_BRANCH[context]->read() != 0))
     624                {
     625                  LABEL("DEPTH [%d] nb_branch : %d - tail : %d",context,out_DEPTH_NB_BRANCH[context]->read(), out_DEPTH_TAIL [context]->read());
     626                  SC_START(1);
     627                }
     628        }
     629      }
     630
     631      LABEL ("Yo1");
    107632      SC_START(1);
     633      LABEL ("Yo2");
     634
    108635    }
    109636
     
    119646  delete in_CLOCK;
    120647  delete in_NRESET;
     648
     649  // ~~~~~[ Interface : "predict" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     650  delete []  in_PREDICT_VAL                 ;
     651  delete [] out_PREDICT_ACK                 ;
     652  delete []  in_PREDICT_CONTEXT_ID          ;
     653  delete []  in_PREDICT_BTB_ADDRESS_SRC     ;
     654  delete []  in_PREDICT_BTB_ADDRESS_DEST    ;
     655  delete []  in_PREDICT_BTB_CONDITION       ;
     656  delete []  in_PREDICT_BTB_LAST_TAKE       ;
     657  delete []  in_PREDICT_BTB_IS_ACCURATE     ;
     658  delete []  in_PREDICT_DIR_HISTORY         ;
     659  delete []  in_PREDICT_RAS_ADDRESS         ;
     660  delete []  in_PREDICT_RAS_INDEX           ;
     661//delete [] out_PREDICT_UPDATE_PREDICTION_ID;
     662 
     663  // ~~~~~[ Interface : "decod" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     664  delete []  in_DECOD_VAL                   ;
     665  delete [] out_DECOD_ACK                   ;
     666  delete []  in_DECOD_CONTEXT_ID            ;
     667  delete []  in_DECOD_BTB_ADDRESS_SRC       ;
     668  delete []  in_DECOD_BTB_ADDRESS_DEST      ;
     669  delete []  in_DECOD_BTB_CONDITION         ;
     670  delete []  in_DECOD_BTB_LAST_TAKE         ;
     671  delete []  in_DECOD_RAS_ADDRESS           ;
     672  delete []  in_DECOD_RAS_INDEX             ;
     673  delete []  in_DECOD_MISS_PREDICTION       ;
     674  delete []  in_DECOD_UPDATE_PREDICTION_ID  ;
     675//delete [] out_DECOD_DEPTH                 ;
     676 
     677  // ~~~~~[ Interface : "branch_complete" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     678  delete []  in_BRANCH_COMPLETE_VAL            ;
     679  delete [] out_BRANCH_COMPLETE_ACK            ;
     680  delete []  in_BRANCH_COMPLETE_CONTEXT_ID     ;
     681  delete []  in_BRANCH_COMPLETE_DEPTH          ;
     682  delete []  in_BRANCH_COMPLETE_ADDRESS        ;
     683  delete []  in_BRANCH_COMPLETE_FLAG           ;
     684  delete [] out_BRANCH_COMPLETE_MISS_PREDICTION;
     685  delete [] out_BRANCH_COMPLETE_TAKE           ;
     686  delete [] out_BRANCH_COMPLETE_ADDRESS_SRC    ;
     687  delete [] out_BRANCH_COMPLETE_ADDRESS_DEST   ;
     688 
     689  // ~~~~~[ Interface : "update" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     690  delete [] out_UPDATE_VAL                  ;
     691  delete []  in_UPDATE_ACK                  ;
     692  delete [] out_UPDATE_CONTEXT_ID           ;
     693  delete [] out_UPDATE_MISS_PREDICTION      ;
     694  delete [] out_UPDATE_DIRECTION_GOOD       ;
     695  delete [] out_UPDATE_BTB_VAL              ;
     696  delete [] out_UPDATE_BTB_ADDRESS_SRC      ;
     697  delete [] out_UPDATE_BTB_ADDRESS_DEST     ;
     698  delete [] out_UPDATE_BTB_CONDITION        ;
     699  delete [] out_UPDATE_DIR_VAL              ;
     700  delete [] out_UPDATE_DIR_HISTORY          ;
     701  delete [] out_UPDATE_RAS_VAL              ;
     702  delete [] out_UPDATE_RAS_ADDRESS          ;
     703  delete [] out_UPDATE_RAS_INDEX            ;
     704  delete [] out_UPDATE_RAS_PREDICTION_IFETCH;
     705
     706  // ~~~~~[ Interface : "depth" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     707  delete [] out_DEPTH_NB_BRANCH;
     708  delete [] out_DEPTH_TAIL;
     709
    121710#endif
    122711
Note: See TracChangeset for help on using the changeset viewer.