Ignore:
Timestamp:
Feb 19, 2009, 5:31:47 PM (15 years ago)
Author:
rosiere
Message:

1) OOO_egine : add stat to depiste low perf source
2) Commit : add stat
3) LSU_Pointer : retire - always ack (else combinatory loop). insert - max nb_inst_memory
4) TopLevel? : add debug_idle_time to stop combinatory loop.
5) Issue_queue : add reexecute_queue, new implementation (routage after issue_queue)
6) Decod / Predictor : add "can_continue"

Location:
trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine
Files:
2 added
1 deleted
57 edited
2 moved

Legend:

Unmodified
Added
Removed

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/SelfTest/src/main.cpp

    r108 r110  
    77
    88#include "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/SelfTest/include/test.h"
     9#include "Behavioural/include/Allocation.h"
    910
    1011#define NB_PARAMS 16
    … …  
    99100  uint32_t          _nb_rename_unit_select   = fromString<uint32_t         >(argv[x++]);
    100101
     102  uint32_t          _nb_thread                          ;
     103  uint32_t       ** _translate_num_context_to_num_thread; //[nb_front_end][nb_context]
     104
     105  ALLOC2(_translate_num_context_to_num_thread,uint32_t,_nb_front_end,_nb_context[it1]);
     106
     107  _nb_thread = 0;
     108  for (uint32_t i=0; i<_nb_front_end; i++)
     109    for (uint32_t j=0; j<_nb_context [i]; j++)
     110      _translate_num_context_to_num_thread [i][j] = _nb_thread ++;
     111
    101112  int _return = EXIT_SUCCESS;
    102113  try
    … …  
    123134         _load_balancing          ,
    124135         _nb_rename_unit_select   ,
     136         _nb_thread                          ,
     137         _translate_num_context_to_num_thread,
    125138         true // is_toplevel
    126139         );
    … …  
    149162    }
    150163
     164  DELETE2(_translate_num_context_to_num_thread,_nb_front_end,_nb_context[it1]);
     165
    151166  delete [] _nb_context    ;
    152167  delete [] _nb_inst_insert;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/SelfTest/src/test.cpp

    r108 r110  
    99#include "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/SelfTest/include/test.h"
    1010#include "Behavioural/include/Allocation.h"
     11#include "Behavioural/include/Simulation.h"
    1112#include "Common/include/Max.h"
    1213
    … …  
    2728  morpheo::behavioural::Parameters_Statistics * _parameters_statistics = new morpheo::behavioural::Parameters_Statistics (5,CYCLE_MAX);
    2829#endif
     30
     31  simulation_init(0,0);
     32
     33  debug_idle_cycle = CYCLE_MAX;
    2934
    3035  Tusage_t _usage = USE_ALL;
    … …  
    744749
    745750  delete _Commit_unit;
     751 
    746752#ifdef STATISTICS
    747753  delete _parameters_statistics;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/include/Commit_unit.h

    r109 r110  
    5454#ifdef STATISTICS
    5555  public    : Stat                           * _stat;
    56   public    : counter_t                     ** _stat_nb_inst_insert;
    57   public    : counter_t                      * _stat_nb_inst_commit;
     56  public    : counter_t                     ** _stat_nb_inst_insert               ;//[nb_rename_unit]
     57  public    : counter_t                     ** _stat_nb_inst_retire               ;//[nb_rename_unit]
     58  public    : counter_t                      * _stat_nb_inst_commit               ;
    5859  public    : counter_t                      * _stat_nb_inst_commit_conflit_access;
    59   public    : counter_t                     ** _stat_nb_inst_retire_ok;
    60   public    : counter_t                     ** _stat_nb_inst_retire_ko;
    61   public    : counter_t                     ** _stat_bank_nb_inst;// [nb_bank]
     60  public    : counter_t                     ** _stat_nb_inst_retire_ok            ;//[nb_thread]
     61  public    : counter_t                     ** _stat_nb_inst_retire_ko            ;//[nb_thread]
     62  public    : counter_t                     ** _stat_nb_inst_type                 ;//[nb_type]
     63  public    : counter_t                     ** _stat_bank_nb_inst                 ;//[nb_bank]
    6264#endif
    6365
    … …  
    254256  private   : entry_t *                    ** internal_BANK_COMMIT_ENTRY           ;//[nb_bank][nb_bank_access_commit]
    255257
     258  private   : uint32_t                        internal_BANK_RETIRE_HEAD            ;
    256259  private   : Tcontrol_t                    * internal_BANK_RETIRE_VAL             ;//[nb_bank]
    257260  private   : uint32_t                      * internal_BANK_RETIRE_NUM_RENAME_UNIT ;//[nb_bank]

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/include/Parameters.h

    r108 r110  
    2424  {
    2525    //-----[ fields ]------------------------------------------------------------
    26   public : uint32_t            _nb_front_end            ;
    27   public : uint32_t          * _nb_context              ;//[nb_front_end]
    28   public : uint32_t            _nb_rename_unit          ;
    29   public : uint32_t            _size_queue              ;
    30   public : uint32_t            _nb_bank                 ;
    31   public : uint32_t          * _nb_inst_insert          ;//[nb_rename_unit]
    32   public : uint32_t          * _nb_inst_retire          ;//[nb_rename_unit]
    33   public : uint32_t            _nb_inst_commit          ;
    34   public : uint32_t            _nb_inst_reexecute       ;
    35   public : uint32_t            _nb_inst_branch_complete ;
    36   public : uint32_t         ** _nb_branch_speculated    ;//[nb_front_end][nb_context]
    37 //public : uint32_t            _size_general_data       ;
    38 //public : uint32_t            _size_store_queue_ptr    ;
    39 //public : uint32_t            _size_load_queue_ptr     ;
    40 //public : uint32_t            _size_general_register   ;
    41 //public : uint32_t            _size_special_register   ;
    42   public : Tpriority_t         _priority                ;
    43   public : Tload_balancing_t   _load_balancing          ;
    44   public : uint32_t            _nb_rename_unit_select   ;
    45   public : const uint32_t      _nb_bank_access_commit   ;
    46   public : const retire_ooo_t  _retire_ooo              ;
     26  public : uint32_t            _nb_front_end                       ;
     27  public : uint32_t          * _nb_context                         ;//[nb_front_end]
     28  public : uint32_t            _nb_rename_unit                     ;
     29  public : uint32_t            _size_queue                         ;
     30  public : uint32_t            _nb_bank                            ;
     31  public : uint32_t          * _nb_inst_insert                     ;//[nb_rename_unit]
     32  public : uint32_t          * _nb_inst_retire                     ;//[nb_rename_unit]
     33  public : uint32_t            _nb_inst_commit                     ;
     34  public : uint32_t            _nb_inst_reexecute                  ;
     35  public : uint32_t            _nb_inst_branch_complete            ;
     36  public : uint32_t         ** _nb_branch_speculated               ;//[nb_front_end][nb_context]
     37//public : uint32_t            _size_general_data                  ;
     38//public : uint32_t            _size_store_queue_ptr               ;
     39//public : uint32_t            _size_load_queue_ptr                ;
     40//public : uint32_t            _size_general_register              ;
     41//public : uint32_t            _size_special_register              ;
     42  public : Tpriority_t         _priority                           ;
     43  public : Tload_balancing_t   _load_balancing                     ;
     44  public : uint32_t            _nb_rename_unit_select              ;
     45  public : uint32_t            _nb_thread                          ;
     46  public : uint32_t         ** _translate_num_context_to_num_thread; //[nb_front_end][nb_context]
     47  public : const uint32_t      _nb_bank_access_commit              ;
     48  public : const retire_ooo_t  _retire_ooo                         ;
    4749
    4850  public : uint32_t            _max_nb_context          ;
    … …  
    6971//public : bool             ** _have_port_depth         ;//[nb_front_end][nb_context]
    7072
     73  public : bool              * _have_thread             ;//[nb_thread]
     74
    7175    //-----[ methods ]-----------------------------------------------------------
    72   public : Parameters  (uint32_t            nb_front_end            ,
    73                         uint32_t          * nb_context              ,
    74                         uint32_t            nb_rename_unit          ,
    75                         uint32_t            size_queue              ,
    76                         uint32_t            nb_bank                 ,
    77                         uint32_t          * nb_inst_insert          ,
    78                         uint32_t          * nb_inst_retire          ,
    79                         uint32_t            nb_inst_commit          ,
    80                         uint32_t            nb_inst_reexecute       ,
    81                         uint32_t            nb_inst_branch_complete ,
    82                         uint32_t         ** nb_branch_speculated    ,
    83                         uint32_t            size_nb_inst_decod      ,
    84                         uint32_t            size_general_data       ,
    85                         uint32_t            size_store_queue_ptr    ,
    86                         uint32_t            size_load_queue_ptr     ,
    87                         uint32_t            size_general_register   ,
    88                         uint32_t            size_special_register   ,
    89                         Tpriority_t         priority                ,
    90                         Tload_balancing_t   load_balancing          ,
    91                         uint32_t            nb_rename_unit_select   ,
     76  public : Parameters  (uint32_t            nb_front_end                       ,
     77                        uint32_t          * nb_context                         ,//[nb_front_end]
     78                        uint32_t            nb_rename_unit                     ,
     79                        uint32_t            size_queue                         ,
     80                        uint32_t            nb_bank                            ,
     81                        uint32_t          * nb_inst_insert                     ,//[nb_rename_unit]
     82                        uint32_t          * nb_inst_retire                     ,//[nb_rename_unit]
     83                        uint32_t            nb_inst_commit                     ,
     84                        uint32_t            nb_inst_reexecute                  ,
     85                        uint32_t            nb_inst_branch_complete            ,
     86                        uint32_t         ** nb_branch_speculated               ,//[nb_front_end][nb_context]
     87                        uint32_t            size_nb_inst_decod                 ,
     88                        uint32_t            size_general_data                  ,
     89                        uint32_t            size_store_queue_ptr               ,
     90                        uint32_t            size_load_queue_ptr                ,
     91                        uint32_t            size_general_register              ,
     92                        uint32_t            size_special_register              ,
     93                        Tpriority_t         priority                           ,
     94                        Tload_balancing_t   load_balancing                     ,
     95                        uint32_t            nb_rename_unit_select              ,
     96                        uint32_t            nb_thread                          ,
     97                        uint32_t         ** translate_num_context_to_num_thread, //[nb_front_end][nb_context]
    9298                        bool                is_toplevel=false
    9399                        );

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit.cpp

    r104 r110  
    77
    88#include "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/include/Commit_unit.h"
     9#include "Behavioural/include/Simulation.h"
    910
    1011namespace morpheo                    {
    … …  
    260261       
    261262#endif
     263
     264        // Init stop condition
     265        while (_simulation_nb_instruction_commited.size() < _param->_nb_thread)
     266          _simulation_nb_instruction_commited.push_back(0);
    262267      }
    263268    log_end(Commit_unit,FUNCTION);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_genMealy_retire.cpp

    r105 r110  
    5757        }
    5858    // Scan Top of each bank
     59    internal_BANK_RETIRE_HEAD = reg_NUM_BANK_HEAD;
    5960    for (uint32_t i=0; i<_param->_nb_bank; i++)
    6061      {
    61         uint32_t num_bank = (reg_NUM_BANK_HEAD+i)%_param->_nb_bank;
     62        uint32_t num_bank = (internal_BANK_RETIRE_HEAD+i)%_param->_nb_bank;
    6263
    6364        if (not _rob[num_bank].empty())
    … …  
    167168                    PORT_WRITE(out_RETIRE_NUM_REG_RE_PHY_OLD    [x][y], entry->num_reg_re_phy_old   );
    168169                    PORT_WRITE(out_RETIRE_NUM_REG_RE_PHY_NEW    [x][y], entry->num_reg_re_phy_new   );
     170
     171                    // Event -> rob must be manage this event
     172                    if ((state == ROB_END_BRANCH_MISS) or
     173                        (state == ROB_END_LOAD_MISS))
     174                      can_retire [x] = false;
    169175                  }
    170176              }

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_statistics_allocation.cpp

    r109 r110  
    2828
    2929    _stat_nb_inst_insert                = new counter_t * [_param->_nb_rename_unit];
    30     _stat_nb_inst_retire_ok             = new counter_t * [_param->_nb_rename_unit];
    31     _stat_nb_inst_retire_ko             = new counter_t * [_param->_nb_rename_unit];
     30    _stat_nb_inst_retire                = new counter_t * [_param->_nb_rename_unit];
     31    _stat_nb_inst_retire_ok             = new counter_t * [_param->_nb_thread];
     32    _stat_nb_inst_retire_ko             = new counter_t * [_param->_nb_thread];
     33    _stat_nb_inst_type                  = new counter_t * [_param->_nb_type];
    3234    _stat_bank_nb_inst                  = new counter_t * [_param->_nb_bank];
    3335   
    3436    {
    3537      std::string sum_nb_inst_insert    = "0";
    36       std::string sum_nb_inst_retire_ok = "0";
    37       std::string sum_nb_inst_retire_ko = "0";
     38      std::string sum_nb_inst_retire    = "0";
    3839
    3940      for (uint32_t i=0; i<_param->_nb_rename_unit; i++)
    4041        {
    4142          _stat_nb_inst_insert    [i] = _stat->create_variable("nb_inst_insert_"   +toString(i));
    42           _stat_nb_inst_retire_ok [i] = _stat->create_variable("nb_inst_retire_ok_"+toString(i));
    43           _stat_nb_inst_retire_ko [i] = _stat->create_variable("nb_inst_retire_ko_"+toString(i));
     43          _stat_nb_inst_retire    [i] = _stat->create_variable("nb_inst_retire_"   +toString(i));
    4444         
    4545          _stat->create_expr_average_by_cycle("average_use_interface_insert_"+toString(i), "nb_inst_insert_"+toString(i), "", toString(_("Average instruction by cycle on insert interface (rename_unit %d)"),i));
    46           _stat->create_expr_average_by_cycle("average_use_interface_retire_"+toString(i), "+ nb_inst_retire_ok_"+toString(i)+" nb_inst_retire_ko_"+toString(i), "", toString(_("Average instruction by cycle on retire interface (rename_unit %d)"),i));
     46          _stat->create_expr_average_by_cycle("average_use_interface_retire_"+toString(i), "nb_inst_retire_"+toString(i), "", toString(_("Average instruction by cycle on retire interface (rename_unit %d)"),i));
    4747          _stat->create_expr_percent         ("percent_use_interface_insert_"+toString(i) , "average_use_interface_insert_"+toString(i), toString(_param->_nb_inst_insert [i]), toString(_("Percent usage of insert interface (rename_unit %d)"),i));
    4848          _stat->create_expr_percent         ("percent_use_interface_retire_"+toString(i) , "average_use_interface_retire_"+toString(i), toString(_param->_nb_inst_retire [i]), toString(_("Percent usage of retire interface (rename_unit %d)"),i));
    4949
    5050          sum_nb_inst_insert    = "+ nb_inst_insert_"+   toString(i) + " " +sum_nb_inst_insert;
    51           sum_nb_inst_retire_ok = "+ nb_inst_retire_ok_"+toString(i) + " " +sum_nb_inst_retire_ok;
    52           sum_nb_inst_retire_ko = "+ nb_inst_retire_ko_"+toString(i) + " " +sum_nb_inst_retire_ko;
    53         }
     51          sum_nb_inst_retire    = "+ nb_inst_retire_"+   toString(i) + " " +sum_nb_inst_retire;
     52        }
    5453
    5554      _stat->create_expr_average_by_cycle("average_inst_insert"   , sum_nb_inst_insert   , "", _("Average instruction insert by cycle"));
    56       _stat->create_expr_average_by_cycle("average_inst_retire_ok", sum_nb_inst_retire_ok, "", _("Average instruction retire ok by cycle (IPC)"));
    57       _stat->create_expr_average_by_cycle("average_inst_retire_ko", sum_nb_inst_retire_ko, "", _("Average instruction retire ko (event, miss) by cycle"));
    58       _stat->create_expr_average_by_cycle("average_inst_retire"   , "+ "+sum_nb_inst_retire_ok+" "+sum_nb_inst_retire_ko, "", _("Average instruction retire by cycle"));
     55      _stat->create_expr_average_by_cycle("average_inst_retire"   , sum_nb_inst_retire   , "", _("Average instruction retire by cycle"));
     56    }
    5957
    60       _stat->create_expr                 ("IPC_ok" , "average_inst_retire_ok", TYPE_COUNTER, "inst/cycle", "Instruction Per Cycle (Instruction Ok)");
     58    {
     59      std::string sum_nb_inst_retire_ok = "0";
     60      std::string sum_nb_inst_retire_ko = "0";
     61
     62      for (uint32_t i=0; i<_param->_nb_thread; i++)
     63        if (_param->_have_thread [i])
     64          {
     65            _stat_nb_inst_retire_ok [i] = _stat->create_variable("nb_inst_retire_ok_"+toString(i));
     66            _stat_nb_inst_retire_ko [i] = _stat->create_variable("nb_inst_retire_ko_"+toString(i));
     67           
     68            sum_nb_inst_retire_ok = "+ nb_inst_retire_ok_"+toString(i) + " " +sum_nb_inst_retire_ok;
     69            sum_nb_inst_retire_ko = "+ nb_inst_retire_ko_"+toString(i) + " " +sum_nb_inst_retire_ko;
     70           
     71            _stat->create_expr_average_by_cycle("average_inst_retire_ok_"+toString(i), sum_nb_inst_retire_ok, "", toString(_("Average instruction retire ok by cycle (IPC) (thread %d)"),i));
     72            _stat->create_expr_average_by_cycle("average_inst_retire_ko_"+toString(i), sum_nb_inst_retire_ko, "", toString(_("Average instruction retire ko (event, miss) by cycle (thread %d)"),i));
     73           
     74            _stat->create_expr                 ("IPC_ok_"+toString(i) , "average_inst_retire_ok_"+toString(i), TYPE_COUNTER, "inst/cycle", toString("Instruction Per Cycle (Instruction Ok) (thread %d)",i));
     75            _stat->create_expr                 ("CPI_ok_"+toString(i) , "/ 1 IPC_ok_"+toString(i)            , TYPE_COUNTER, "cycle/inst", toString("Cycle Per Instruction (Instruction Ok) (thread %d)",i));
     76           
     77            _stat->create_expr                 ("IPC_ko_"+toString(i) , "average_inst_retire_ko_"+toString(i), TYPE_COUNTER, "inst/cycle", toString("Instruction Per Cycle (Instruction Ko) (thread %d)",i));
     78            _stat->create_expr                 ("CPI_ko_"+toString(i) , "/ 1 IPC_ko_"+toString(i)            , TYPE_COUNTER, "cycle/inst", toString("Cycle Per Instruction (Instruction Ko) (thread %d)",i));
     79           
     80            _stat->create_expr                 ("IPC_all_"+toString(i), "+ IPC_ok_"+toString(i)+" IPC_ko_"+toString(i), TYPE_COUNTER, "inst/cycle", toString("Instruction Per Cycle (Instruction Ok and Ko) (thread %d)",i));
     81            _stat->create_expr                 ("CPI_all_"+toString(i), "/ 1 IPC_all_"+toString(i)           , TYPE_COUNTER, "cycle/inst", toString("Cycle Per Instruction (Instruction Ok and Ko) (thread %d)",i));
     82          }
     83
     84      _stat->create_expr                 ("IPC_ok" , "/ "+sum_nb_inst_retire_ok+" cycle", TYPE_COUNTER, "inst/cycle", "Instruction Per Cycle (Instruction Ok)");
    6185      _stat->create_expr                 ("CPI_ok" , "/ 1 IPC_ok"            , TYPE_COUNTER, "cycle/inst", "Cycle Per Instruction (Instruction Ok)");
    6286
    63       _stat->create_expr                 ("IPC_ko" , "average_inst_retire_ko", TYPE_COUNTER, "inst/cycle", "Instruction Per Cycle (Instruction Ko)");
     87      _stat->create_expr                 ("IPC_ko" , "/ "+sum_nb_inst_retire_ko+" cycle", TYPE_COUNTER, "inst/cycle", "Instruction Per Cycle (Instruction Ko)");
    6488      _stat->create_expr                 ("CPI_ko" , "/ 1 IPC_ko"            , TYPE_COUNTER, "cycle/inst", "Cycle Per Instruction (Instruction Ko)");
    6589
    66       _stat->create_expr                 ("IPC_all", "average_inst_retire"   , TYPE_COUNTER, "inst/cycle", "Instruction Per Cycle (Instruction Ok and Ko)");
     90      _stat->create_expr                 ("IPC_all", "+ IPC_ok IPC_ko"       , TYPE_COUNTER, "inst/cycle", "Instruction Per Cycle (Instruction Ok and Ko)");
    6791      _stat->create_expr                 ("CPI_all", "/ 1 IPC_all"           , TYPE_COUNTER, "cycle/inst", "Cycle Per Instruction (Instruction Ok and Ko)");
    6892    }
     93
     94    {
     95      std::string sum_nb_inst_type = "0";
     96
     97      for (uint32_t i=0; i<_param->_nb_type; i++)
     98        if (is_type_valid(i))
     99          {
     100            _stat_nb_inst_type [i] = _stat->create_variable("nb_inst_type_"+toString(i));
     101           
     102            sum_nb_inst_type = "+ nb_inst_type_"+toString(i) + " " +sum_nb_inst_type;
     103          }
     104 
     105      for (uint32_t i=0; i<_param->_nb_type; i++)
     106        if (is_type_valid(i))
     107          {
     108            std::string name = toString(static_cast<type_t>(i)).c_str();
     109//          _stat->create_expr_average_by_cycle("average_inst_type_"+toString(name), "nb_inst_type_"+toString(i), "", toString(_("Average instruction retire ok by cycle (type %s)"),name.c_str()));
     110            _stat->create_expr_percent         ("percent_inst_type_"+toString(name), "nb_inst_type_"+toString(i), sum_nb_inst_type, toString(_("Percent instruction retire ok by cycle (type %s)"),name.c_str()));
     111          }
     112    }
     113
    69114
    70115    _stat_nb_inst_commit = _stat->create_variable("nb_inst_commit");

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_statistics_deallocation.cpp

    r98 r110  
    2828
    2929    delete [] _stat_nb_inst_insert;
     30    delete [] _stat_nb_inst_retire;
    3031    delete [] _stat_nb_inst_retire_ok;
    3132    delete [] _stat_nb_inst_retire_ko;
     33    delete [] _stat_nb_inst_type;
    3234    delete [] _stat_bank_nb_inst;
    3335   

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_transition.cpp

    r109 r110  
    88
    99#include "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/include/Commit_unit.h"
     10#include "Behavioural/include/Simulation.h"
    1011
    1112namespace morpheo                    {
    … …  
    114115                {
    115116                  log_printf(TRACE,Commit_unit,FUNCTION,"  * INSERT            [%d][%d]",x,y);
    116 
    117 #ifdef STATISTICS
    118                   if (usage_is_set(_usage,USE_STATISTICS))
    119                     (*_stat_nb_inst_insert [x]) ++;
    120 #endif
    121117
    122118                  // get information
    … …  
    219215                        }
    220216                    }
     217
     218#ifdef STATISTICS
     219                  if (usage_is_set(_usage,USE_STATISTICS))
     220                    (*_stat_nb_inst_insert [x]) ++;
     221#endif
    221222
    222223                  // Push in rob
    … …  
    346347        // ===================================================================
    347348        for (uint32_t i=0; i<_param->_nb_bank; i++)
    348           if (internal_BANK_RETIRE_VAL [i])
    349             {
    350               uint32_t x = internal_BANK_RETIRE_NUM_RENAME_UNIT [i];
    351               uint32_t y = internal_BANK_RETIRE_NUM_INST        [i];
    352 
    353               log_printf(TRACE,Commit_unit,FUNCTION,"  * RETIRE            [%d][%d]",x,y);
    354 
     349          {
     350            uint32_t num_bank = (internal_BANK_RETIRE_HEAD+i)%_param->_nb_bank;
     351           
     352            if (internal_BANK_RETIRE_VAL [num_bank])
     353              {
     354                uint32_t x = internal_BANK_RETIRE_NUM_RENAME_UNIT [num_bank];
     355                uint32_t y = internal_BANK_RETIRE_NUM_INST        [num_bank];
     356               
     357                log_printf(TRACE,Commit_unit,FUNCTION,"  * RETIRE            [%d][%d]",x,y);
     358               
    355359#ifdef DEBUG_TEST
    356               if (not PORT_READ(in_RETIRE_ACK [x][y]))
    357                 throw ERRORMORPHEO(FUNCTION,_("Retire : retire_ack must be set.\n"));
    358 #endif
    359 
    360               entry_t *  entry        =  _rob [i].front();
    361               rob_state_t state = entry->state;
    362              
    363 #ifdef STATISTICS
    364               if (usage_is_set(_usage,USE_STATISTICS))
    365                 {
    366                   if (state == ROB_END_OK)
    367                     (*_stat_nb_inst_retire_ok [x]) ++;
    368                   else
    369                     (*_stat_nb_inst_retire_ko [x]) ++;
    370                 }
    371 #endif
    372 
    373               Tcontext_t front_end_id = entry->front_end_id;
    374               Tcontext_t context_id   = entry->context_id  ;
    375               Ttype_t    type         = entry->type        ;
    376 
    377               if ((state == ROB_END_OK         ) or
    378 //                (state == ROB_END_KO         ) or
    379                   (state == ROB_END_BRANCH_MISS) or
    380                   (state == ROB_END_LOAD_MISS  )//  or
    381 //                (state == ROB_END_MISS       ) or
    382 //                (state == ROB_END_EXCEPTION  )
    383                   )
    384                 {
    385 //                reg_PC_PREVIOUS           [front_end_id][context_id] = reg_PC_CURRENT [front_end_id][context_id];
    386                   reg_PC_CURRENT            [front_end_id][context_id] = reg_PC_NEXT    [front_end_id][context_id];
    387                   reg_PC_CURRENT_IS_DS      [front_end_id][context_id] = entry->type == TYPE_BRANCH;
    388                   reg_PC_CURRENT_IS_DS_TAKE [front_end_id][context_id] = entry->no_sequence;
    389                   reg_PC_NEXT               [front_end_id][context_id] = (entry->no_sequence)?(entry->address_next):(reg_PC_CURRENT [front_end_id][context_id]+1);
     360                if (not PORT_READ(in_RETIRE_ACK [x][y]))
     361                  throw ERRORMORPHEO(FUNCTION,_("Retire : retire_ack must be set.\n"));
     362#endif
     363               
     364                entry_t *  entry        =  _rob [num_bank].front();
     365                rob_state_t state = entry->state;
     366               
     367                Tcontext_t front_end_id = entry->front_end_id;
     368                Tcontext_t context_id   = entry->context_id  ;
     369                uint32_t   num_thread   = _param->_translate_num_context_to_num_thread [front_end_id][context_id];
     370                Ttype_t    type         = entry->type        ;
     371                bool       retire_ok    = false;
     372
     373                log_printf(TRACE,Commit_unit,FUNCTION,"    * front_end_id : %d",front_end_id );
     374                log_printf(TRACE,Commit_unit,FUNCTION,"    * context_id   : %d",context_id   );
     375                log_printf(TRACE,Commit_unit,FUNCTION,"    * num_thread   : %d",num_thread   );
     376                log_printf(TRACE,Commit_unit,FUNCTION,"    * type         : %s",toString(type).c_str());
     377                log_printf(TRACE,Commit_unit,FUNCTION,"    * state        : %s",toString(state).c_str());
     378
     379                if ((state == ROB_END_OK         ) or
     380//                  (state == ROB_END_KO         ) or
     381                    (state == ROB_END_BRANCH_MISS) or
     382                    (state == ROB_END_LOAD_MISS  )//  or
     383//                  (state == ROB_END_MISS       ) or
     384//                  (state == ROB_END_EXCEPTION  )
     385                    )
     386                  {
     387                    log_printf(TRACE,Commit_unit,FUNCTION,"    * retire_ok");
     388
     389                    retire_ok = true;
     390
     391//                  reg_PC_PREVIOUS           [front_end_id][context_id] = reg_PC_CURRENT [front_end_id][context_id];
     392                    reg_PC_CURRENT            [front_end_id][context_id] = reg_PC_NEXT    [front_end_id][context_id];
     393                    reg_PC_CURRENT_IS_DS      [front_end_id][context_id] = entry->type == TYPE_BRANCH;
     394                    reg_PC_CURRENT_IS_DS_TAKE [front_end_id][context_id] = entry->no_sequence;
     395                    reg_PC_NEXT               [front_end_id][context_id] = (entry->no_sequence)?(entry->address_next):(reg_PC_CURRENT [front_end_id][context_id]+1);
    390396
    391397//                   if (entry->address_next != reg_PC_NEXT [front_end_id][context_id])
    392398//                     throw ERRORMORPHEO(FUNCTION,toString(_("Retire : Instruction's address_next (%.8x) is different of commit_unit's address_next (%.8x)"),entry->address_next,reg_PC_NEXT [front_end_id][context_id]));
    393                 }
    394 
    395               if ((state == ROB_END_BRANCH_MISS) or
    396                   (state == ROB_END_LOAD_MISS))
    397                 {
    398                   reg_EVENT_STATE [front_end_id][context_id] = EVENT_STATE_EVENT;
    399                   reg_EVENT_FLUSH [front_end_id][context_id] = true;
    400                 }
    401              
    402               // Update nb_inst
    403               reg_NB_INST_COMMIT_ALL [front_end_id][context_id] --;
    404               if (type == TYPE_MEMORY)
    405                 reg_NB_INST_COMMIT_MEM [front_end_id][context_id] --;
    406 
    407               reg_NUM_BANK_HEAD = (reg_NUM_BANK_HEAD+1)%_param->_nb_bank;
    408              
    409               _rob [i].pop_front();
    410               delete entry;
    411 
    412               // Transaction on retire interface : reset watch dog timer.
    413               _nb_cycle_idle [front_end_id][context_id] = 0;
    414             }
     399                  }
     400               
     401                if ((state == ROB_END_BRANCH_MISS) or
     402                    (state == ROB_END_LOAD_MISS))
     403                  {
     404                    reg_EVENT_STATE [front_end_id][context_id] = EVENT_STATE_EVENT;
     405                    reg_EVENT_FLUSH [front_end_id][context_id] = true;
     406                  }
     407               
     408                // Update nb_inst
     409                reg_NB_INST_COMMIT_ALL [front_end_id][context_id] --;
     410                if (type == TYPE_MEMORY)
     411                  reg_NB_INST_COMMIT_MEM [front_end_id][context_id] --;
     412               
     413                reg_NUM_BANK_HEAD = (reg_NUM_BANK_HEAD+1)%_param->_nb_bank;
     414               
     415                _rob [num_bank].pop_front();
     416                delete entry;
     417               
     418                // Transaction on retire interface : reset watch dog timer.
     419                _nb_cycle_idle [front_end_id][context_id] = 0;
     420
     421                // Increase stop condition
     422                if (retire_ok)
     423                  _simulation_nb_instruction_commited [num_thread] ++;
     424
     425#ifdef STATISTICS
     426                if (usage_is_set(_usage,USE_STATISTICS))
     427                  {
     428                    (*_stat_nb_inst_retire [x]) ++;
     429                   
     430                    if (retire_ok)
     431                      {
     432                        (*_stat_nb_inst_retire_ok [num_thread]) ++;
     433                        (*_stat_nb_inst_type      [type]      ) ++;
     434                      }
     435                    else
     436                      (*_stat_nb_inst_retire_ko [num_thread]) ++;
     437                  }
     438#endif
     439              }
     440          }
    415441
    416442        // ===================================================================
    … …  
    652678        for (uint32_t j=0; j<_param->_nb_context [i]; j++)
    653679          {
    654             log_printf(TRACE,Commit_unit,FUNCTION,"    * [%d][%d]",i,j);
     680            log_printf(TRACE,Commit_unit,FUNCTION,"    * [%d][%d] - %d",i,j,_param->_translate_num_context_to_num_thread [i][j]);
    655681            log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_STATE  : %s",toString(reg_EVENT_STATE [i][j]).c_str());
    656682            log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_FLUSH  : %d",reg_EVENT_FLUSH [i][j]);
    … …  
    667693          log_printf(TRACE,Commit_unit,FUNCTION,"      * Bank [%d] size : %d, ptr : %d",num_bank,(int)_rob[num_bank].size(), reg_BANK_PTR [i]);
    668694         
    669           uint32_t x=0;
    670695          for (std::list<entry_t*>::iterator it=_rob[num_bank].begin();
    671696               it!=_rob[num_bank].end();
    672697               it++)
    673698            {
    674               log_printf(TRACE,Commit_unit,FUNCTION,"        [%.4d] %.4d %.4d %.4d %.4d, %.3d %.3d, %.1d, %.1d %.4d, %.1d %.4d, %s - %d",
    675                          x,
     699              log_printf(TRACE,Commit_unit,FUNCTION,"        [%.4d][%.4d] (%.4d) %.4d %.4d %.4d %.4d, %.3d %.3d, %.1d, %.1d %.4d, %.1d %.4d, %s",
     700                         num_bank                       ,
     701                         (*it)->ptr                     ,
     702                         ((num_bank << _param->_shift_num_bank) | (*it)->ptr),
    676703                         (*it)->front_end_id            ,
    677704                         (*it)->context_id              ,
    … …  
    685712                         (*it)->use_load_queue          ,
    686713                         (*it)->load_queue_ptr_write    ,
    687                          toString((*it)->state).c_str() ,
    688                          (*it)->ptr                     );
    689               log_printf(TRACE,Commit_unit,FUNCTION,"               %.1d %.2d %.6d, %.1d %.2d %.6d, %.1d %.1d %.6d, %.1d %.2d %.6d %.6d, %.1d %.1d %.6d %.6d ",
     714                         toString((*it)->state).c_str() );
     715              log_printf(TRACE,Commit_unit,FUNCTION,"                     %.1d %.2d %.6d, %.1d %.2d %.6d, %.1d %.1d %.6d, %.1d %.2d %.6d %.6d, %.1d %.1d %.6d %.6d ",
    690716                         (*it)->read_ra                 ,
    691717                         (*it)->num_reg_ra_log          ,
    … …  
    706732                         (*it)->num_reg_re_phy_new      );
    707733             
    708               log_printf(TRACE,Commit_unit,FUNCTION,"               %.2d %.2d %.1d %.1d %.1d - %.8x (%.8x) %.8x (%.8x)",
     734              log_printf(TRACE,Commit_unit,FUNCTION,"                     %.2d %.2d %.1d %.1d %.1d - %.8x (%.8x) %.8x (%.8x)",
    709735                         (*it)->exception_use ,
    710736                         (*it)->exception     ,
    … …  
    717743                         (*it)->address_next<<2
    718744                         );
    719              
    720               x++;
    721745            }
    722746        }
    … …  
    772796    for (uint32_t i=0; i<_param->_nb_front_end; i++)
    773797      for (uint32_t j=0; j<_param->_nb_context [i]; j++)
    774         if (_nb_cycle_idle [i][j] >= debug_cycle_idle)
    775           throw ERRORMORPHEO(FUNCTION,toString(_("Context [%d][%d] is idle since %.0f cycles.\n"),i,j,_nb_cycle_idle [i][j]));
     798        if (_nb_cycle_idle [i][j] >= debug_idle_cycle)
     799          throw ERRORMORPHEO(FUNCTION,toString(_("Thread [%d] is idle since %.0f cycles.\n"),_param->_translate_num_context_to_num_thread[i][j],_nb_cycle_idle [i][j]));
    776800
    777801    log_end(Commit_unit,FUNCTION);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Parameters.cpp

    r108 r110  
    77
    88#include "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/include/Parameters.h"
     9#include "Behavioural/include/Allocation.h"
    910#include "Common/include/Max.h"
    1011#include "Common/include/BitManipulation.h"
    … …  
    2021#undef  FUNCTION
    2122#define FUNCTION "Commit_unit::Parameters"
    22   Parameters::Parameters (uint32_t            nb_front_end            ,
    23                           uint32_t          * nb_context              ,
    24                           uint32_t            nb_rename_unit          ,
    25                           uint32_t            size_queue              ,
    26                           uint32_t            nb_bank                 ,
    27                           uint32_t          * nb_inst_insert          ,
    28                           uint32_t          * nb_inst_retire          ,
    29                           uint32_t            nb_inst_commit          ,
    30                           uint32_t            nb_inst_reexecute       ,
    31                           uint32_t            nb_inst_branch_complete ,
    32                           uint32_t         ** nb_branch_speculated    ,
    33                           uint32_t            size_nb_inst_decod      ,
    34                           uint32_t            size_general_data       ,
    35                           uint32_t            size_store_queue_ptr    ,
    36                           uint32_t            size_load_queue_ptr     ,
    37                           uint32_t            size_general_register   ,
    38                           uint32_t            size_special_register   ,
    39                           Tpriority_t         priority                ,
    40                           Tload_balancing_t   load_balancing          ,
    41                           uint32_t            nb_rename_unit_select   ,
     23  Parameters::Parameters (uint32_t            nb_front_end                       ,
     24                          uint32_t          * nb_context                         ,
     25                          uint32_t            nb_rename_unit                     ,
     26                          uint32_t            size_queue                         ,
     27                          uint32_t            nb_bank                            ,
     28                          uint32_t          * nb_inst_insert                     ,
     29                          uint32_t          * nb_inst_retire                     ,
     30                          uint32_t            nb_inst_commit                     ,
     31                          uint32_t            nb_inst_reexecute                  ,
     32                          uint32_t            nb_inst_branch_complete            ,
     33                          uint32_t         ** nb_branch_speculated               ,
     34                          uint32_t            size_nb_inst_decod                 ,
     35                          uint32_t            size_general_data                  ,
     36                          uint32_t            size_store_queue_ptr               ,
     37                          uint32_t            size_load_queue_ptr                ,
     38                          uint32_t            size_general_register              ,
     39                          uint32_t            size_special_register              ,
     40                          Tpriority_t         priority                           ,
     41                          Tload_balancing_t   load_balancing                     ,
     42                          uint32_t            nb_rename_unit_select              ,
     43                          uint32_t            nb_thread                          ,
     44                          uint32_t         ** translate_num_context_to_num_thread,
    4245                          bool                is_toplevel):
    4346    _nb_bank_access_commit (1              ),
    … …  
    4649    log_begin(Commit_unit,FUNCTION);
    4750
    48     _nb_front_end             = nb_front_end           ;
    49     _nb_context               = nb_context             ;
    50     _nb_rename_unit           = nb_rename_unit         ;
    51     _size_queue               = size_queue             ;
    52     _nb_bank                  = nb_bank                ;
    53     _nb_inst_insert           = nb_inst_insert         ;
    54     _nb_inst_retire           = nb_inst_retire         ;
    55     _nb_inst_commit           = nb_inst_commit         ;
    56     _nb_inst_reexecute        = nb_inst_reexecute      ;
    57     _nb_inst_branch_complete  = nb_inst_branch_complete;
    58     _nb_branch_speculated     = nb_branch_speculated   ;
    59     _priority                 = priority               ;
    60     _load_balancing           = load_balancing         ;
    61     _nb_rename_unit_select    = nb_rename_unit_select  ;
     51    _nb_front_end                        = nb_front_end                       ;
     52    _nb_context                          = nb_context                         ;
     53    _nb_rename_unit                      = nb_rename_unit                     ;
     54    _size_queue                          = size_queue                         ;
     55    _nb_bank                             = nb_bank                            ;
     56    _nb_inst_insert                      = nb_inst_insert                     ;
     57    _nb_inst_retire                      = nb_inst_retire                     ;
     58    _nb_inst_commit                      = nb_inst_commit                     ;
     59    _nb_inst_reexecute                   = nb_inst_reexecute                  ;
     60    _nb_inst_branch_complete             = nb_inst_branch_complete            ;
     61    _nb_branch_speculated                = nb_branch_speculated               ;
     62    _priority                            = priority                           ;
     63    _load_balancing                      = load_balancing                     ;
     64    _nb_rename_unit_select               = nb_rename_unit_select              ;
     65    _nb_thread                           = nb_thread                          ;
     66    _translate_num_context_to_num_thread = translate_num_context_to_num_thread;
    6267
    6368    _size_rename_unit_id      = log2(_nb_rename_unit);
    … …  
    7176    _have_port_rename_unit_id = _size_rename_unit_id > 0;
    7277
    73     _array_size_depth               = new uint32_t * [_nb_front_end];
     78    ALLOC2(_array_size_depth,uint32_t,_nb_front_end,_nb_context [it1]);
    7479    for (uint32_t i=0; i<_nb_front_end; i++)
    75       {
    76         _array_size_depth      [i]      = new uint32_t [_nb_context [i]];
    77         for (uint32_t j=0; j<_nb_context [i]; j++)
    78           _array_size_depth      [i][j] = (_nb_branch_speculated [i][j] == 0)?0:log2(_nb_branch_speculated [i][j]);
    79       }
     80      for (uint32_t j=0; j<_nb_context [i]; j++)
     81        _array_size_depth      [i][j] = (_nb_branch_speculated [i][j] == 0)?0:log2(_nb_branch_speculated [i][j]);
    8082
    8183    test();
     84
     85    ALLOC1(_have_thread,bool,_nb_thread);
     86    for (uint32_t i=0; i<_nb_thread; i++)
     87      _have_thread[i] = false;
     88    for (uint32_t i=0; i<_nb_front_end; i++)
     89      for (uint32_t j=0; j<_nb_context [i]; j++)
     90        _have_thread[_translate_num_context_to_num_thread [i][j]] = true;
    8291
    8392    if (is_toplevel)
    … …  
    123132    log_begin(Commit_unit,FUNCTION);
    124133
    125     for (uint32_t i=0; i<_nb_front_end; i++)
    126       {
    127         delete [] _array_size_depth [i];
    128       }
    129     delete [] _array_size_depth;
     134    DELETE1(_have_thread     ,_nb_thread);
     135    DELETE2(_array_size_depth,_nb_front_end,_nb_context [it1]);
    130136
    131137    log_end(Commit_unit,FUNCTION);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Parameters_msg_error.cpp

    r88 r110  
    3535   
    3636    if (_nb_rename_unit_select > _nb_rename_unit)
    37       test.error("nb_rename_unit must be >= nb_rename_unit_select.\n");
     37      test.error(_("nb_rename_unit must be >= nb_rename_unit_select.\n"));
    3838
    3939    if (not is_multiple(_size_queue, _nb_bank))
    40       test.error("nb_bank must be a multiple of size_queue.\n");
     40      test.error(_("nb_bank must be a multiple of size_queue.\n"));
    4141
    4242    if (_nb_inst_reexecute != 1)
    43       test.error("nb_inst_reexecute must be set at 1. Anothers value is unsupported.\n");
     43      test.error(_("nb_inst_reexecute must be set at 1. Anothers value is unsupported.\n"));
     44
     45    for (uint32_t i=0; i<_nb_front_end; ++i)
     46      for (uint32_t j=0; j<_nb_context[i]; ++j)
     47        if (_translate_num_context_to_num_thread [i][j] >= _nb_thread)
     48          test.error(toString(_("num_thread [%d][%d] (%d) is >= at nb_thread (%d).\n"),i,j,_translate_num_context_to_num_thread [i][j],_nb_thread));
     49   
     50    for (uint32_t i=0; i<_nb_front_end; ++i)
     51      for (uint32_t j=0; j<_nb_context[i]-1; ++j)
     52        for (uint32_t x=i; x<_nb_front_end; ++x)
     53          for (uint32_t y=j+1; y<_nb_context[i]; ++y)
     54            if (_translate_num_context_to_num_thread [i][j] == _translate_num_context_to_num_thread [x][y])
     55              test.error(toString(_("To context [%d][%d] and [%d][%d], num_thread is the same (%d).\n"),i,j,x,y,_translate_num_context_to_num_thread [i][j]));
     56             
    4457
    4558    if (_size_queue == 1)
    46       test.information ("Instructions are issued In-Order.\n");
     59      test.information (_("Instructions are issued In-Order.\n"));
    4760    else
    48       test.information ("Instructions are issued Out-Of-Order.\n");
     61      test.information (_("Instructions are issued Out-Of-Order.\n"));
    4962
    5063    log_end(Commit_unit,FUNCTION);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/SelfTest/src/test.cpp

    r88 r110  
    333333          }
    334334
    335       bool test_size = issue_queue.size() <= _param->_size_queue;
     335      bool test_size = issue_queue.size() <= (_param->_size_queue+_param->_size_reexecute_queue);
    336336      TEST(bool,test_size,true);
    337337

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/include/Issue_queue.h

    r88 r110  
    144144    // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    145145  private   : std::list<entry_t*>           * _issue_queue;
     146  private   : std::list<entry_t*>             _reexecute_queue;
    146147 
    147148    // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    148149  private   : Tcontrol_t                    * internal_BANK_IN_ACK              ;//[nb_bank]
    149   private   : bool                          * internal_BANK_IN_IS_REEXECUTE     ;//[nb_bank]
    150150  private   : uint32_t                      * internal_BANK_IN_NUM_RENAME_UNIT  ;//[nb_bank]
    151151  private   : uint32_t                      * internal_BANK_IN_NUM_INST         ;//[nb_bank]
    152152
    153   private   : Tcontrol_t                    * internal_BANK_OUT_VAL             ;//[nb_bank]
    154   private   : uint32_t                      * internal_BANK_OUT_NUM_INST        ;//[nb_bank]
     153  private   : Tcontrol_t                    * internal_ISSUE_OUT_VAL            ;//[nb_inst_issue]
     154  private   : Tcontrol_t                    * internal_ISSUE_OUT_FROM_REEXECUTE ;//[nb_inst_issue]
     155  private   : uint32_t                      * internal_ISSUE_OUT_NUM_BANK       ;//[nb_inst_issue]
     156  private   : entry_t *                     * internal_ISSUE_OUT_ENTRY          ;//[nb_inst_issue]
     157
     158  private   : Tcontrol_t                    * internal_REEXECUTE_ACK            ;//[nb_inst_reexecute]
    155159#endif
    156160
    … …  
    187191  public  : void        transition                (void);
    188192  public  : void        genMoore                  (void);
    189   public  : void        genMealy                  (void);
    190193#endif                                         
    191194

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/include/Parameters.h

    r88 r110  
    4545  public : bool           ** _table_routing           ;//[nb_rename_unit][nb_inst_issue]
    4646  public : bool           ** _table_issue_type        ;//[nb_inst_issue][nb_type]
     47  public : uint32_t          _size_reexecute_queue    ;
    4748
    48   public : uint32_t          _nb_bank_select_out      ;
     49//public : uint32_t          _nb_bank_select_out      ;
    4950  public : uint32_t          _max_nb_inst_rename      ;
    5051

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/src/Issue_queue.cpp

    r88 r110  
    9595# endif   
    9696
    97         log_printf(INFO,Issue_queue,FUNCTION,_("<%s> : Method - genMealy"),_name.c_str());
    98 
    99         SC_METHOD (genMealy);
    100         dont_initialize ();
    101         sensitive << (*(in_CLOCK)).neg(); // need internal register
    102         for (uint32_t i=0; i<_param->_nb_inst_reexecute; i++)
    103           sensitive << (*(in_REEXECUTE_VAL  [i]))
    104                     << (*(in_REEXECUTE_TYPE [i]));
    105         for (uint32_t i=0; i<_param->_nb_rename_unit; i++)
    106           for (uint32_t j=0; j<_param->_nb_inst_rename[i]; j++)
    107             sensitive // << (*(in_ISSUE_IN_VAL  [i][j]))
    108                       << (*(in_ISSUE_IN_TYPE [i][j]));
    109        
    110 # ifdef SYSTEMCASS_SPECIFIC
    111         // List dependency information
    112         for (uint32_t i=0; i<_param->_nb_inst_reexecute; i++)
    113           for (uint32_t x=0; x<_param->_nb_inst_reexecute; x++)
    114             {
    115               (*(out_REEXECUTE_ACK [i])) (*(in_REEXECUTE_VAL  [x]));
    116               (*(out_REEXECUTE_ACK [i])) (*(in_REEXECUTE_TYPE [x]));
    117             }
    118 
    119         for (uint32_t i=0; i<_param->_nb_rename_unit; i++)
    120           for (uint32_t j=0; j<_param->_nb_inst_rename[i]; j++)
    121             {
    122               for (uint32_t x=0; x<_param->_nb_inst_reexecute; x++)
    123                 {
    124                   (*(out_ISSUE_IN_ACK [i][j])) (*(in_REEXECUTE_VAL  [x]));
    125                   (*(out_ISSUE_IN_ACK [i][j])) (*(in_REEXECUTE_TYPE [x]));
    126                 }
    127 
    128               for (uint32_t x=0; x<_param->_nb_rename_unit; x++)
    129                 for (uint32_t y=0; y<_param->_nb_inst_rename[x]; y++)
    130                   {
    131                     (*(out_ISSUE_IN_ACK [i][j])) (*(in_ISSUE_IN_VAL  [x][y]));
    132                     (*(out_ISSUE_IN_ACK [i][j])) (*(in_ISSUE_IN_TYPE [x][y]));
    133                   }
    134             }
    135 # endif   
    136        
    13797#endif
    13898      }

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/src/Issue_queue_allocation.cpp

    r88 r110  
    141141      {
    142142    // ~~~~~[ Registers ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    143     _issue_queue = new std::list<entry_t*> [_param->_nb_bank];
     143    _issue_queue     = new std::list<entry_t*> [_param->_nb_bank];
    144144
    145145    // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    146     internal_BANK_IN_ACK             = new Tcontrol_t [_param->_nb_bank];
    147     internal_BANK_IN_IS_REEXECUTE    = new bool       [_param->_nb_bank];
    148     internal_BANK_IN_NUM_RENAME_UNIT = new uint32_t   [_param->_nb_bank];
    149     internal_BANK_IN_NUM_INST        = new uint32_t   [_param->_nb_bank];
    150    
    151     internal_BANK_OUT_VAL            = new Tcontrol_t [_param->_nb_bank];
    152     internal_BANK_OUT_NUM_INST       = new uint32_t   [_param->_nb_bank];
     146    ALLOC1(internal_BANK_IN_ACK             ,Tcontrol_t,_param->_nb_bank);
     147    ALLOC1(internal_BANK_IN_NUM_RENAME_UNIT ,uint32_t  ,_param->_nb_bank);
     148    ALLOC1(internal_BANK_IN_NUM_INST        ,uint32_t  ,_param->_nb_bank);
     149
     150    ALLOC1(internal_ISSUE_OUT_VAL           ,Tcontrol_t,_param->_nb_inst_issue);
     151    ALLOC1(internal_ISSUE_OUT_FROM_REEXECUTE,Tcontrol_t,_param->_nb_inst_issue);
     152    ALLOC1(internal_ISSUE_OUT_NUM_BANK      ,uint32_t  ,_param->_nb_inst_issue);
     153    ALLOC1(internal_ISSUE_OUT_ENTRY         ,entry_t * ,_param->_nb_inst_issue);
     154
     155    ALLOC1(internal_REEXECUTE_ACK           ,Tcontrol_t,_param->_nb_inst_reexecute);
    153156      }
    154157
    … …  
    164167    _priority_out = new generic::priority::Priority (_name+"_priority_out"  ,
    165168                                                     _param->_priority      ,
    166                                                      _param->_nb_bank_select_out,
    167                                                      _param->_nb_bank_select_out);
     169                                                     _param->_nb_bank,
     170                                                     _param->_nb_bank);
    168171
    169     _priority_reg = new generic::priority::Priority (_name+"_priority_reg",
    170                                                      PRIORITY_ROUND_ROBIN ,
     172    _priority_reg = new generic::priority::Priority (_name+"_priority_reg"  ,
     173                                                     _param->_priority      ,
    171174                                                     _param->_nb_bank,
    172175                                                     _param->_nb_bank);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/src/Issue_queue_deallocation.cpp

    r88 r110  
    9898       
    9999        // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    100         delete [] internal_BANK_IN_ACK            ;
    101         delete [] internal_BANK_IN_IS_REEXECUTE   ;
    102         delete [] internal_BANK_IN_NUM_RENAME_UNIT;
    103         delete [] internal_BANK_IN_NUM_INST       ;
    104        
    105         delete [] internal_BANK_OUT_VAL           ;
    106         delete [] internal_BANK_OUT_NUM_INST      ;
     100        DELETE1(internal_BANK_IN_ACK             ,_param->_nb_bank);
     101        DELETE1(internal_BANK_IN_NUM_RENAME_UNIT ,_param->_nb_bank);
     102        DELETE1(internal_BANK_IN_NUM_INST        ,_param->_nb_bank);
     103
     104        DELETE1(internal_ISSUE_OUT_VAL           ,_param->_nb_inst_issue);
     105        DELETE1(internal_ISSUE_OUT_FROM_REEXECUTE,_param->_nb_inst_issue);
     106        DELETE1(internal_ISSUE_OUT_NUM_BANK      ,_param->_nb_inst_issue);
     107        DELETE1(internal_ISSUE_OUT_ENTRY         ,_param->_nb_inst_issue);
     108
     109        DELETE1(internal_REEXECUTE_ACK           ,_param->_nb_inst_reexecute);
    107110      }
    108111   

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/src/Issue_queue_genMoore.cpp

    r88 r110  
    2424    log_function(Issue_queue,FUNCTION,_name.c_str());
    2525
    26     for (uint32_t i=0; i<_param->_nb_bank; i++)
    27       internal_BANK_OUT_VAL [i] = false;
    28 
    29     std::list<generic::priority::select_t> * select = _priority_out->select(); // same select for all issue
    30 
    31     uint32_t num_bank_offset = 0;
    32     for (uint32_t i=0; i<_param->_nb_inst_issue; i++)
     26    // ===================================================================
     27    // =====[ REEXECUTE_UNIT ]============================================
     28    // ===================================================================
     29   
     30    for (uint32_t i=0; i<_param->_nb_inst_reexecute; ++i)
    3331      {
    34 //      log_printf(TRACE,Issue_queue,FUNCTION,"  * ISSUE_OUT [%d]",i);
    35         Tcontrol_t val      = false;
    36         uint32_t   num_bank = 0;
    37 
    38         // find a non empty bank
    39         for (std::list<generic::priority::select_t>::iterator it=select->begin();
    40              it!=select->end();
    41              it++)
    42           {
    43             num_bank=num_bank_offset+it->grp;
    44            
    45 //          log_printf(TRACE,Issue_queue,FUNCTION,"    * Bank [%d]",num_bank);
     32        log_printf(TRACE,Issue_queue,FUNCTION,"  * REEXECUTE [%d]",i);
     33
     34        internal_REEXECUTE_ACK [i] = (_reexecute_queue.size()+i) < _param->_size_reexecute_queue;
     35
     36        log_printf(TRACE,Issue_queue,FUNCTION,"    * ACK : %d",internal_REEXECUTE_ACK [i]);
     37
     38        PORT_WRITE(out_REEXECUTE_ACK [i], internal_REEXECUTE_ACK [i]);
     39      }
     40
     41    // ===================================================================
     42    // =====[ ISSUE_IN ]==================================================
     43    // ===================================================================
     44    {
     45      Tcontrol_t ack [_param->_nb_rename_unit][_param->_max_nb_inst_rename];
     46
     47      // Initialisation
     48      for (uint32_t i=0; i<_param->_nb_bank; i++)
     49        internal_BANK_IN_ACK  [i] = false;
     50   
     51      for (uint32_t i=0; i<_param->_nb_rename_unit; i++)
     52        for (uint32_t j=0; j<_param->_nb_inst_rename[i]; j++)
     53          ack [i][j] = false;
     54   
     55      std::list<generic::priority::select_t> * select_reg = _priority_reg->select(); // same select for all issue
     56     
     57      // issue_in interface
     58      std::list<generic::priority::select_t> * select_in = _priority_in ->select(); // same select for all issue
     59      for (std::list<generic::priority::select_t>::iterator it=select_in ->begin();
     60           it!=select_in ->end();
     61           it++)
     62        {
     63          // Get num interface
     64          uint32_t num_rename_unit = it->grp;
     65          uint32_t num_inst_rename = it->elt;
     66
     67          log_printf(TRACE,Issue_queue,FUNCTION,"  * ISSUE_IN [%d][%d]",num_rename_unit,num_inst_rename);
     68         
     69          // scan all bank
     70          for (std::list<generic::priority::select_t>::iterator it=select_reg->begin();
     71               it!=select_reg->end();
     72               it++)
     73            {
     74              uint32_t num_bank  = it->grp;
     75
     76              log_printf(TRACE,Issue_queue,FUNCTION,"    * BANK [%d]",num_bank);
     77         
     78              // test if bank is not busy (full or previous access)
     79              if (not internal_BANK_IN_ACK [num_bank] and (_issue_queue[num_bank].size() < _param->_size_bank))
     80                {
     81                  log_printf(TRACE,Issue_queue,FUNCTION,"    * find");
     82
     83                  // find
     84                  ack [num_rename_unit][num_inst_rename] = true;
     85                  internal_BANK_IN_ACK             [num_bank] = true;
     86                  internal_BANK_IN_NUM_RENAME_UNIT [num_bank] = num_rename_unit;
     87                  internal_BANK_IN_NUM_INST        [num_bank] = num_inst_rename;
     88                 
     89                  break; // Stop scan
     90                }
     91              else
     92                log_printf(TRACE,Issue_queue,FUNCTION,"    * not find");
     93            }
     94        }
     95   
     96      for (uint32_t i=0; i<_param->_nb_rename_unit; i++)
     97        for (uint32_t j=0; j<_param->_nb_inst_rename[i]; j++)
     98          PORT_WRITE(out_ISSUE_IN_ACK [i][j],ack [i][j]);
     99    }
     100
     101    // ===================================================================
     102    // =====[ ISSUE_OUT ]=================================================
     103    // ===================================================================
     104    {
     105      Tcontrol_t val [_param->_nb_inst_issue];
     106
     107      for (uint32_t i=0; i<_param->_nb_inst_issue; i++)
     108        val [i] = 0;
     109
     110      // From Reexecute_queue
     111
     112//       uint32_t num_reexecute_entry = 0;
     113      for (std::list<entry_t*>::iterator it=_reexecute_queue.begin();
     114           it!=_reexecute_queue.end();
     115           ++it)
     116        {
     117          entry_t* entry = (*it);
     118
     119          for (uint32_t i=0; i<_param->_nb_inst_issue; i++)
     120            // test if no previous transaction and can accept this type
     121            if ((val[i] == 0) and _param->_table_issue_type [i][entry->_type])
     122              {
     123                // find a issue port
     124                val [i] = 1;
    46125           
    47             if (not _issue_queue [num_bank].empty())
    48               {
    49 //              log_printf(TRACE,Issue_queue,FUNCTION,"      * Not Empty !!!");
    50                 val = true;
    51 
    52                 internal_BANK_OUT_NUM_INST [num_bank] = i;
    53                 break; // quit scearch loop
    54               }
    55           }
    56 
    57         PORT_WRITE(out_ISSUE_OUT_VAL [i], val);
    58 
    59         if (val)
    60           {
    61             // have find a bank with a data
    62             internal_BANK_OUT_VAL [num_bank] = true;
    63        
    64             entry_t* entry = _issue_queue [num_bank].front();
    65            
    66             if (_param->_have_port_context_id)
    67             PORT_WRITE(out_ISSUE_OUT_CONTEXT_ID            [i], entry->_context_id           );
    68             if (_param->_have_port_front_end_id)
    69             PORT_WRITE(out_ISSUE_OUT_FRONT_END_ID          [i], entry->_front_end_id         );
    70             if (_param->_have_port_rob_ptr  )
    71             PORT_WRITE(out_ISSUE_OUT_PACKET_ID             [i], entry->_packet_id            );
    72             PORT_WRITE(out_ISSUE_OUT_OPERATION             [i], entry->_operation            );
    73             PORT_WRITE(out_ISSUE_OUT_TYPE                  [i], entry->_type                 );
    74             PORT_WRITE(out_ISSUE_OUT_STORE_QUEUE_PTR_WRITE [i], entry->_store_queue_ptr_write);
    75             if (_param->_have_port_load_queue_ptr)
    76             PORT_WRITE(out_ISSUE_OUT_LOAD_QUEUE_PTR_WRITE  [i], entry->_load_queue_ptr_write );
    77             PORT_WRITE(out_ISSUE_OUT_HAS_IMMEDIAT          [i], entry->_has_immediat         );
    78             PORT_WRITE(out_ISSUE_OUT_IMMEDIAT              [i], entry->_immediat             );
    79             PORT_WRITE(out_ISSUE_OUT_READ_RA               [i], entry->_read_ra              );
    80             PORT_WRITE(out_ISSUE_OUT_NUM_REG_RA            [i], entry->_num_reg_ra           );
    81             PORT_WRITE(out_ISSUE_OUT_READ_RB               [i], entry->_read_rb              );
    82             PORT_WRITE(out_ISSUE_OUT_NUM_REG_RB            [i], entry->_num_reg_rb           );
    83             PORT_WRITE(out_ISSUE_OUT_READ_RC               [i], entry->_read_rc              );
    84             PORT_WRITE(out_ISSUE_OUT_NUM_REG_RC            [i], entry->_num_reg_rc           );
    85             PORT_WRITE(out_ISSUE_OUT_WRITE_RD              [i], entry->_write_rd             );
    86             PORT_WRITE(out_ISSUE_OUT_NUM_REG_RD            [i], entry->_num_reg_rd           );
    87             PORT_WRITE(out_ISSUE_OUT_WRITE_RE              [i], entry->_write_re             );
    88             PORT_WRITE(out_ISSUE_OUT_NUM_REG_RE            [i], entry->_num_reg_re           );
    89           }
    90 
    91         num_bank_offset += _param->_nb_bank_select_out;
    92       }
     126                if (_param->_have_port_context_id)
     127                PORT_WRITE(out_ISSUE_OUT_CONTEXT_ID            [i], entry->_context_id           );
     128                if (_param->_have_port_front_end_id)
     129                PORT_WRITE(out_ISSUE_OUT_FRONT_END_ID          [i], entry->_front_end_id         );
     130                if (_param->_have_port_rob_ptr  )
     131                PORT_WRITE(out_ISSUE_OUT_PACKET_ID             [i], entry->_packet_id            );
     132                PORT_WRITE(out_ISSUE_OUT_OPERATION             [i], entry->_operation            );
     133                PORT_WRITE(out_ISSUE_OUT_TYPE                  [i], entry->_type                 );
     134                PORT_WRITE(out_ISSUE_OUT_STORE_QUEUE_PTR_WRITE [i], entry->_store_queue_ptr_write);
     135                if (_param->_have_port_load_queue_ptr)
     136                PORT_WRITE(out_ISSUE_OUT_LOAD_QUEUE_PTR_WRITE  [i], entry->_load_queue_ptr_write );
     137                PORT_WRITE(out_ISSUE_OUT_HAS_IMMEDIAT          [i], entry->_has_immediat         );
     138                PORT_WRITE(out_ISSUE_OUT_IMMEDIAT              [i], entry->_immediat             );
     139                PORT_WRITE(out_ISSUE_OUT_READ_RA               [i], entry->_read_ra              );
     140                PORT_WRITE(out_ISSUE_OUT_NUM_REG_RA            [i], entry->_num_reg_ra           );
     141                PORT_WRITE(out_ISSUE_OUT_READ_RB               [i], entry->_read_rb              );
     142                PORT_WRITE(out_ISSUE_OUT_NUM_REG_RB            [i], entry->_num_reg_rb           );
     143                PORT_WRITE(out_ISSUE_OUT_READ_RC               [i], entry->_read_rc              );
     144                PORT_WRITE(out_ISSUE_OUT_NUM_REG_RC            [i], entry->_num_reg_rc           );
     145                PORT_WRITE(out_ISSUE_OUT_WRITE_RD              [i], entry->_write_rd             );
     146                PORT_WRITE(out_ISSUE_OUT_NUM_REG_RD            [i], entry->_num_reg_rd           );
     147                PORT_WRITE(out_ISSUE_OUT_WRITE_RE              [i], entry->_write_re             );
     148                PORT_WRITE(out_ISSUE_OUT_NUM_REG_RE            [i], entry->_num_reg_re           );
     149
     150                internal_ISSUE_OUT_FROM_REEXECUTE [i] = true;
     151//              internal_ISSUE_OUT_NUM_BANK       [i] = num_reexecute_entry;
     152                internal_ISSUE_OUT_ENTRY          [i] = entry;
     153
     154                break; // stop scan
     155              }
     156//           num_reexecute_entry ++;
     157        }
     158
     159      // From Issue_queue
     160
     161      std::list<generic::priority::select_t> * select = _priority_out->select(); // same select for all issue
     162
     163      for (std::list<generic::priority::select_t>::iterator it=select->begin();
     164           it!=select->end();
     165           it++)
     166        {
     167          uint32_t num_bank=it->grp;
     168
     169//        log_printf(TRACE,Issue_queue,Issue_queue,FUNCTION,"    * Bank [%d]",num_bank);
     170
     171          // Have instruction ?
     172          if (not _issue_queue [num_bank].empty())
     173            {
     174//            log_printf(TRACE,Issue_queue,Issue_queue,FUNCTION,"      * Not Empty !!!");
     175
     176              entry_t* entry = _issue_queue [num_bank].front();
     177             
     178              for (uint32_t i=0; i<_param->_nb_inst_issue; i++)
     179                // test if no previous transaction and can accept this type
     180                if ((val[i] == 0) and _param->_table_issue_type [i][entry->_type])
     181                  {
     182                    // find a issue port
     183                    val [i] = 1;
     184
     185                    if (_param->_have_port_context_id)
     186                    PORT_WRITE(out_ISSUE_OUT_CONTEXT_ID            [i], entry->_context_id           );
     187                    if (_param->_have_port_front_end_id)
     188                    PORT_WRITE(out_ISSUE_OUT_FRONT_END_ID          [i], entry->_front_end_id         );
     189                    if (_param->_have_port_rob_ptr  )
     190                    PORT_WRITE(out_ISSUE_OUT_PACKET_ID             [i], entry->_packet_id            );
     191                    PORT_WRITE(out_ISSUE_OUT_OPERATION             [i], entry->_operation            );
     192                    PORT_WRITE(out_ISSUE_OUT_TYPE                  [i], entry->_type                 );
     193                    PORT_WRITE(out_ISSUE_OUT_STORE_QUEUE_PTR_WRITE [i], entry->_store_queue_ptr_write);
     194                    if (_param->_have_port_load_queue_ptr)
     195                    PORT_WRITE(out_ISSUE_OUT_LOAD_QUEUE_PTR_WRITE  [i], entry->_load_queue_ptr_write );
     196                    PORT_WRITE(out_ISSUE_OUT_HAS_IMMEDIAT          [i], entry->_has_immediat         );
     197                    PORT_WRITE(out_ISSUE_OUT_IMMEDIAT              [i], entry->_immediat             );
     198                    PORT_WRITE(out_ISSUE_OUT_READ_RA               [i], entry->_read_ra              );
     199                    PORT_WRITE(out_ISSUE_OUT_NUM_REG_RA            [i], entry->_num_reg_ra           );
     200                    PORT_WRITE(out_ISSUE_OUT_READ_RB               [i], entry->_read_rb              );
     201                    PORT_WRITE(out_ISSUE_OUT_NUM_REG_RB            [i], entry->_num_reg_rb           );
     202                    PORT_WRITE(out_ISSUE_OUT_READ_RC               [i], entry->_read_rc              );
     203                    PORT_WRITE(out_ISSUE_OUT_NUM_REG_RC            [i], entry->_num_reg_rc           );
     204                    PORT_WRITE(out_ISSUE_OUT_WRITE_RD              [i], entry->_write_rd             );
     205                    PORT_WRITE(out_ISSUE_OUT_NUM_REG_RD            [i], entry->_num_reg_rd           );
     206                    PORT_WRITE(out_ISSUE_OUT_WRITE_RE              [i], entry->_write_re             );
     207                    PORT_WRITE(out_ISSUE_OUT_NUM_REG_RE            [i], entry->_num_reg_re           );
     208                   
     209                    internal_ISSUE_OUT_FROM_REEXECUTE [i] = false;
     210                    internal_ISSUE_OUT_NUM_BANK       [i] = num_bank;
     211                    internal_ISSUE_OUT_ENTRY          [i] = entry;
     212
     213                    break; // stop scan
     214                  }
     215            }
     216        }
     217
     218      for (uint32_t i=0; i<_param->_nb_inst_issue; i++)
     219        {
     220          internal_ISSUE_OUT_VAL [i] = val [i];
     221          PORT_WRITE(out_ISSUE_OUT_VAL [i], internal_ISSUE_OUT_VAL [i]);
     222        }
     223    }
    93224
    94225    log_end(Issue_queue,FUNCTION);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/src/Issue_queue_transition.cpp

    r109 r110  
    3232        for (uint32_t i=0; i<_param->_nb_bank; i++)
    3333          _issue_queue [i].clear();
     34        _reexecute_queue.clear();
    3435      }
    3536    else
    … …  
    4243        // =====[ ISSUE_IN ]==================================================
    4344        // ===================================================================
     45
    4446        for (uint32_t i=0; i<_param->_nb_bank; i++)
    4547          if (internal_BANK_IN_ACK [i])
    4648            {
    47               entry_t * entry = NULL;
    48 
    49               if (internal_BANK_IN_IS_REEXECUTE [i])
    50                 {
    51                   uint32_t y = internal_BANK_IN_NUM_INST [i];
    52              
    53                   if (PORT_READ(in_REEXECUTE_VAL [y]))
    54                     {
    55                       log_printf(TRACE,Issue_queue,FUNCTION,"  * ISSUE_IN [%d] - Transaction with REEXECUTE [%d]",i,y);
     49              uint32_t x = internal_BANK_IN_NUM_RENAME_UNIT [i];
     50              uint32_t y = internal_BANK_IN_NUM_INST [i];
     51             
     52              if (PORT_READ(in_ISSUE_IN_VAL[x][y]))
     53                {
     54                  log_printf(TRACE,Issue_queue,FUNCTION,"  * ISSUE_IN [%d] - Transaction with ISSUE_IN [%d][%d]",i,x,y);
     55
    5656#ifdef STATISTICS
    57                       if (usage_is_set(_usage,USE_STATISTICS))
    58                         (*_stat_nb_inst_reexecute) ++;
    59 #endif
    60                       entry = new entry_t
    61                         (
    62                          (_param->_have_port_context_id    )?PORT_READ(in_REEXECUTE_CONTEXT_ID            [y]):0,
    63                          (_param->_have_port_front_end_id  )?PORT_READ(in_REEXECUTE_FRONT_END_ID          [y]):0,
    64                          (_param->_have_port_rob_ptr       )?PORT_READ(in_REEXECUTE_PACKET_ID             [y]):0,
    65                                                              PORT_READ(in_REEXECUTE_OPERATION             [y]),
    66                                                              PORT_READ(in_REEXECUTE_TYPE                  [y]),
    67                                                              PORT_READ(in_REEXECUTE_STORE_QUEUE_PTR_WRITE [y]),
    68                          (_param->_have_port_load_queue_ptr)?PORT_READ(in_REEXECUTE_LOAD_QUEUE_PTR_WRITE  [y]):0,
    69                                                              PORT_READ(in_REEXECUTE_HAS_IMMEDIAT          [y]),
    70                                                              PORT_READ(in_REEXECUTE_IMMEDIAT              [y]),
    71                                                              PORT_READ(in_REEXECUTE_READ_RA               [y]),
    72                                                              PORT_READ(in_REEXECUTE_NUM_REG_RA            [y]),
    73                                                              PORT_READ(in_REEXECUTE_READ_RB               [y]),
    74                                                              PORT_READ(in_REEXECUTE_NUM_REG_RB            [y]),
    75                                                              PORT_READ(in_REEXECUTE_READ_RC               [y]),
    76                                                              PORT_READ(in_REEXECUTE_NUM_REG_RC            [y]),
    77                                                              PORT_READ(in_REEXECUTE_WRITE_RD              [y]),
    78                                                              PORT_READ(in_REEXECUTE_NUM_REG_RD            [y]),
    79                                                              PORT_READ(in_REEXECUTE_WRITE_RE              [y]),
    80                                                              PORT_READ(in_REEXECUTE_NUM_REG_RE            [y])
    81                          );
    82                     }
    83                 }
    84               else
    85                 {
    86                   uint32_t x = internal_BANK_IN_NUM_RENAME_UNIT [i];
    87                   uint32_t y = internal_BANK_IN_NUM_INST [i];
    88 
    89                   if (PORT_READ(in_ISSUE_IN_VAL[x][y]))
    90                     {
    91                       log_printf(TRACE,Issue_queue,FUNCTION,"  * ISSUE_IN [%d] - Transaction with ISSUE_IN [%d][%d]",i,x,y);
    92 
     57                  if (usage_is_set(_usage,USE_STATISTICS))
     58                    (*_stat_nb_inst_issue_in [x]) ++;
     59#endif
     60                  entry_t * entry = new entry_t
     61                    (
     62                     (_param->_have_port_context_id    )?PORT_READ(in_ISSUE_IN_CONTEXT_ID            [x][y]):0,
     63                     (_param->_have_port_front_end_id  )?PORT_READ(in_ISSUE_IN_FRONT_END_ID          [x][y]):0,
     64                     (_param->_have_port_rob_ptr       )?PORT_READ(in_ISSUE_IN_PACKET_ID             [x][y]):0,
     65                                                         PORT_READ(in_ISSUE_IN_OPERATION             [x][y]),
     66                                                         PORT_READ(in_ISSUE_IN_TYPE                  [x][y]),
     67                                                         PORT_READ(in_ISSUE_IN_STORE_QUEUE_PTR_WRITE [x][y]),
     68                     (_param->_have_port_load_queue_ptr)?PORT_READ(in_ISSUE_IN_LOAD_QUEUE_PTR_WRITE  [x][y]):0,
     69                                                         PORT_READ(in_ISSUE_IN_HAS_IMMEDIAT          [x][y]),
     70                                                         PORT_READ(in_ISSUE_IN_IMMEDIAT              [x][y]),
     71                                                         PORT_READ(in_ISSUE_IN_READ_RA               [x][y]),
     72                                                         PORT_READ(in_ISSUE_IN_NUM_REG_RA            [x][y]),
     73                                                         PORT_READ(in_ISSUE_IN_READ_RB               [x][y]),
     74                                                         PORT_READ(in_ISSUE_IN_NUM_REG_RB            [x][y]),
     75                                                         PORT_READ(in_ISSUE_IN_READ_RC               [x][y]),
     76                                                         PORT_READ(in_ISSUE_IN_NUM_REG_RC            [x][y]),
     77                                                         PORT_READ(in_ISSUE_IN_WRITE_RD              [x][y]),
     78                                                         PORT_READ(in_ISSUE_IN_NUM_REG_RD            [x][y]),
     79                                                         PORT_READ(in_ISSUE_IN_WRITE_RE              [x][y]),
     80                                                         PORT_READ(in_ISSUE_IN_NUM_REG_RE            [x][y])
     81                     );
     82
     83                  _issue_queue [i].push_back(entry);
     84                }
     85            }
     86
     87        // ===================================================================
     88        // =====[ REEXECUTE_UNIT ]============================================
     89        // ===================================================================
     90
     91        for (uint32_t i=0; i<_param->_nb_inst_reexecute; ++i)
     92          if (PORT_READ(in_REEXECUTE_VAL [i]) and internal_REEXECUTE_ACK [i])
     93            {
     94              log_printf(TRACE,Issue_queue,FUNCTION,"  * REEXECUTE [%d]",i);
    9395#ifdef STATISTICS
    94                       if (usage_is_set(_usage,USE_STATISTICS))
    95                         (*_stat_nb_inst_issue_in [x]) ++;
    96 #endif
    97                       entry = new entry_t
    98                         (
    99                          (_param->_have_port_context_id    )?PORT_READ(in_ISSUE_IN_CONTEXT_ID            [x][y]):0,
    100                          (_param->_have_port_front_end_id  )?PORT_READ(in_ISSUE_IN_FRONT_END_ID          [x][y]):0,
    101                          (_param->_have_port_rob_ptr       )?PORT_READ(in_ISSUE_IN_PACKET_ID             [x][y]):0,
    102                                                              PORT_READ(in_ISSUE_IN_OPERATION             [x][y]),
    103                                                              PORT_READ(in_ISSUE_IN_TYPE                  [x][y]),
    104                                                              PORT_READ(in_ISSUE_IN_STORE_QUEUE_PTR_WRITE [x][y]),
    105                          (_param->_have_port_load_queue_ptr)?PORT_READ(in_ISSUE_IN_LOAD_QUEUE_PTR_WRITE  [x][y]):0,
    106                                                              PORT_READ(in_ISSUE_IN_HAS_IMMEDIAT          [x][y]),
    107                                                              PORT_READ(in_ISSUE_IN_IMMEDIAT              [x][y]),
    108                                                              PORT_READ(in_ISSUE_IN_READ_RA               [x][y]),
    109                                                              PORT_READ(in_ISSUE_IN_NUM_REG_RA            [x][y]),
    110                                                              PORT_READ(in_ISSUE_IN_READ_RB               [x][y]),
    111                                                              PORT_READ(in_ISSUE_IN_NUM_REG_RB            [x][y]),
    112                                                              PORT_READ(in_ISSUE_IN_READ_RC               [x][y]),
    113                                                              PORT_READ(in_ISSUE_IN_NUM_REG_RC            [x][y]),
    114                                                              PORT_READ(in_ISSUE_IN_WRITE_RD              [x][y]),
    115                                                              PORT_READ(in_ISSUE_IN_NUM_REG_RD            [x][y]),
    116                                                              PORT_READ(in_ISSUE_IN_WRITE_RE              [x][y]),
    117                                                              PORT_READ(in_ISSUE_IN_NUM_REG_RE            [x][y])
    118                          );
    119                     }
    120                 }
    121 
    122               if (entry != NULL)
    123                 _issue_queue [i].push_back(entry);
    124             }
     96              if (usage_is_set(_usage,USE_STATISTICS))
     97                (*_stat_nb_inst_reexecute) ++;
     98#endif
     99              entry_t * entry = new entry_t
     100                (
     101                 (_param->_have_port_context_id    )?PORT_READ(in_REEXECUTE_CONTEXT_ID            [i]):0,
     102                 (_param->_have_port_front_end_id  )?PORT_READ(in_REEXECUTE_FRONT_END_ID          [i]):0,
     103                 (_param->_have_port_rob_ptr       )?PORT_READ(in_REEXECUTE_PACKET_ID             [i]):0,
     104                                                     PORT_READ(in_REEXECUTE_OPERATION             [i]),
     105                                                     PORT_READ(in_REEXECUTE_TYPE                  [i]),
     106                                                     PORT_READ(in_REEXECUTE_STORE_QUEUE_PTR_WRITE [i]),
     107                 (_param->_have_port_load_queue_ptr)?PORT_READ(in_REEXECUTE_LOAD_QUEUE_PTR_WRITE  [i]):0,
     108                                                     PORT_READ(in_REEXECUTE_HAS_IMMEDIAT          [i]),
     109                                                     PORT_READ(in_REEXECUTE_IMMEDIAT              [i]),
     110                                                     PORT_READ(in_REEXECUTE_READ_RA               [i]),
     111                                                     PORT_READ(in_REEXECUTE_NUM_REG_RA            [i]),
     112                                                     PORT_READ(in_REEXECUTE_READ_RB               [i]),
     113                                                     PORT_READ(in_REEXECUTE_NUM_REG_RB            [i]),
     114                                                     PORT_READ(in_REEXECUTE_READ_RC               [i]),
     115                                                     PORT_READ(in_REEXECUTE_NUM_REG_RC            [i]),
     116                                                     PORT_READ(in_REEXECUTE_WRITE_RD              [i]),
     117                                                     PORT_READ(in_REEXECUTE_NUM_REG_RD            [i]),
     118                                                     PORT_READ(in_REEXECUTE_WRITE_RE              [i]),
     119                                                     PORT_READ(in_REEXECUTE_NUM_REG_RE            [i])
     120                 );
     121
     122              _reexecute_queue.push_back(entry);
     123            }
    125124
    126125        // ===================================================================
    127126        // =====[ ISSUE_OUT ]=================================================
    128127        // ===================================================================
    129         for (uint32_t i=0; i<_param->_nb_bank; i++)
    130           {
    131 //          log_printf(TRACE,Issue_queue,FUNCTION,"  * internal_BANK_OUT [%d] val %d, num_inst %d",i,internal_BANK_OUT_VAL [i],internal_BANK_OUT_NUM_INST [i]);
    132 
    133             if (internal_BANK_OUT_VAL [i])
    134               {
    135 #ifdef STATISTICS
    136                 if (usage_is_set(_usage,USE_STATISTICS))
    137                   (*_stat_nb_inst_issue_out) ++;
    138 #endif
    139 
    140                 uint32_t x = internal_BANK_OUT_NUM_INST [i];
    141 //              log_printf(TRACE,Issue_queue,FUNCTION,"    * ISSUE_OUT_ACK : %d",PORT_READ(in_ISSUE_OUT_ACK [x]));
    142                
    143                 if (PORT_READ(in_ISSUE_OUT_ACK [x]))
    144                   {
    145                     log_printf(TRACE,Issue_queue,FUNCTION,"  * ISSUE_OUT [%d] - Transaction with ISSUE_OUT [%d]",i,x);
    146 
    147 
    148                     entry_t * entry =  _issue_queue [i].front();
    149                     _issue_queue [i].pop_front();
    150                     delete entry;
    151                   }
    152               }
    153           }
     128
     129        for (uint32_t i=0; i<_param->_nb_inst_issue; ++i)
     130          if (internal_ISSUE_OUT_VAL [i] and PORT_READ(in_ISSUE_OUT_ACK [i]))
     131            {
     132              entry_t * entry    = internal_ISSUE_OUT_ENTRY    [i];
     133
     134              if (internal_ISSUE_OUT_FROM_REEXECUTE [i])
     135                {
     136                  log_printf(TRACE,Issue_queue,FUNCTION,"  * ISSUE_OUT [%d] - From Reexecute_queue",i);
     137                 
     138                  _reexecute_queue.remove(entry);
     139                }
     140              else
     141                {
     142                  // front ...
     143                  uint32_t  num_bank = internal_ISSUE_OUT_NUM_BANK [i];
     144
     145                  log_printf(TRACE,Issue_queue,FUNCTION,"  * ISSUE_OUT [%d] - From issue_queue [%d]",i,num_bank);
     146
     147                  _issue_queue [num_bank].remove(entry);
     148                }
     149
     150              delete entry;
     151            }
    154152      }
    155153
     154#if defined(DEBUG) and defined(DEBUG_Issue_queue) and (DEBUG >= DEBUG_TRACE)
    156155    log_printf(TRACE,Issue_queue,FUNCTION,"  * Dump Issue_queue");
     156
    157157    for (uint32_t i=0; i<_param->_nb_bank; i++)
    158158      {
    159 #ifdef STATISTICS
    160         if (usage_is_set(_usage,USE_STATISTICS))
    161           *(_stat_bank_nb_inst [i]) += _issue_queue[i].size();
    162 #endif
    163159        log_printf(TRACE,Issue_queue,FUNCTION,"    * Bank [%d] size : %d",i,(int)_issue_queue[i].size());
    164160
    … …  
    199195                ++j;
    200196              }
    201 
    202197      }
     198
     199    {
     200      log_printf(TRACE,Issue_queue,FUNCTION,"    * Reexecute_queue - size : %d",(int)_reexecute_queue.size());
     201     
     202      uint32_t i = 0;
     203
     204      for (std::list<entry_t*>::iterator it=_reexecute_queue.begin();it!=_reexecute_queue.end(); ++it)
     205        {
     206          log_printf(TRACE,Issue_queue,FUNCTION,"      [%.4d] %.2d %.2d %.4d, %.2d %.3d, %.2d %.2d, %.1d %.8x, %.1d %.4d, %.1d %.4d, %.1d %.4d, %.1d %.4d, %.1d %.4d",
     207                     i,
     208                     
     209                     (*it)->_context_id           ,
     210                     (*it)->_front_end_id         ,
     211                     (*it)->_packet_id            ,
     212                     
     213                     (*it)->_type                 ,
     214                     (*it)->_operation            ,
     215                     
     216                     (*it)->_store_queue_ptr_write,
     217                     (*it)->_load_queue_ptr_write ,
     218                     
     219                     (*it)->_has_immediat         ,
     220                     (*it)->_immediat             ,
     221                     
     222                     (*it)->_read_ra              ,
     223                     (*it)->_num_reg_ra           ,
     224                     
     225                     (*it)->_read_rb              ,
     226                     (*it)->_num_reg_rb           ,
     227                     
     228                     (*it)->_read_rc              ,
     229                     (*it)->_num_reg_rc           ,
     230                     
     231                     (*it)->_write_rd             ,
     232                     (*it)->_num_reg_rd           ,
     233                     
     234                     (*it)->_write_re             ,
     235                     (*it)->_num_reg_re           );
     236          ++i;
     237        }
     238    }
     239#endif
     240
     241#ifdef STATISTICS
     242    if (usage_is_set(_usage,USE_STATISTICS))
     243      for (uint32_t i=0; i<_param->_nb_bank; i++)
     244        *(_stat_bank_nb_inst [i]) += _issue_queue[i].size();
     245#endif
    203246
    204247#if defined(STATISTICS) or defined(VHDL_TESTBENCH)

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/src/Parameters.cpp

    r109 r110  
    5656    _table_routing            = table_routing        ;
    5757    _table_issue_type         = table_issue_type     ;
     58    _size_reexecute_queue     = nb_inst_reexecute    ;
    5859
    5960    log_printf(TRACE,Issue_queue,FUNCTION,"  * table_routing [nb_rename_unit][nb_inst_issue]");
    … …  
    7071   
    7172    _max_nb_inst_rename       = max<uint32_t>(_nb_inst_rename,_nb_rename_unit);
    72     _nb_bank_select_out       = _nb_bank/nb_inst_issue;
    7373
    7474    _size_bank                = _size_queue / _nb_bank;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/OOO_Engine_Glue/SelfTest/src/test.cpp

    r88 r110  
    2626//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
    2727//   _usage = usage_unset(_usage,USE_POSITION             );
    28    _usage = usage_unset(_usage,USE_STATISTICS           );
     28//   _usage = usage_unset(_usage,USE_STATISTICS           );
    2929//   _usage = usage_unset(_usage,USE_INFORMATION          );
    3030

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/OOO_Engine_Glue/include/OOO_Engine_Glue.h

    r88 r110  
    5252#ifdef STATISTICS
    5353  public    : Stat                           * _stat;
     54
     55  private   : counter_t                      * _stat_nb_inst_issue_stall_by_registerfile;
     56//private   : counter_t                      * _stat_nb_inst_issue_stall_by_rename_unit ;
     57  private   : counter_t                      * _stat_nb_inst_issue_stall_by_commit_unit ;
     58  private   : counter_t                      * _stat_nb_inst_issue_stall_by_issue_queue ;
    5459#endif
    5560
    … …  
    122127  public    : SC_OUT(Tspecial_address_t ) *** out_INSERT_COMMIT_UNIT_NUM_REG_RE_PHY_NEW        ;//[nb_rename_unit][nb_inst_insert]
    123128
    124   public    : SC_OUT(Tcontrol_t         ) *** out_INSERT_ISSUE_QUEUE_VAL                       ;//[nb_rename_unit][nb_inst_rename]
    125   public    : SC_IN (Tcontrol_t         ) ***  in_INSERT_ISSUE_QUEUE_ACK                       ;//[nb_rename_unit][nb_inst_rename]
    126   public    : SC_OUT(Tcontext_t         ) *** out_INSERT_ISSUE_QUEUE_CONTEXT_ID                ;//[nb_rename_unit][nb_inst_rename]
    127   public    : SC_OUT(Tcontext_t         ) *** out_INSERT_ISSUE_QUEUE_FRONT_END_ID              ;//[nb_rename_unit][nb_inst_rename]
    128   public    : SC_OUT(Toperation_t       ) *** out_INSERT_ISSUE_QUEUE_OPERATION                 ;//[nb_rename_unit][nb_inst_rename]
    129   public    : SC_OUT(Ttype_t            ) *** out_INSERT_ISSUE_QUEUE_TYPE                      ;//[nb_rename_unit][nb_inst_rename]
    130   public    : SC_OUT(Tlsq_ptr_t         ) *** out_INSERT_ISSUE_QUEUE_STORE_QUEUE_PTR_WRITE     ;//[nb_rename_unit][nb_inst_rename]
    131   public    : SC_OUT(Tlsq_ptr_t         ) *** out_INSERT_ISSUE_QUEUE_LOAD_QUEUE_PTR_WRITE      ;//[nb_rename_unit][nb_inst_rename]
    132   public    : SC_OUT(Tcontrol_t         ) *** out_INSERT_ISSUE_QUEUE_HAS_IMMEDIAT              ;//[nb_rename_unit][nb_inst_rename]
    133   public    : SC_OUT(Tgeneral_data_t    ) *** out_INSERT_ISSUE_QUEUE_IMMEDIAT                  ;//[nb_rename_unit][nb_inst_rename]
    134   public    : SC_OUT(Tcontrol_t         ) *** out_INSERT_ISSUE_QUEUE_READ_RA                   ;//[nb_rename_unit][nb_inst_rename]
    135   public    : SC_OUT(Tgeneral_address_t ) *** out_INSERT_ISSUE_QUEUE_NUM_REG_RA                ;//[nb_rename_unit][nb_inst_rename]
    136   public    : SC_OUT(Tcontrol_t         ) *** out_INSERT_ISSUE_QUEUE_READ_RB                   ;//[nb_rename_unit][nb_inst_rename]
    137   public    : SC_OUT(Tgeneral_address_t ) *** out_INSERT_ISSUE_QUEUE_NUM_REG_RB                ;//[nb_rename_unit][nb_inst_rename]
    138   public    : SC_OUT(Tcontrol_t         ) *** out_INSERT_ISSUE_QUEUE_READ_RC                   ;//[nb_rename_unit][nb_inst_rename]
    139   public    : SC_OUT(Tspecial_address_t ) *** out_INSERT_ISSUE_QUEUE_NUM_REG_RC                ;//[nb_rename_unit][nb_inst_rename]
    140   public    : SC_OUT(Tcontrol_t         ) *** out_INSERT_ISSUE_QUEUE_WRITE_RD                  ;//[nb_rename_unit][nb_inst_rename]
    141   public    : SC_OUT(Tgeneral_address_t ) *** out_INSERT_ISSUE_QUEUE_NUM_REG_RD                ;//[nb_rename_unit][nb_inst_rename]
    142   public    : SC_OUT(Tcontrol_t         ) *** out_INSERT_ISSUE_QUEUE_WRITE_RE                  ;//[nb_rename_unit][nb_inst_rename]
    143   public    : SC_OUT(Tspecial_address_t ) *** out_INSERT_ISSUE_QUEUE_NUM_REG_RE                ;//[nb_rename_unit][nb_inst_rename]
     129  public    : SC_OUT(Tcontrol_t         ) *** out_INSERT_ISSUE_QUEUE_VAL                       ;//[nb_rename_unit][nb_inst_insert]
     130  public    : SC_IN (Tcontrol_t         ) ***  in_INSERT_ISSUE_QUEUE_ACK                       ;//[nb_rename_unit][nb_inst_insert]
     131  public    : SC_OUT(Tcontext_t         ) *** out_INSERT_ISSUE_QUEUE_CONTEXT_ID                ;//[nb_rename_unit][nb_inst_insert]
     132  public    : SC_OUT(Tcontext_t         ) *** out_INSERT_ISSUE_QUEUE_FRONT_END_ID              ;//[nb_rename_unit][nb_inst_insert]
     133  public    : SC_OUT(Toperation_t       ) *** out_INSERT_ISSUE_QUEUE_OPERATION                 ;//[nb_rename_unit][nb_inst_insert]
     134  public    : SC_OUT(Ttype_t            ) *** out_INSERT_ISSUE_QUEUE_TYPE                      ;//[nb_rename_unit][nb_inst_insert]
     135  public    : SC_OUT(Tlsq_ptr_t         ) *** out_INSERT_ISSUE_QUEUE_STORE_QUEUE_PTR_WRITE     ;//[nb_rename_unit][nb_inst_insert]
     136  public    : SC_OUT(Tlsq_ptr_t         ) *** out_INSERT_ISSUE_QUEUE_LOAD_QUEUE_PTR_WRITE      ;//[nb_rename_unit][nb_inst_insert]
     137  public    : SC_OUT(Tcontrol_t         ) *** out_INSERT_ISSUE_QUEUE_HAS_IMMEDIAT              ;//[nb_rename_unit][nb_inst_insert]
     138  public    : SC_OUT(Tgeneral_data_t    ) *** out_INSERT_ISSUE_QUEUE_IMMEDIAT                  ;//[nb_rename_unit][nb_inst_insert]
     139  public    : SC_OUT(Tcontrol_t         ) *** out_INSERT_ISSUE_QUEUE_READ_RA                   ;//[nb_rename_unit][nb_inst_insert]
     140  public    : SC_OUT(Tgeneral_address_t ) *** out_INSERT_ISSUE_QUEUE_NUM_REG_RA                ;//[nb_rename_unit][nb_inst_insert]
     141  public    : SC_OUT(Tcontrol_t         ) *** out_INSERT_ISSUE_QUEUE_READ_RB                   ;//[nb_rename_unit][nb_inst_insert]
     142  public    : SC_OUT(Tgeneral_address_t ) *** out_INSERT_ISSUE_QUEUE_NUM_REG_RB                ;//[nb_rename_unit][nb_inst_insert]
     143  public    : SC_OUT(Tcontrol_t         ) *** out_INSERT_ISSUE_QUEUE_READ_RC                   ;//[nb_rename_unit][nb_inst_insert]
     144  public    : SC_OUT(Tspecial_address_t ) *** out_INSERT_ISSUE_QUEUE_NUM_REG_RC                ;//[nb_rename_unit][nb_inst_insert]
     145  public    : SC_OUT(Tcontrol_t         ) *** out_INSERT_ISSUE_QUEUE_WRITE_RD                  ;//[nb_rename_unit][nb_inst_insert]
     146  public    : SC_OUT(Tgeneral_address_t ) *** out_INSERT_ISSUE_QUEUE_NUM_REG_RD                ;//[nb_rename_unit][nb_inst_insert]
     147  public    : SC_OUT(Tcontrol_t         ) *** out_INSERT_ISSUE_QUEUE_WRITE_RE                  ;//[nb_rename_unit][nb_inst_insert]
     148  public    : SC_OUT(Tspecial_address_t ) *** out_INSERT_ISSUE_QUEUE_NUM_REG_RE                ;//[nb_rename_unit][nb_inst_insert]
    144149
    145150//     // ~~~~~[ Interface "retire" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/OOO_Engine_Glue/src/OOO_Engine_Glue_genMealy_insert_valack.cpp

    r109 r110  
    5959                                          commit_unit_ack        and
    6060                                          not rename_unit_no_execute);
    61            
     61
    6262            PORT_WRITE(out_INSERT_VAL             [x]   ,val            );
    6363            PORT_WRITE(out_INSERT_RENAME_UNIT_ACK [i][j],rename_unit_ack);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/OOO_Engine_Glue/src/OOO_Engine_Glue_statistics_allocation.cpp

    r88 r110  
    2626                      "OOO_Engine_Glue",
    2727                      param_statistics);
     28
     29    _stat_nb_inst_issue_stall_by_registerfile = _stat->create_variable("nb_inst_issue_stall_by_registerfile");
     30//  _stat_nb_inst_issue_stall_by_rename_unit  = _stat->create_variable("nb_inst_issue_stall_by_rename_unit" );
     31    _stat_nb_inst_issue_stall_by_commit_unit  = _stat->create_variable("nb_inst_issue_stall_by_commit_unit" );
     32    _stat_nb_inst_issue_stall_by_issue_queue  = _stat->create_variable("nb_inst_issue_stall_by_issue_queue" );
     33
     34//     std::string nb_inst_issue_stall = "+ + nb_inst_issue_stall_by_registerfile nb_inst_issue_stall_by_rename_unit + nb_inst_issue_stall_by_commit_unit nb_inst_issue_stall_by_issue_queue";
     35    std::string nb_inst_issue_stall = "+ nb_inst_issue_stall_by_registerfile + nb_inst_issue_stall_by_commit_unit nb_inst_issue_stall_by_issue_queue";
     36
     37    _stat->create_expr_percent ("percent_issue_stall_by_registerfile", "nb_inst_issue_stall_by_registerfile", nb_inst_issue_stall, _("Percent of instruction stalled by RegisterFile"));
     38//  _stat->create_expr_percent ("percent_issue_stall_by_rename_unit" , "nb_inst_issue_stall_by_rename_unit" , nb_inst_issue_stall, _("Percent of instruction stalled by Rename_Unit") );
     39    _stat->create_expr_percent ("percent_issue_stall_by_commit_unit" , "nb_inst_issue_stall_by_commit_unit" , nb_inst_issue_stall, _("Percent of instruction stalled by Commit_Unit") );
     40    _stat->create_expr_percent ("percent_issue_stall_by_issue_queue" , "nb_inst_issue_stall_by_issue_queue" , nb_inst_issue_stall, _("Percent of instruction stalled by Issue_Queue") );
    2841   
    2942    log_end(OOO_Engine_Glue,FUNCTION);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/OOO_Engine_Glue/src/OOO_Engine_Glue_transition.cpp

    r88 r110  
    2323    log_begin(OOO_Engine_Glue,FUNCTION);
    2424
     25#ifdef STATISTICS
     26    if (usage_is_set(_usage,USE_STATISTICS))
     27      {
     28        uint32_t x=0;
     29        for (uint32_t i=0; i<_param->_nb_rename_unit; ++i)
     30          for (uint32_t j=0; j<_param->_nb_inst_insert[i]; ++j)
     31            {
     32              if (PORT_READ(in_INSERT_RENAME_UNIT_VAL [i][j]))
     33                {
     34                  if (PORT_READ(in_INSERT_ACK [x]) == 0)
     35                    (*_stat_nb_inst_issue_stall_by_registerfile) ++;
     36                  if (PORT_READ(in_INSERT_COMMIT_UNIT_ACK [i][j]) == 0)
     37                    (*_stat_nb_inst_issue_stall_by_commit_unit ) ++;
     38                  if (PORT_READ(in_INSERT_ISSUE_QUEUE_ACK [i][j]) == 0)
     39                    (*_stat_nb_inst_issue_stall_by_issue_queue ) ++;
     40                }
     41              x++;
     42            }
     43      }
     44#endif
     45
    2546#if defined(STATISTICS) or defined(VHDL_TESTBENCH)
    2647    end_cycle ();

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Load_Store_pointer_unit/SelfTest/configuration.cfg

    r81 r110  
    552       4       *2      # size_store_queue                 [0]    [nb_load_store_queue]
    661       4       *2      # size_load_queue                  [0]    [nb_load_store_queue]
     71       4       *4      # nb_inst_memory                   [0]    [nb_load_store_queue]
    780       0       +1      # link_load_store_unit_with_thread [0][0] [nb_front_end][nb_context]
    891       4       *4      # nb_inst_insert

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Load_Store_pointer_unit/SelfTest/src/main.cpp

    r88 r110  
    1919  err (_(" * size_store_queue                 [nb_load_store_queue]     (uint32_t)\n"));
    2020  err (_(" * size_load_queue                  [nb_load_store_queue]     (uint32_t)\n"));
     21  err (_(" * nb_inst_memory                   [nb_load_store_queue]     (uint32_t)\n"));
    2122  err (_(" * link_load_store_unit_with_thread [nb_front_end][nb_context](uint32_t)\n"));
    2223  err (_(" * nb_inst_insert                                             (uint32_t)\n"));
    … …  
    5354  uint32_t    _nb_load_store_queue              = fromString<uint32_t>(argv[x++]);
    5455 
    55   if (argc != static_cast<int>(2+NB_PARAMS+_nb_front_end+2*_nb_load_store_queue+nb_thread))
     56  if (argc != static_cast<int>(2+NB_PARAMS+_nb_front_end+3*_nb_load_store_queue+nb_thread))
    5657    usage (argc, argv);
    5758
    5859  uint32_t  * _size_store_queue                 = new uint32_t [_nb_load_store_queue];
    5960  uint32_t  * _size_load_queue                  = new uint32_t [_nb_load_store_queue];
     61  uint32_t  * _nb_inst_memory                   = new uint32_t [_nb_load_store_queue];
    6062 
    6163  for (uint32_t i=0; i<_nb_load_store_queue; i++)
    … …  
    6365  for (uint32_t i=0; i<_nb_load_store_queue; i++)
    6466    _size_load_queue  [i] = atoi(argv[x++]);
     67  for (uint32_t i=0; i<_nb_load_store_queue; i++)
     68    _nb_inst_memory   [i] = atoi(argv[x++]);
    6569 
    6670  uint32_t ** _link_load_store_unit_with_thread = new uint32_t * [_nb_front_end];
    … …  
    8488         _size_store_queue                ,
    8589         _size_load_queue                 ,
     90         _nb_inst_memory                  ,
    8691         _link_load_store_unit_with_thread,
    8792         _nb_inst_insert                  ,

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Load_Store_pointer_unit/include/Parameters.h

    r88 r110  
    2929  public : uint32_t  * _size_store_queue                ; //[nb_load_store_queue]
    3030  public : uint32_t  * _size_load_queue                 ; //[nb_load_store_queue]
     31  public : uint32_t  * _nb_inst_memory                  ; //[nb_load_store_queue]
    3132  public : uint32_t ** _link_load_store_unit_with_thread; //[nb_front_end][nb_context]
    3233  public : uint32_t    _nb_inst_insert                  ;
    3334  public : uint32_t    _nb_inst_retire                  ;
     35
     36  public : uint32_t    _max_size_store_queue            ;
     37  public : uint32_t    _max_size_load_queue             ;
    3438
    3539//public : uint32_t    _size_front_end_id               ;
    … …  
    5054                        uint32_t  * size_store_queue                ,
    5155                        uint32_t  * size_load_queue                 ,
     56                        uint32_t  * nb_inst_memory                  ,
    5257                        uint32_t ** link_load_store_unit_with_thread,
    5358                        uint32_t    nb_inst_insert                  ,

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Load_Store_pointer_unit/src/Load_Store_pointer_unit_genMealy_insert.cpp

    r81 r110  
    2222  void Load_Store_pointer_unit::genMealy_insert (void)
    2323  {
    24     log_printf(FUNC,Load_Store_pointer_unit,FUNCTION,"Begin");
     24    log_begin(Load_Store_pointer_unit,FUNCTION);
     25    log_function(Load_Store_pointer_unit,FUNCTION,_name.c_str());
    2526
    26     bool use_lsq [_param->_nb_load_store_queue];
     27    // TODO : limité à nb_inst_memory le nombre d'accès par lsq !!!
     28
     29    uint32_t   nb_use_lsq            [_param->_nb_load_store_queue];
     30    Tlsq_ptr_t STORE_QUEUE_PTR_WRITE [_param->_nb_load_store_queue];
     31    bool       STORE_QUEUE_USE       [_param->_nb_load_store_queue][_param->_max_size_store_queue];
     32    Tlsq_ptr_t STORE_QUEUE_NB_USE    [_param->_nb_load_store_queue];
     33    Tlsq_ptr_t LOAD_QUEUE_PTR_WRITE  [_param->_nb_load_store_queue];
     34    bool       LOAD_QUEUE_USE        [_param->_nb_load_store_queue][_param->_max_size_load_queue];
     35   
    2736    for (uint32_t i=0; i<_param->_nb_load_store_queue; i++)
    28       use_lsq [i] = false;
     37      {
     38        nb_use_lsq            [i] = _param->_nb_inst_memory[i];
     39
     40        STORE_QUEUE_PTR_WRITE [i] = reg_STORE_QUEUE_PTR_WRITE [i];
     41        STORE_QUEUE_NB_USE    [i] = reg_STORE_QUEUE_NB_USE    [i];
     42        LOAD_QUEUE_PTR_WRITE  [i] = reg_LOAD_QUEUE_PTR_WRITE  [i];
     43       
     44        for (uint32_t j=0; j<_param->_size_store_queue[i]; j++)
     45          STORE_QUEUE_USE [i][j] = reg_STORE_QUEUE_USE [i][j];
     46        for (uint32_t j=0; j<_param->_size_load_queue[i]; j++)
     47          LOAD_QUEUE_USE  [i][j] = reg_LOAD_QUEUE_USE  [i][j];
     48      }
    2949
    3050    for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
    3151      {
     52        log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"  * INSERT [%d]",i);
     53
    3254        Tcontrol_t ack                   = false;
    33         Tlsq_ptr_t store_queue_ptr_write = 0;
    34         Tlsq_ptr_t load_queue_ptr_write  = 0;
    3555
    3656        if ( (PORT_READ(in_INSERT_VAL  [i]) == true       ) and
    3757             (PORT_READ(in_INSERT_TYPE [i]) == TYPE_MEMORY))
    3858          {
     59            log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * type is memory");
     60
    3961            Tcontext_t front_end_id = (_param->_have_port_front_end_id)?PORT_READ(in_INSERT_FRONT_END_ID [i]):0;
    4062            Tcontext_t context_id   = (_param->_have_port_context_id  )?PORT_READ(in_INSERT_CONTEXT_ID   [i]):0;
    41            
    4263            uint32_t   lsq          = _param->_link_load_store_unit_with_thread[front_end_id][context_id];
     64
     65            log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * front_end_id : %d",front_end_id);
     66            log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * context_id   : %d",context_id  );
     67            log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * lsq          : %d",lsq         );
    4368
    4469            // Test if a previous instruction use the same lsq
    4570            // Authorize once memory access by load store unit
    46             if (use_lsq [lsq] == false)
     71            if (nb_use_lsq [lsq] > 0)
    4772              {
    48                 use_lsq [lsq] = true;
     73                nb_use_lsq [lsq] --;
    4974
    5075                uint32_t   ptr;
    51                
    52                 store_queue_ptr_write   = reg_STORE_QUEUE_PTR_WRITE [lsq];
    53                 load_queue_ptr_write    = reg_LOAD_QUEUE_PTR_WRITE  [lsq];
     76
     77                PORT_WRITE(out_INSERT_STORE_QUEUE_PTR_WRITE [i], STORE_QUEUE_PTR_WRITE [lsq]);
     78                if (_param->_have_port_load_queue_ptr)
     79                PORT_WRITE(out_INSERT_LOAD_QUEUE_PTR_WRITE  [i], LOAD_QUEUE_PTR_WRITE  [lsq]);
     80
     81                log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * sq_ptr_write : %d",STORE_QUEUE_PTR_WRITE [lsq]);
     82                log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * lq_ptr_write : %d",LOAD_QUEUE_PTR_WRITE [lsq]);
    5483               
    5584                // operation became of decod_stage. Also operation is != store_head_ok and store_head_ko
    5685                if (is_operation_memory_store(PORT_READ(in_INSERT_OPERATION [i])))
    5786                  {
     87                    log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * USE_STORE_QUEUE");
     88               
    5889                    internal_INSERT_OPERATION_USE [i] = OPERATION_USE_STORE_QUEUE;
    5990                   
    60                     ptr = reg_STORE_QUEUE_PTR_WRITE [lsq];
     91                    ptr = STORE_QUEUE_PTR_WRITE [lsq];
     92                    ack = not STORE_QUEUE_USE [lsq][ptr] and (static_cast<uint32_t>(STORE_QUEUE_NB_USE [lsq]+1) < _param->_size_store_queue[lsq]);
    6193
    62                     ack = not reg_STORE_QUEUE_USE [lsq][ptr] and (static_cast<uint32_t>(reg_STORE_QUEUE_NB_USE [lsq]+1) < _param->_size_store_queue[lsq]);
     94                    if (ack)
     95                      {
     96                        STORE_QUEUE_PTR_WRITE [lsq]      = (ptr+1)%_param->_size_store_queue[lsq];
     97                        STORE_QUEUE_NB_USE    [lsq]      ++;
     98                        STORE_QUEUE_USE       [lsq][ptr] = true;
     99                      }
    63100                  }
    64101                else
    65102                  {
     103                    log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * USE_LOAD_QUEUE");
     104
    66105                    internal_INSERT_OPERATION_USE [i] = OPERATION_USE_LOAD_QUEUE;
    67106                   
    68                     ptr = reg_LOAD_QUEUE_PTR_WRITE [lsq];
     107                    ptr = LOAD_QUEUE_PTR_WRITE [lsq];
     108                    ack = (not LOAD_QUEUE_USE [lsq][ptr]);
    69109
    70                     ack = (not reg_LOAD_QUEUE_USE [lsq][ptr]);
     110                    if (ack)
     111                      {
     112                        LOAD_QUEUE_PTR_WRITE [lsq]      = (ptr+1)%_param->_size_load_queue[lsq];
     113                        LOAD_QUEUE_USE       [lsq][ptr] = true;
     114                      }
    71115                  }
     116
     117                log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * ptr          : %d",ptr         );
     118                log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * ack          : %d",ack         );
    72119               
    73120                internal_INSERT_LSQ [i] = lsq;
    … …  
    85132        internal_INSERT_ACK [i] = ack;
    86133        PORT_WRITE(out_INSERT_ACK                   [i], ack);
    87         PORT_WRITE(out_INSERT_STORE_QUEUE_PTR_WRITE [i], store_queue_ptr_write);
    88         if (_param->_have_port_load_queue_ptr)
    89         PORT_WRITE(out_INSERT_LOAD_QUEUE_PTR_WRITE  [i], load_queue_ptr_write );
    90134      }
    91135
    92     log_printf(FUNC,Load_Store_pointer_unit,FUNCTION,"End");
     136    log_end(Load_Store_pointer_unit,FUNCTION);
    93137  };
    94138

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Load_Store_pointer_unit/src/Load_Store_pointer_unit_genMealy_retire.cpp

    r88 r110  
    2424    log_printf(FUNC,Load_Store_pointer_unit,FUNCTION,"Begin");
    2525   
    26     bool use_lsq [_param->_nb_load_store_queue];
    27     for (uint32_t i=0; i<_param->_nb_load_store_queue; i++)
    28       use_lsq [i] = false;
     26//     bool use_lsq [_param->_nb_load_store_queue];
     27//     for (uint32_t i=0; i<_param->_nb_load_store_queue; i++)
     28//       use_lsq [i] = false;
    2929
    3030    for (uint32_t i=0; i<_param->_nb_inst_retire; i++)
    3131      {
    32         Tcontrol_t ack = false;
     32        Tcontrol_t ack = true; // always accept
    3333        Tcontrol_t use_sq  = PORT_READ(in_RETIRE_USE_STORE_QUEUE [i]);
    3434        Tcontrol_t use_lq  = PORT_READ(in_RETIRE_USE_LOAD_QUEUE  [i]);
    … …  
    4141
    4242            // Test if a previous instruction use the same lsq
    43             // Authorize once memory access by load store unit
    44             if (use_lsq [lsq] == false)
     43//          // Authorize once memory access by load store unit
     44//          if (use_lsq [lsq] == false)
    4545              {
    46                 use_lsq [lsq] = true;
    47                 ack = true;
     46//              use_lsq [lsq] = true;
     47//              ack = true;
    4848
    4949                uint32_t   ptr;
    … …  
    7070        else
    7171          {
    72             ack = true;
     72//          ack = true;
    7373
    7474            internal_RETIRE_OPERATION_USE [i] = OPERATION_USE_NONE;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Load_Store_pointer_unit/src/Load_Store_pointer_unit_transition.cpp

    r81 r110  
    2222  void Load_Store_pointer_unit::transition (void)
    2323  {
    24     log_printf(FUNC,Load_Store_pointer_unit,FUNCTION,"Begin");
     24    log_begin(Load_Store_pointer_unit,FUNCTION);
     25    log_function(Load_Store_pointer_unit,FUNCTION,_name.c_str());
    2526
    2627    if (PORT_READ(in_NRESET) == 0)
    … …  
    4748          if (PORT_READ(in_INSERT_VAL [i]) and internal_INSERT_ACK [i])
    4849            {
    49 //            log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"INSERT [%d]",i);
     50              log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"  * INSERT [%d]",i);
    5051             
    5152              switch (internal_INSERT_OPERATION_USE [i])
    … …  
    5354                case OPERATION_USE_STORE_QUEUE :
    5455                  {
    55 //                  log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"  * use STORE_QUEUE");
     56                    log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * use STORE_QUEUE");
    5657
    5758                    uint32_t   lsq = internal_INSERT_LSQ [i];
    5859                    Tlsq_ptr_t ptr = internal_INSERT_PTR [i];
    5960
    60 //                  log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"  * lsq : %d",lsq);
    61 //                  log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"  * ptr : %d",ptr);
     61                    log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * lsq : %d",lsq);
     62                    log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * ptr : %d",ptr);
    6263
    6364                    reg_STORE_QUEUE_PTR_WRITE [lsq]      = (ptr+1)%_param->_size_store_queue[lsq];
    … …  
    6970                case OPERATION_USE_LOAD_QUEUE :
    7071                  {
    71 //                  log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"  * use LOAD_QUEUE");
     72                    log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * use LOAD_QUEUE");
    7273
    7374                    uint32_t   lsq = internal_INSERT_LSQ [i];
    7475                    Tlsq_ptr_t ptr = internal_INSERT_PTR [i];
    7576                   
    76 //                  log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"  * lsq : %d",lsq);
    77 //                  log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"  * ptr : %d",ptr);
     77                    log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * lsq : %d",lsq);
     78                    log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * ptr : %d",ptr);
    7879
    7980                    reg_LOAD_QUEUE_PTR_WRITE [lsq]      = (ptr+1)%_param->_size_load_queue[lsq];
    … …  
    9596          if (PORT_READ(in_RETIRE_VAL [i]) and internal_RETIRE_ACK [i])
    9697            {
    97 //            log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"RETIRE [%d]",i);
     98              log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"  * RETIRE [%d]",i);
    9899
    99100              switch (internal_RETIRE_OPERATION_USE [i])
    … …  
    101102                case OPERATION_USE_STORE_QUEUE :
    102103                  {
    103 //                  log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"  * use STORE_QUEUE");
     104                    log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * use STORE_QUEUE");
    104105
    105106                    uint32_t   lsq = internal_RETIRE_LSQ [i];
    106107                    Tlsq_ptr_t ptr = internal_RETIRE_PTR [i];
    107108
    108 //                  log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"  * lsq : %d",lsq);
    109 //                  log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"  * ptr : %d",ptr);
     109                    log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * lsq : %d",lsq);
     110                    log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * ptr : %d",ptr);
    110111                   
    111112//                  reg_STORE_QUEUE_PTR_WRITE [lsq]      = ((ptr==0)?_param->_size_store_queue[lsq]:ptr)-1;
    … …  
    117118                case OPERATION_USE_LOAD_QUEUE :
    118119                  {
    119 //                  log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"  * use LOAD_QUEUE");
     120                    log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * use LOAD_QUEUE");
    120121
    121122                    uint32_t   lsq = internal_RETIRE_LSQ [i];
    122123                    Tlsq_ptr_t ptr = internal_RETIRE_PTR [i];
    123124                   
    124 //                  log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"  * lsq : %d",lsq);
    125 //                  log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"  * ptr : %d",ptr);
     125                    log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * lsq : %d",lsq);
     126                    log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * ptr : %d",ptr);
    126127                   
    127128//                  reg_LOAD_QUEUE_PTR_WRITE [lsq]      = ((ptr==0)?_param->_size_load_queue[lsq]:ptr)-1;
    … …  
    138139      }
    139140
     141    // ===================================================================
     142    // =====[ OTHER ]=====================================================
     143    // ===================================================================
    140144
    141 //     for (uint32_t i=0; i<_param->_nb_load_store_queue; i++)
    142 //       {
    143 //      std::string str;
    144 
    145 //      log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"LOAD_STORE_QUEUE [%d]",i);
    146 
    147 //      log_printf(TRACE,Load_Store_pointer_unit,FUNCTION," * STORE_QUEUE_PTR_WRITE : %d",reg_STORE_QUEUE_PTR_WRITE [i]);
    148 //      log_printf(TRACE,Load_Store_pointer_unit,FUNCTION," * STORE_QUEUE_NB_USE    : %d",reg_STORE_QUEUE_NB_USE    [i]);
    149 
    150 //      str = "";
    151 //      for (uint32_t j=0; j<_param->_size_store_queue[i]; j++)
    152 //        str += toString(reg_STORE_QUEUE_USE [i][j]) + " ";
    153 //      log_printf(TRACE,Load_Store_pointer_unit,FUNCTION," * %s",str.c_str());
    154        
    155 //      log_printf(TRACE,Load_Store_pointer_unit,FUNCTION," * LOAD_QUEUE_PTR_WRITE  : %d",reg_LOAD_QUEUE_PTR_WRITE [i]);
    156 
    157 //      str = "";
    158 //      for (uint32_t j=0; j<_param->_size_load_queue[i]; j++)
    159 //        str += toString(reg_LOAD_QUEUE_USE [i][j]) + " ";
    160 //      log_printf(TRACE,Load_Store_pointer_unit,FUNCTION," * %s",str.c_str());
    161 //       }
     145#if (DEBUG >= DEBUG_TRACE) and (DEBUG_Commit_unit == true)
     146    {
     147      log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"  * Dump Load_Store_pointer Unit");
     148     
     149      for (uint32_t i=0; i<_param->_nb_load_store_queue; ++i)
     150        {
     151          log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"    * Load_Store_unit [%d]",i);
     152          log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"      * reg_STORE_QUEUE_NB_USE    : %d", reg_STORE_QUEUE_NB_USE   [i]);
     153          log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"      * reg_STORE_QUEUE_PTR_WRITE : %d", reg_STORE_QUEUE_PTR_WRITE[i]);
     154          log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"      * reg_STORE_QUEUE_USE       :");
     155          for (uint32_t j=0; j<_param->_size_store_queue [i]; ++j)
     156          log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"        [%d] %d",j,reg_STORE_QUEUE_USE [i][j]);
     157          log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"      * reg_LOAD_QUEUE_PTR_WRITE  : %d", reg_LOAD_QUEUE_PTR_WRITE [i]);
     158          log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"      * reg_LOAD_QUEUE_USE        :");
     159          for (uint32_t j=0; j<_param->_size_load_queue [i]; ++j)
     160          log_printf(TRACE,Load_Store_pointer_unit,FUNCTION,"        [%d] %d",j,reg_LOAD_QUEUE_USE [i][j]);
     161        }
     162    }
     163#endif
    162164
    163165#if defined(STATISTICS) or defined(VHDL_TESTBENCH)
    … …  
    165167#endif
    166168
    167     log_printf(FUNC,Load_Store_pointer_unit,FUNCTION,"End");
     169    log_end(Load_Store_pointer_unit,FUNCTION);
    168170  };
    169171

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Load_Store_pointer_unit/src/Parameters.cpp

    r88 r110  
    2222  Parameters::Parameters (uint32_t    nb_front_end                    ,
    2323                          uint32_t  * nb_context                      ,
    24 //                           uint32_t    size_front_end_id               ,
    25 //                           uint32_t    size_context_id                 ,
     24//                        uint32_t    size_front_end_id               ,
     25//                        uint32_t    size_context_id                 ,
    2626                          uint32_t    nb_load_store_queue             ,
    2727                          uint32_t  * size_store_queue                ,
    2828                          uint32_t  * size_load_queue                 ,
     29                          uint32_t  * nb_inst_memory                  ,
    2930                          uint32_t ** link_load_store_unit_with_thread,
    3031                          uint32_t    nb_inst_insert                  ,
    … …  
    4041    _size_store_queue                 = size_store_queue                ;
    4142    _size_load_queue                  = size_load_queue                 ;
     43    _nb_inst_memory                   = nb_inst_memory                  ;
    4244    _link_load_store_unit_with_thread = link_load_store_unit_with_thread;
    4345    _nb_inst_insert                   = nb_inst_insert                  ;
    4446    _nb_inst_retire                   = nb_inst_retire                  ;
    45     
     47   
    4648    test();
     49
     50    _max_size_store_queue             = max<uint32_t>(_size_store_queue,_nb_load_store_queue);
     51    _max_size_load_queue              = max<uint32_t>(_size_load_queue ,_nb_load_store_queue);
    4752
    4853    if (is_toplevel)

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Free_List_unit/include/Free_List_unit.h

    r109 r110  
    5555#ifdef STATISTICS
    5656  public    : Stat                           * _stat;
     57  private   : counter_t                      * _stat_nb_inst_pop     ;
     58  private   : counter_t                      * _stat_nb_inst_pop_gpr ;
     59  private   : counter_t                      * _stat_nb_inst_pop_spr ;
     60  private   : counter_t                      * _stat_nb_inst_push_gpr;
     61  private   : counter_t                      * _stat_nb_inst_push_spr;
     62  private   : counter_t                     ** _stat_bank_gpr_nb_elt ; //[nb_bank]
     63  private   : counter_t                     ** _stat_bank_spr_nb_elt ; //[nb_bank]
    5764#endif
    5865
    … …  
    146153
    147154#ifdef STATISTICS
    148   public  : void        statistics_declaration    (morpheo::behavioural::Parameters_Statistics * param_statistics);
     155  public  : void        statistics_allocation     (morpheo::behavioural::Parameters_Statistics * param_statistics);
     156  public  : void        statistics_deallocation   (void);
    149157#endif
    150158#if defined(STATISTICS) or defined(VHDL_TESTBENCH)

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Free_List_unit/src/Free_List_unit.cpp

    r88 r110  
    5858        log_printf(INFO,Free_List_unit,FUNCTION,"Allocation of statistics");
    5959
    60         statistics_declaration(param_statistics);
     60        statistics_allocation(param_statistics);
    6161      }
    6262#endif
    … …  
    157157#ifdef STATISTICS
    158158    if (usage_is_set(_usage,USE_STATISTICS))
    159       {
    160         log_printf(INFO,Free_List_unit,FUNCTION,"Generate Statistics file");
    161        
    162         delete _stat;
    163       }
     159      statistics_deallocation ();
     160
    164161#endif
    165162

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Free_List_unit/src/Free_List_unit_statistics_allocation.cpp

    r108 r110  
    2020
    2121#undef  FUNCTION
    22 #define FUNCTION "Free_List_unit::statistics_declaration"
    23   void Free_List_unit::statistics_declaration (morpheo::behavioural::Parameters_Statistics * param_statistics)
     22#define FUNCTION "Free_List_unit::statistics_allocation"
     23  void Free_List_unit::statistics_allocation (morpheo::behavioural::Parameters_Statistics * param_statistics)
    2424  {
    2525    log_printf(FUNC,Free_List_unit,FUNCTION,"Begin");
    … …  
    2828                      "Free_List_unit",
    2929                      param_statistics);
     30
     31    std::string sum_bank_gpr_nb_elt = "0";
     32    _stat_bank_gpr_nb_elt = new counter_t * [_param->_nb_bank];
    3033   
     34    for (uint32_t i=0; i<_param->_nb_bank; ++i)
     35      {
     36        std::string str = "bank_gpr_nb_elt_"+toString(i);
     37       
     38        sum_bank_gpr_nb_elt = "+ "+str+" "+sum_bank_gpr_nb_elt;
     39       
     40        _stat_bank_gpr_nb_elt [i]  = _stat->create_variable(str);
     41       
     42        _stat->create_expr_average_by_cycle("average_occupation_bank_gpr_"+toString(i), str, "", toString(_("Average free list occupation (bank %d)"),i));
     43        _stat->create_expr_percent         ("percent_occupation_bank_gpr_"+toString(i) , "average_occupation_bank_gpr_"+toString(i), toString(_param->_bank_gpr_nb_slot), toString(_("Percent free list occupation (bank %d)"),i));
     44      }
     45
     46    _stat->create_expr_average_by_cycle("average_occupation_bank_gpr", sum_bank_gpr_nb_elt, "", _("Average free list occupation (bank all)"));
     47    _stat->create_expr_percent         ("percent_occupation_bank_gpr", "average_occupation_bank_gpr", toString(_param->_bank_gpr_nb_slot*_param->_nb_bank), _("Percent free list occupation (bank all)"));
     48   
     49    std::string sum_bank_spr_nb_elt = "0";
     50    _stat_bank_spr_nb_elt = new counter_t * [_param->_nb_bank];
     51
     52    for (uint32_t i=0; i<_param->_nb_bank; ++i)
     53      {
     54        std::string str = "bank_spr_nb_elt_"+toString(i);
     55       
     56        sum_bank_spr_nb_elt = "+ "+str+" "+sum_bank_spr_nb_elt;
     57       
     58        _stat_bank_spr_nb_elt [i]  = _stat->create_variable(str);
     59       
     60        _stat->create_expr_average_by_cycle("average_occupation_bank_spr_"+toString(i), str, "", toString(_("Average free list occupation (bank %d)"),i));
     61        _stat->create_expr_percent         ("percent_occupation_bank_spr_"+toString(i) , "average_occupation_bank_spr_"+toString(i), toString(_param->_bank_spr_nb_slot), toString(_("Percent free list occupation (bank %d)"),i));
     62      }
     63
     64    _stat->create_expr_average_by_cycle("average_occupation_bank_spr", sum_bank_spr_nb_elt, "", _("Average free list occupation (bank all)"));
     65    _stat->create_expr_percent         ("percent_occupation_bank_spr", "average_occupation_bank_spr", toString(_param->_bank_spr_nb_slot*_param->_nb_bank), _("Percent free list occupation (bank all)"));
     66
     67    _stat_nb_inst_pop      = _stat->create_variable("nb_inst_pop"     );
     68    _stat_nb_inst_pop_gpr  = _stat->create_variable("nb_inst_pop_gpr" );
     69    _stat_nb_inst_pop_spr  = _stat->create_variable("nb_inst_pop_spr" );
     70    _stat_nb_inst_push_gpr = _stat->create_variable("nb_inst_push_gpr");
     71    _stat_nb_inst_push_spr = _stat->create_variable("nb_inst_push_spr");
     72   
     73    _stat->create_expr_average_by_cycle("average_use_interface_pop"     , "nb_inst_pop"     , "", _("Average instruction per cycle on pop interface"));
     74    _stat->create_expr_average_by_cycle("average_use_interface_pop_gpr" , "nb_inst_pop_gpr" , "", _("Average instruction per cycle on pop interface for gpr"));
     75    _stat->create_expr_average_by_cycle("average_use_interface_pop_spr" , "nb_inst_pop_spr" , "", _("Average instruction per cycle on pop interface for spr"));
     76    _stat->create_expr_average_by_cycle("average_use_interface_push_gpr", "nb_inst_push_gpr", "", _("Average instruction per cycle on push_gpr interface"));
     77    _stat->create_expr_average_by_cycle("average_use_interface_push_spr", "nb_inst_push_spr", "", _("Average instruction per cycle on push_spr interface"));
     78
     79    _stat->create_expr_percent         ("percent_inst_pop_need_gpr"     , "nb_inst_pop_gpr" , "nb_inst_pop", _("Percent of pop instruction that need gpr"));
     80    _stat->create_expr_percent         ("percent_inst_pop_need_spr"     , "nb_inst_pop_spr" , "nb_inst_pop", _("Percent of pop instruction that need spr"));
     81
    3182    log_printf(FUNC,Free_List_unit,FUNCTION,"End");
    3283  };

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Free_List_unit/src/Free_List_unit_transition.cpp

    r109 r110  
    5050              log_printf(TRACE,Free_List_unit,FUNCTION,"  * POP [%d]",i);
    5151
     52#ifdef STATISTICS
     53              (*_stat_nb_inst_pop) ++;
     54#endif
     55
    5256              if (PORT_READ(in_POP_GPR_VAL [i]))
    53                 _gpr_list [internal_POP_GPR_BANK[i]].pop_front();
     57                {
     58#ifdef STATISTICS
     59                  (*_stat_nb_inst_pop_gpr) ++;
     60#endif
     61                  _gpr_list [internal_POP_GPR_BANK[i]].pop_front();
     62                }
    5463         
    5564              if (PORT_READ(in_POP_SPR_VAL [i]))
    56                 _spr_list [internal_POP_SPR_BANK[i]].pop_front();
     65                {
     66#ifdef STATISTICS
     67                  (*_stat_nb_inst_pop_spr) ++;
     68#endif
     69                  _spr_list [internal_POP_SPR_BANK[i]].pop_front();
     70                }
    5771            }
    5872
    … …  
    6781              log_printf(TRACE,Free_List_unit,FUNCTION,"    * num_reg : %d",PORT_READ(in_PUSH_GPR_NUM_REG [i]));
    6882
     83#ifdef STATISTICS
     84              (*_stat_nb_inst_push_gpr) ++;
     85#endif
     86
    6987              _gpr_list [internal_PUSH_GPR_BANK[i]].push_back(PORT_READ(in_PUSH_GPR_NUM_REG [i]));
    7088            }
    … …  
    7997              log_printf(TRACE,Free_List_unit,FUNCTION,"    * num_reg : %d",PORT_READ(in_PUSH_SPR_NUM_REG [i]));
    8098
     99#ifdef STATISTICS
     100              (*_stat_nb_inst_push_spr) ++;
     101#endif
     102
    81103              _spr_list [internal_PUSH_SPR_BANK[i]].push_back(PORT_READ(in_PUSH_SPR_NUM_REG [i]));
    82104            }
     105
     106#ifdef STATISTICS
     107          for (uint32_t i=0; i<_param->_nb_bank; ++i)
     108            {
     109              (*(_stat_bank_gpr_nb_elt [i])) += _gpr_list[i].size();
     110              (*(_stat_bank_spr_nb_elt [i])) += _spr_list[i].size();
     111            }
     112#endif
    83113
    84114#if (DEBUG >= DEBUG_TRACE) and (DEBUG_Free_List_unit == true)
    … …  
    140170        if (1)
    141171          for (uint32_t i=0; i<_param->_nb_bank; ++i)
    142           {
     172            {
    143173            for (std::list<Tgeneral_address_t>::iterator it1=_gpr_list[i].begin();
    144174                 it1!=_gpr_list[i].end();

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue/include/Register_translation_unit_Glue.h

    r98 r110  
    5252#ifdef STATISTICS
    5353  public    : Stat                           * _stat;
     54
     55  private   : counter_t                      * _stat_nb_inst_issue_rename_select;
     56  private   : counter_t                      * _stat_nb_inst_issue_rename_select_req;
     57  private   : counter_t                      * _stat_nb_inst_issue_stall_by_commit           ;
     58  private   : counter_t                      * _stat_nb_inst_issue_stall_by_rat_rename       ;
     59  private   : counter_t                      * _stat_nb_inst_issue_stall_by_rat_insert       ;
     60  private   : counter_t                      * _stat_nb_inst_issue_stall_by_free_list        ;
     61  private   : counter_t                      * _stat_nb_inst_issue_stall_by_stat_list        ;
    5462#endif
    5563
    … …  
    139147
    140148    // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     149#ifdef STATISTICS
     150  private   : Tcontrol_t                    * internal_INSERT_RENAME_ACK; //[nb_inst_insert]
     151#endif
     152
    141153#endif
    142154
    … …  
    186198
    187199#ifdef STATISTICS
    188   public  : void        statistics_declaration    (morpheo::behavioural::Parameters_Statistics * param_statistics);
     200  public  : void        statistics_allocation     (morpheo::behavioural::Parameters_Statistics * param_statistics);
     201  public  : void        statistics_deallocation   (void);
    189202#endif
    190203#if defined(STATISTICS) or defined(VHDL_TESTBENCH)

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue/src/Register_translation_unit_Glue.cpp

    r88 r110  
    5858        log_printf(INFO,Register_translation_unit_Glue,FUNCTION,"Allocation of statistics");
    5959
    60         statistics_declaration(param_statistics);
     60        statistics_allocation(param_statistics);
    6161      }
    6262#endif
    … …  
    199199#ifdef STATISTICS
    200200    if (usage_is_set(_usage,USE_STATISTICS))
    201       {
    202         log_printf(INFO,Register_translation_unit_Glue,FUNCTION,"Generate Statistics file");
    203        
    204         delete _stat;
    205       }
     201      statistics_deallocation ();
    206202#endif
    207203

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue/src/Register_translation_unit_Glue_allocation.cpp

    r98 r110  
    136136    }
    137137
     138#ifdef STATISTICS
     139    ALLOC1(internal_INSERT_RENAME_ACK, Tcontrol_t,_param->_nb_inst_insert);
     140#endif
     141
    138142    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    139 
    140143#ifdef POSITION
    141144    if (usage_is_set(_usage,USE_POSITION))

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue/src/Register_translation_unit_Glue_deallocation.cpp

    r98 r110  
    9999        DELETE1_SIGNAL( in_RETIRE_STAT_LIST_ACK,_param->_nb_inst_retire,1);
    100100
     101#ifdef STATISTICS
     102        DELETE1(internal_INSERT_RENAME_ACK, _param->_nb_inst_insert);
     103#endif
    101104      }
     105
    102106    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    103107

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue/src/Register_translation_unit_Glue_genMealy_insert_valack.cpp

    r88 r110  
    7575        log_printf(TRACE,Register_translation_unit_Glue,FUNCTION,"    * stat_list_ack  (r): %d",stat_list_ack );
    7676
     77#ifdef STATISTICS
     78        internal_INSERT_RENAME_ACK [i] = rename_ack;
     79#endif
    7780
    7881        PORT_WRITE(out_INSERT_RENAME_ACK     [i], rename_ack    );

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue/src/Register_translation_unit_Glue_genMealy_retire.cpp

    r88 r110  
    3232        Tcontrol_t stat_list_ack = PORT_READ(in_RETIRE_STAT_LIST_ACK [i]);
    3333
    34         PORT_WRITE(out_RETIRE_ACK           [i], rat_ack and stat_list_ack);
    35         PORT_WRITE(out_RETIRE_RAT_VAL       [i], val and stat_list_ack);
    36         PORT_WRITE(out_RETIRE_STAT_LIST_VAL [i], val and rat_ack);
     34        Tcontrol_t ack           = (true
     35//                                     and val
     36                                    and rat_ack
     37                                    and stat_list_ack
     38                                    );
     39        Tcontrol_t rat_val       = (true
     40                                    and val
     41//                                     and rat_ack
     42                                    and stat_list_ack
     43                                    );
     44        Tcontrol_t stat_list_val = (true
     45                                    and val
     46                                    and rat_ack
     47//                                     and stat_list_ack
     48                                    );
     49
     50        PORT_WRITE(out_RETIRE_ACK           [i], ack          );
     51        PORT_WRITE(out_RETIRE_RAT_VAL       [i], rat_val      );
     52        PORT_WRITE(out_RETIRE_STAT_LIST_VAL [i], stat_list_val);
     53
     54        log_printf(TRACE,Register_translation_unit_Glue,FUNCTION,"  * inst_insert [%d]",i);
     55        log_printf(TRACE,Register_translation_unit_Glue,FUNCTION,"    * val            (r): %d",val           );
     56        log_printf(TRACE,Register_translation_unit_Glue,FUNCTION,"    * ack            (w): %d",ack           );
     57        log_printf(TRACE,Register_translation_unit_Glue,FUNCTION,"    * rat_val        (w): %d",rat_val       );
     58        log_printf(TRACE,Register_translation_unit_Glue,FUNCTION,"    * rat_ack        (r): %d",rat_ack       );
     59        log_printf(TRACE,Register_translation_unit_Glue,FUNCTION,"    * stat_list_val  (w): %d",stat_list_val );
     60        log_printf(TRACE,Register_translation_unit_Glue,FUNCTION,"    * stat_list_ack  (r): %d",stat_list_ack );
    3761      }
    3862

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue/src/Register_translation_unit_Glue_statistics_allocation.cpp

    r108 r110  
    2020
    2121#undef  FUNCTION
    22 #define FUNCTION "Register_translation_unit_Glue::statistics_declaration"
    23   void Register_translation_unit_Glue::statistics_declaration (morpheo::behavioural::Parameters_Statistics * param_statistics)
     22#define FUNCTION "Register_translation_unit_Glue::statistics_allocation"
     23  void Register_translation_unit_Glue::statistics_allocation (morpheo::behavioural::Parameters_Statistics * param_statistics)
    2424  {
    2525    log_printf(FUNC,Register_translation_unit_Glue,FUNCTION,"Begin");
    … …  
    2828                      "Register_translation_unit_Glue",
    2929                      param_statistics);
     30
     31    _stat_nb_inst_issue_rename_select        = _stat->create_variable("nb_inst_issue_rename_select");
     32    _stat_nb_inst_issue_rename_select_req    = _stat->create_variable("nb_inst_issue_rename_select_req");
     33
     34    _stat_nb_inst_issue_stall_by_commit      = _stat->create_variable("nb_inst_issue_stall_by_commit");
     35    _stat_nb_inst_issue_stall_by_rat_rename  = _stat->create_variable("nb_inst_issue_stall_by_rat_rename");
     36    _stat_nb_inst_issue_stall_by_rat_insert  = _stat->create_variable("nb_inst_issue_stall_by_rat_insert");
     37    _stat_nb_inst_issue_stall_by_free_list   = _stat->create_variable("nb_inst_issue_stall_by_free_list");
     38    _stat_nb_inst_issue_stall_by_stat_list   = _stat->create_variable("nb_inst_issue_stall_by_stat_list");
     39
     40//  std::string nb_inst_issue_stall = "+ + + nb_inst_issue_stall_by_commit nb_inst_issue_stall_by_rat_rename + nb_inst_issue_stall_by_rat_insert nb_inst_issue_stall_by_free_list + nb_inst_issue_stall_by_stat_list nb_inst_issue_stall_by_rename_select";
     41    std::string nb_inst_issue_stall = "+ + + nb_inst_issue_stall_by_commit nb_inst_issue_stall_by_rat_rename + nb_inst_issue_stall_by_rat_insert nb_inst_issue_stall_by_free_list nb_inst_issue_stall_by_stat_list";
     42
     43    _stat->create_expr_average_by_cycle("average_req_interface_insert", "nb_inst_issue_rename_select_req", "", _("Average instruction by cycle on issue interface (request)"));
     44    _stat->create_expr_average_by_cycle("average_use_interface_insert", "nb_inst_issue_rename_select"    , "", _("Average instruction by cycle on issue interface"));
     45
     46//  _stat->create_expr_percent ("percent_issue_stall_by_rename_select", "nb_inst_issue_stall_by_rename_select", nb_inst_issue_stall, _("Percent of instruction stalled by Rename_Select"));
     47    _stat->create_expr_percent ("percent_issue_stall_by_commit"       , "nb_inst_issue_stall_by_commit", nb_inst_issue_stall, _("Percent of instruction stalled by Commit_unit or Issue_queue or RegisterFile"));
     48    _stat->create_expr_percent ("percent_issue_stall_by_rat_rename"   , "nb_inst_issue_stall_by_rat_rename", nb_inst_issue_stall, _("Percent of instruction stalled by Rat_Rename"));
     49    _stat->create_expr_percent ("percent_issue_stall_by_rat_insert"   , "nb_inst_issue_stall_by_rat_insert", nb_inst_issue_stall, _("Percent of instruction stalled by Rat_Insert"));
     50    _stat->create_expr_percent ("percent_issue_stall_by_free_list"    , "nb_inst_issue_stall_by_free_list", nb_inst_issue_stall, _("Percent of instruction stalled by Free_List"));
     51    _stat->create_expr_percent ("percent_issue_stall_by_stat_list"    , "nb_inst_issue_stall_by_stat_list", nb_inst_issue_stall, _("Percent of instruction stalled by Stat_List"));
    3052   
    3153    log_printf(FUNC,Register_translation_unit_Glue,FUNCTION,"End");

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue/src/Register_translation_unit_Glue_transition.cpp

    r81 r110  
    2626    log_printf(FUNC,Register_translation_unit_Glue,FUNCTION,"Begin");
    2727
     28#ifdef STATISTICS
     29    if (usage_is_set(_usage,USE_STATISTICS))
     30      {
     31        for (uint32_t i=0; i<_param->_nb_inst_insert; ++i)
     32          // Test request
     33          if (PORT_READ(in_INSERT_RENAME_VAL [i]))
     34            {
     35              (* _stat_nb_inst_issue_rename_select_req) ++;
     36
     37              if (internal_INSERT_RENAME_ACK [i])
     38                (* _stat_nb_inst_issue_rename_select)++;
     39              if (PORT_READ(in_INSERT_INSERT_ACK     [i]) == 0)
     40                (*_stat_nb_inst_issue_stall_by_commit    ) ++;
     41              if (PORT_READ(in_INSERT_RAT_RENAME_ACK [i]) == 0)
     42                (*_stat_nb_inst_issue_stall_by_rat_rename) ++;
     43              if (PORT_READ(in_INSERT_RAT_INSERT_ACK [i]) == 0)
     44                (*_stat_nb_inst_issue_stall_by_rat_insert) ++;
     45              if (PORT_READ(in_INSERT_FREE_LIST_ACK  [i]) == 0)
     46                (*_stat_nb_inst_issue_stall_by_free_list ) ++;
     47              if (PORT_READ(in_INSERT_STAT_LIST_ACK  [i]) == 0)
     48                (*_stat_nb_inst_issue_stall_by_stat_list ) ++;
     49            }
     50      }
     51#endif
     52
    2853#if defined(STATISTICS) or defined(VHDL_TESTBENCH)
    2954    end_cycle ();

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_select/src/Rename_select_genMealy.cpp

    r108 r110  
    4343    for (uint32_t i=0; i<_param->_nb_inst_rename; i++)
    4444      {
    45         log_printf(TRACE,Rename_select,FUNCTION,"  * inst_rename [%d]",i);
     45        log_printf(TRACE,Rename_select,FUNCTION,"  * RENAME_OUT [%d]",i);
    4646
    4747        // Scan all instruction until find
    … …  
    6565                log_printf(TRACE,Rename_select,FUNCTION,"      * rename_out_ack       : %d",PORT_READ(in_RENAME_OUT_ACK[i]));
    6666
    67                 Tcontext_t     front_end_id = (_param->_have_port_front_end_id)?PORT_READ(in_RENAME_IN_FRONT_END_ID [x][y]):0;
    68                 Tcontext_t     context_id   = (_param->_have_port_context_id  )?PORT_READ(in_RENAME_IN_CONTEXT_ID   [x][y]):0;
     67                Tcontext_t front_end_id = (_param->_have_port_front_end_id)?PORT_READ(in_RENAME_IN_FRONT_END_ID [x][y]):0;
     68                Tcontext_t context_id   = (_param->_have_port_context_id  )?PORT_READ(in_RENAME_IN_CONTEXT_ID   [x][y]):0;
    6969               
    70                 Tcontrol_t     no_execute   = (PORT_READ(in_RENAME_IN_NO_EXECUTE [x][y]));
    71 
    72                 Tcontrol_t read_ra  = (PORT_READ(in_RENAME_IN_READ_RA  [x][y]));
    73                 Tcontrol_t read_rb  = (PORT_READ(in_RENAME_IN_READ_RB  [x][y]));
    74                 Tcontrol_t read_rc  = (PORT_READ(in_RENAME_IN_READ_RC  [x][y]));
    75                 Tcontrol_t write_rd = (PORT_READ(in_RENAME_IN_WRITE_RD [x][y]));
    76                 Tcontrol_t write_re = (PORT_READ(in_RENAME_IN_WRITE_RE [x][y]));
     70                Tcontrol_t no_execute   = (PORT_READ(in_RENAME_IN_NO_EXECUTE [x][y]));
     71                Tcontrol_t read_ra      = (PORT_READ(in_RENAME_IN_READ_RA    [x][y]));
     72                Tcontrol_t read_rb      = (PORT_READ(in_RENAME_IN_READ_RB    [x][y]));
     73                Tcontrol_t read_rc      = (PORT_READ(in_RENAME_IN_READ_RC    [x][y]));
     74                Tcontrol_t write_rd     = (PORT_READ(in_RENAME_IN_WRITE_RD   [x][y]));
     75                Tcontrol_t write_re     = (PORT_READ(in_RENAME_IN_WRITE_RE   [x][y]));
    7776
    7877                // Attention, j'ai enlevé event_state de la liste de sensibilité

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_unit_Glue/src/Rename_unit_Glue_genMealy_insert_valack.cpp

    r88 r110  
    2525    log_function(Rename_unit_Glue,FUNCTION,_name.c_str());
    2626
    27 //     // Transaction must be in-order
     27//     // Transaction must be in-order - made in rename_select
    2828//     Tcontrol_t previous_transaction = true;
    2929   

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_unit_Glue/src/Rename_unit_Glue_genMealy_retire_valack.cpp

    r88 r110  
    2525    log_function(Rename_unit_Glue,FUNCTION,_name.c_str());
    2626
    27     // Transaction must be in-order
    28     Tcontrol_t previous_transaction = true;
     27    // Transaction must be in-order - made in commit_unit
     28//     Tcontrol_t previous_transaction = true;
    2929   
    3030    for (uint32_t i=0; i<_param->_nb_inst_retire; i++)
    … …  
    3434        Tcontrol_t REGISTER_TRANSLATION_ACK     = PORT_READ(in_RETIRE_REGISTER_TRANSLATION_ACK     [i]);
    3535
    36         Tcontrol_t ACK                          = (previous_transaction         and
     36        Tcontrol_t ACK                          = (// previous_transaction         and
    3737                                                   LOAD_STORE_QUEUE_POINTER_ACK and
    3838                                                   REGISTER_TRANSLATION_ACK     );
    39         Tcontrol_t LOAD_STORE_QUEUE_POINTER_VAL = (previous_transaction         and
     39        Tcontrol_t LOAD_STORE_QUEUE_POINTER_VAL = (// previous_transaction         and
    4040                                                   VAL                          and
    4141                                                   REGISTER_TRANSLATION_ACK     );
    42         Tcontrol_t REGISTER_TRANSLATION_VAL     = (previous_transaction         and
     42        Tcontrol_t REGISTER_TRANSLATION_VAL     = (// previous_transaction         and
    4343                                                   VAL                          and
    4444                                                   LOAD_STORE_QUEUE_POINTER_ACK );
    … …  
    4848        PORT_WRITE(out_RETIRE_REGISTER_TRANSLATION_VAL     [i], REGISTER_TRANSLATION_VAL    );
    4949
    50         previous_transaction = VAL and ACK;
     50//      previous_transaction = VAL and ACK;
     51
     52        log_printf(TRACE,Rename_unit_Glue,FUNCTION,"  * retire [%d]",i);
     53        log_printf(TRACE,Rename_unit_Glue,FUNCTION,"    * val (commit_unit)            (r) : %d",VAL                         );
     54        log_printf(TRACE,Rename_unit_Glue,FUNCTION,"    * ack (commit_unit)            (w) : %d",ACK                         );
     55        log_printf(TRACE,Rename_unit_Glue,FUNCTION,"    * register_translation_val     (w) : %d",REGISTER_TRANSLATION_VAL    );
     56        log_printf(TRACE,Rename_unit_Glue,FUNCTION,"    * register_translation_ack     (r) : %d",REGISTER_TRANSLATION_ACK    );
     57        log_printf(TRACE,Rename_unit_Glue,FUNCTION,"    * load_store_queue_pointer_val (w) : %d",LOAD_STORE_QUEUE_POINTER_VAL);
     58        log_printf(TRACE,Rename_unit_Glue,FUNCTION,"    * load_store_queue_pointer_ack (r) : %d",LOAD_STORE_QUEUE_POINTER_ACK);
    5159      }
    5260

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/SelfTest/config-min.cfg

    r88 r110  
    882       2       +1      # size_store_queue                 [0]    [nb_load_store_queue]
    991       1       +1      # size_load_queue                  [0]    [nb_load_store_queue]
     101       1       +1      # nb_inst_memory                   [0]    [nb_load_store_queue]
    10110       0       +1      # link_load_store_unit_with_thread [0][0] [nb_front_end][nb_context]
    11121       1       +1      # rename_select_priority           

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/SelfTest/config-thread_1a.cfg

    r88 r110  
    888       8       +1      # size_store_queue                 [0]    [nb_load_store_queue]
    998       8       +1      # size_load_queue                  [0]    [nb_load_store_queue]
     108       8       +1      # nb_inst_memory                   [0]    [nb_load_store_queue]
    10110       0       +1      # link_load_store_unit_with_thread [0][0] [nb_front_end][nb_context]
    11121       1       +1      # rename_select_priority           

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/SelfTest/config-thread_4a.cfg

    r88 r110  
    888       8       +1      # size_store_queue                 [0]    [nb_load_store_queue]
    998       8       +1      # size_load_queue                  [0]    [nb_load_store_queue]
     104       4       +1      # nb_inst_memory                   [0]    [nb_load_store_queue]
    10110       0       +1      # link_load_store_unit_with_thread [0][0] [nb_front_end][nb_context]
    11120       0       +1      # link_load_store_unit_with_thread [0][1] [nb_front_end][nb_context]

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/SelfTest/config-thread_4b.cfg

    r88 r110  
    10108       8       +1      # size_load_queue                  [0]    [nb_load_store_queue]
    11114       4       +1      # size_load_queue                  [1]    [nb_load_store_queue]
     124       4       +1      # nb_inst_memory                   [0]    [nb_load_store_queue]
     132       2       +1      # nb_inst_memory                   [1]    [nb_load_store_queue]
    12140       0       +1      # link_load_store_unit_with_thread [0][0] [nb_front_end][nb_context]
    13151       1       +1      # link_load_store_unit_with_thread [0][1] [nb_front_end][nb_context]

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/SelfTest/src/main.cpp

    r88 r110  
    2222  err (_(" * size_store_queue                  [nb_load_store_queue]      (uint32_t         )\n"));
    2323  err (_(" * size_load_queue                   [nb_load_store_queue]      (uint32_t         )\n"));
     24  err (_(" * nb_inst_memory                    [nb_load_store_queue]      (uint32_t         )\n"));
    2425  err (_(" * link_load_store_unit_with_thread  [nb_front_end][nb_context] (uint32_t         )\n"));
    2526  err (_(" * rename_select_priority                                       (Tpriority_t      )\n"));
    … …  
    7172  uint32_t             _nb_load_store_queue               = fromString<uint32_t         >(argv[x++]);
    7273
    73   if (argc != static_cast<int>(2+NB_PARAMS+2*_nb_front_end+2*_nb_load_store_queue+_sum_nb_context))
     74  if (argc != static_cast<int>(2+NB_PARAMS+2*_nb_front_end+3*_nb_load_store_queue+_sum_nb_context))
    7475    usage (argc, argv);
    7576
    7677  uint32_t           * _size_store_queue                  = new uint32_t [_nb_load_store_queue];
    7778  uint32_t           * _size_load_queue                   = new uint32_t [_nb_load_store_queue];
     79  uint32_t           * _nb_inst_memory                    = new uint32_t [_nb_load_store_queue];
    7880
    7981  for (uint32_t i=0; i<_nb_load_store_queue; i++)
    … …  
    8183  for (uint32_t i=0; i<_nb_load_store_queue; i++)
    8284    _size_load_queue  [i] = fromString<uint32_t>(argv[x++]);
     85  for (uint32_t i=0; i<_nb_load_store_queue; i++)
     86    _nb_inst_memory   [i] = fromString<uint32_t>(argv[x++]);
    8387
    8488  uint32_t          ** _link_load_store_unit_with_thread  = new uint32_t * [_nb_front_end];
    … …  
    113117         _size_store_queue                 ,
    114118         _size_load_queue                  ,
     119         _nb_inst_memory                   ,
    115120         _link_load_store_unit_with_thread ,
    116121         _rename_select_priority           ,
    … …  
    157162  delete [] _size_store_queue;
    158163  delete [] _size_load_queue ;
     164  delete [] _nb_inst_memory  ;
    159165  delete [] _nb_context      ;
    160166

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/include/Parameters.h

    r88 r110  
    3636  public : uint32_t           * _size_store_queue                 ;//[nb_load_store_queue]
    3737  public : uint32_t           * _size_load_queue                  ;//[nb_load_store_queue]
     38  public : uint32_t           * _nb_inst_memory                   ;//[nb_load_store_queue]
    3839  public : uint32_t          ** _link_load_store_unit_with_thread ;//[nb_front_end][nb_context]
    3940  public : Tpriority_t          _rename_select_priority           ;
    … …  
    7576                        uint32_t           * size_store_queue                 ,
    7677                        uint32_t           * size_load_queue                  ,
     78                        uint32_t           * nb_inst_memory                   ,
    7779                        uint32_t          ** link_load_store_unit_with_thread ,
    7880                        Tpriority_t          rename_select_priority           ,

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/src/Parameters.cpp

    r97 r110  
    2727                          uint32_t           * size_store_queue                 ,
    2828                          uint32_t           * size_load_queue                  ,
     29                          uint32_t           * nb_inst_memory                   ,
    2930                          uint32_t          ** link_load_store_unit_with_thread ,
    3031                          Tpriority_t          rename_select_priority           ,
    … …  
    5051    _size_store_queue                  = size_store_queue                 ;
    5152    _size_load_queue                   = size_load_queue                  ;
     53    _nb_inst_memory                    = nb_inst_memory                   ;
    5254    _link_load_store_unit_with_thread  = link_load_store_unit_with_thread ;
    5355    _rename_select_priority            = rename_select_priority           ;
    … …  
    101103       _size_store_queue                ,
    102104       _size_load_queue                 ,
     105       _nb_inst_memory                  ,
    103106       _link_load_store_unit_with_thread,
    104107       _nb_inst_insert                  ,

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/SelfTest/configuration.cfg

    r108 r110  
    54542       2       +1      # size_store_queue                  [0][0]            [nb_rename_unit][nb_load_store_queue]
    55551       1       +1      # size_load_queue                   [0][0]            [nb_rename_unit][nb_load_store_queue]
     561       1       +1      # nb_inst_memory                    [0][0]            [nb_rename_unit][nb_load_store_queue]
    56570       0       +1      # link_load_store_unit_with_thread  [0][0]            [nb_front_end][nb_context]           

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/SelfTest/src/main.cpp

    r108 r110  
    77
    88#include "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/SelfTest/include/test.h"
     9#include "Behavioural/include/Allocation.h"
    910
    1011#define NB_PARAMS 23
    … …  
    6970  err (_(" * size_store_queue                  [nb_rename_unit][nb_load_store_queue] (uint32_t         )\n"));
    7071  err (_(" * size_load_queue                   [nb_rename_unit][nb_load_store_queue] (uint32_t         )\n"));
     72  err (_(" * nb_inst_memory                    [nb_rename_unit][nb_load_store_queue] (uint32_t         )\n"));
    7173  err (_(" * link_load_store_unit_with_thread  [nb_front_end][nb_context]            (uint32_t         )\n"));
    7274
    … …  
    215217    }
    216218
    217   if (argc != static_cast<int>(2+NB_PARAMS+3*_nb_front_end+2*_sum_nb_context+11*_nb_rename_unit+_nb_execute_loop+_nb_rename_unit*_nb_inst_issue+12*_nb_inst_issue+2*_sum_nb_load_store_queue))
     219  if (argc != static_cast<int>(2+NB_PARAMS+3*_nb_front_end+2*_sum_nb_context+11*_nb_rename_unit+_nb_execute_loop+_nb_rename_unit*_nb_inst_issue+12*_nb_inst_issue+3*_sum_nb_load_store_queue))
    218220    usage (argc, argv);
    219221
    … …  
    233235      for (uint32_t j=0; j<_nb_load_store_queue[i]; j++)
    234236        _size_load_queue [i][j] = fromString<uint32_t>(argv[x++]);
     237    }
     238
     239  uint32_t           ** _nb_inst_memory                   = new uint32_t * [_nb_rename_unit];
     240  for (uint32_t i=0; i<_nb_rename_unit; i++)
     241    {
     242      _nb_inst_memory  [i] = new uint32_t [_nb_load_store_queue[i]];
     243      for (uint32_t j=0; j<_nb_load_store_queue[i]; j++)
     244        _nb_inst_memory  [i][j] = fromString<uint32_t>(argv[x++]);
    235245    }
    236246
    … …  
    258268        }
    259269    }
     270
     271  uint32_t          _nb_thread                          ;
     272  uint32_t       ** _translate_num_context_to_num_thread; //[nb_front_end][nb_context]
     273
     274  ALLOC2(_translate_num_context_to_num_thread,uint32_t,_nb_front_end,_nb_context[it1]);
     275
     276  _nb_thread = 0;
     277  for (uint32_t i=0; i<_nb_front_end; i++)
     278    for (uint32_t j=0; j<_nb_context [i]; j++)
     279      _translate_num_context_to_num_thread [i][j] = _nb_thread ++;
    260280
    261281  int _return = EXIT_SUCCESS;
    … …  
    307327         _size_store_queue                 ,
    308328         _size_load_queue                  ,
     329         _nb_inst_memory                   ,
    309330         _link_load_store_unit_with_thread ,
    310331         _implement_group                  ,
     332         _nb_thread                          ,
     333         _translate_num_context_to_num_thread,
    311334         true //is_toplevel
    312335         );
    … …  
    337360    }
    338361
     362  DELETE2(_translate_num_context_to_num_thread,_nb_front_end,_nb_context[it1]);
     363
    339364  for (uint32_t i=0; i<_nb_front_end; i++)
    340365    {
    … …  
    348373    delete [] _link_load_store_unit_with_thread [i];
    349374  delete [] _link_load_store_unit_with_thread;
     375
     376  for (uint32_t i=0; i<_nb_rename_unit; i++)
     377    delete [] _nb_inst_memory  [i];
     378  delete [] _nb_inst_memory ;
    350379
    351380  for (uint32_t i=0; i<_nb_rename_unit; i++)

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/SelfTest/src/test.cpp

    r108 r110  
    99#include "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/SelfTest/include/test.h"
    1010#include "Behavioural/include/Allocation.h"
     11#include "Behavioural/include/Simulation.h"
    1112
    1213void test (string name,
    … …  
    1819  morpheo::behavioural::Parameters_Statistics * _parameters_statistics = new morpheo::behavioural::Parameters_Statistics (5,CYCLE_MAX);
    1920#endif
     21
     22  simulation_init(0,0);
     23
     24  debug_idle_cycle = CYCLE_MAX;
    2025
    2126  Tusage_t _usage = USE_ALL;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/include/Parameters.h

    r108 r110  
    7878  public : uint32_t           ** _size_store_queue                 ;//[nb_rename_unit][nb_load_store_queue]
    7979  public : uint32_t           ** _size_load_queue                  ;//[nb_rename_unit][nb_load_store_queue]
     80  public : uint32_t           ** _nb_inst_memory                   ;//[nb_rename_unit][nb_load_store_queue]
    8081  public : uint32_t           ** _link_load_store_unit_with_thread ;//[nb_front_end][nb_context]
    8182    // SPR
    8283  public : bool              *** _implement_group                  ;//[nb_front_end][nb_context][NB_GROUP]
     84    // Others
     85  public : uint32_t              _nb_thread                          ;
     86  public : uint32_t           ** _translate_num_context_to_num_thread; //[nb_front_end][nb_context]
     87
    8388
    8489  public : std::vector<uint32_t>*_link_front_end_with_rename_unit              ;//[nb_rename_unit]
    … …  
    168173                        uint32_t           ** size_store_queue                 ,//[nb_rename_unit][nb_load_store_queue]
    169174                        uint32_t           ** size_load_queue                  ,//[nb_rename_unit][nb_load_store_queue]
     175                        uint32_t           ** nb_inst_memory                   ,//[nb_rename_unit][nb_load_store_queue]
    170176                        uint32_t           ** link_load_store_unit_with_thread ,//[nb_front_end][nb_context]
    171177                        // SPR
    172178                        bool              *** implement_group                  ,//[nb_front_end][nb_context][NB_GROUP]
    173 
     179                        // Others
     180                        uint32_t              nb_thread                          ,
     181                        uint32_t           ** translate_num_context_to_num_thread, //[nb_front_end][nb_context]
    174182                        bool                  is_toplevel=false
    175183                        );

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/src/Parameters.cpp

    r108 r110  
    6565                          uint32_t           ** size_store_queue                 ,//[nb_rename_unit][nb_load_store_queue]
    6666                          uint32_t           ** size_load_queue                  ,//[nb_rename_unit][nb_load_store_queue]
     67                          uint32_t           ** nb_inst_memory                   ,//[nb_rename_unit][nb_load_store_queue]
    6768                          uint32_t           ** link_load_store_unit_with_thread ,//[nb_front_end][nb_context]
    6869                          // SPR
    6970                          bool              *** implement_group                  ,//[nb_front_end][nb_context][NB_GROUP]
     71                          // Others
     72                          uint32_t              nb_thread                          ,
     73                          uint32_t           ** translate_num_context_to_num_thread, //[nb_front_end][nb_context]
    7074
    7175                          bool                  is_toplevel
    … …  
    116120    _size_store_queue                  = size_store_queue                 ;
    117121    _size_load_queue                   = size_load_queue                  ;
     122    _nb_inst_memory                    = nb_inst_memory                   ;
    118123    _link_load_store_unit_with_thread  = link_load_store_unit_with_thread ;
    119124    _implement_group                   = implement_group                  ;
     125
     126    _nb_thread                           = nb_thread                          ;
     127    _translate_num_context_to_num_thread = translate_num_context_to_num_thread;
    120128
    121129    test();
    … …  
    217225       _size_store_queue                              [i],
    218226       _size_load_queue                               [i],
     227       _nb_inst_memory                                [i],
    219228       _rename_unit_link_load_store_unit_with_thread  [i],
    220229       _rename_select_priority                        [i],
    … …  
    251260       _commit_priority         ,
    252261       _commit_load_balancing   ,
    253        _nb_rename_unit_select   
     262       _nb_rename_unit_select   ,
     263       _nb_thread                          ,
     264       _translate_num_context_to_num_thread
    254265       );
    255266
Note: See TracChangeset for help on using the changeset viewer.