Ignore:
Timestamp:
May 12, 2010, 7:34:01 PM (14 years ago)
Author:
rosiere
Message:

1) add counters_t type for interface
2) fix in check load in load_store_unit
3) add parameters (but not yet implemented)
4) change environment and add script (distcc_env.sh ...)
5) add warning if an unser change rename flag with l.mtspr instruction
6) ...

Location:
trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop
Files:
16 edited
5 moved

Legend:

Unmodified
Added
Removed

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/include/Load_store_unit.h

    r136 r138  
    181181    // Registers
    182182  public    : Tlsq_ptr_t                    * reg_STORE_QUEUE_NB_CHECK     ;//[size_store_queue]
     183//public    : Tcontrol_t                    * reg_STORE_QUEUE_INVALID      ;//[size_store_queue]
    183184  public    : Tlsq_ptr_t                      reg_STORE_QUEUE_PTR_READ     ;
    184185//public    : Tlsq_ptr_t                      reg_LOAD_QUEUE_PTR_READ      ;
    … …  
    236237  public  : void     genMealy_retire           (void);
    237238   
    238   public  : void     function_speculative_load_commit_transition      (void);
    239   public  : void     function_speculative_load_commit_genMoore        (void);
    240   public  : void     function_speculative_load_commit_genMealy_dcache (void);
    241   public  : void     function_speculative_load_commit_genMealy_insert (void);
    242   public  : void     function_speculative_load_commit_genMealy_retire (void);
     239  public  : void     function_speculative_load_access_transition      (void);
     240  public  : void     function_speculative_load_access_genMoore        (void);
     241  public  : void     function_speculative_load_access_genMealy_dcache (void);
     242  public  : void     function_speculative_load_access_genMealy_insert (void);
     243  public  : void     function_speculative_load_access_genMealy_retire (void);
    243244#endif                                         
    244245

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/include/Parameters.h

    r124 r138  
    2727  {
    2828    //-----[ fields ]------------------------------------------------------------
    29   public : uint32_t            _size_store_queue             ;
    30   public : uint32_t            _size_load_queue              ;
    31   public : uint32_t            _size_speculative_access_queue;
    32   public : uint32_t            _nb_port_check                ;
    33   public : Tspeculative_load_t _speculative_load             ;
    34   public : uint32_t            _nb_bypass_memory             ;
    35   public : uint32_t            _nb_cache_port                ;
    36   public : uint32_t            _nb_inst_memory               ;
    37   public : uint32_t            _nb_context                   ;
    38   public : uint32_t            _nb_front_end                 ;
    39   public : uint32_t            _nb_ooo_engine                ;
    40   public : uint32_t            _nb_packet                    ;
    41 //public : uint32_t            _size_general_data            ;
    42 //public : uint32_t            _size_special_data            ;
    43   public : uint32_t            _nb_general_register          ;
    44   public : uint32_t            _nb_special_register          ;
    45   public : uint32_t            _nb_thread                    ;
    46   public : bool              * _num_thread_valid             ; //[nb_thread]
     29  public : uint32_t            _size_store_queue                   ;
     30  public : uint32_t            _size_load_queue                    ;
     31  public : uint32_t            _size_speculative_access_queue      ;
     32  public : uint32_t            _nb_store_queue_bank                ;
     33  public : uint32_t            _nb_load_queue_bank                 ;
     34  public : uint32_t            _nb_port_check                      ;
     35  public : Tspeculative_load_t _speculative_load                   ;
     36  public : Tpredictor_t        _speculative_commit_predictor_scheme;
     37  public : uint32_t          * _lsu_pht_size_counter               ;//[1]
     38  public : uint32_t          * _lsu_pht_nb_counter                 ;//[1]
     39  public : uint32_t            _nb_bypass_memory                   ;
     40  public : uint32_t            _nb_cache_port                      ;
     41  public : uint32_t            _nb_inst_memory                     ;
     42  public : uint32_t            _nb_context                         ;
     43  public : uint32_t            _nb_front_end                       ;
     44  public : uint32_t            _nb_ooo_engine                      ;
     45  public : uint32_t            _nb_packet                          ;
     46//public : uint32_t            _size_general_data                  ;
     47//public : uint32_t            _size_special_data                  ;
     48  public : uint32_t            _nb_general_register                ;
     49  public : uint32_t            _nb_special_register                ;
     50  public : uint32_t            _nb_thread                          ;
     51  public : bool              * _num_thread_valid                   ; //[nb_thread]
    4752
    4853//public : uint32_t            _size_address_store_queue             ;
    … …  
    7075
    7176    //-----[ methods ]-----------------------------------------------------------
    72   public : Parameters  (uint32_t            size_store_queue       ,
    73                         uint32_t            size_load_queue        ,
    74                         uint32_t            size_speculative_access_queue,
    75                         uint32_t            nb_port_check          ,
    76                         Tspeculative_load_t speculative_load       ,
    77                         uint32_t            nb_bypass_memory       ,
    78                         uint32_t            nb_cache_port          ,
    79                         uint32_t            nb_inst_memory         ,
    80                         uint32_t            nb_context             ,
    81                         uint32_t            nb_front_end           ,
    82                         uint32_t            nb_ooo_engine          ,
    83                         uint32_t            nb_packet              ,
    84                         uint32_t            size_general_data      ,
    85                         uint32_t            size_special_data      ,
    86                         uint32_t            nb_general_register    ,
    87                         uint32_t            nb_special_register    ,
    88                         uint32_t            nb_thread              ,
    89                         bool              * num_thread_valid       , //[nb_thread]
     77  public : Parameters  (uint32_t            size_store_queue                   ,
     78                        uint32_t            size_load_queue                    ,
     79                        uint32_t            size_speculative_access_queue      ,
     80                        uint32_t            nb_store_queue_bank                ,
     81                        uint32_t            nb_load_queue_bank                 ,
     82                        uint32_t            nb_port_check                      ,
     83                        Tspeculative_load_t speculative_load                   ,
     84                        Tpredictor_t        speculative_commit_predictor_scheme,
     85                        uint32_t          * lsu_pht_size_counter               ,//[1]
     86                        uint32_t          * lsu_pht_nb_counter                 ,//[1]
     87                        uint32_t            nb_bypass_memory                   ,
     88                        uint32_t            nb_cache_port                      ,
     89                        uint32_t            nb_inst_memory                     ,
     90                        uint32_t            nb_context                         ,
     91                        uint32_t            nb_front_end                       ,
     92                        uint32_t            nb_ooo_engine                      ,
     93                        uint32_t            nb_packet                          ,
     94                        uint32_t            size_general_data                  ,
     95                        uint32_t            size_special_data                  ,
     96                        uint32_t            nb_general_register                ,
     97                        uint32_t            nb_special_register                ,
     98                        uint32_t            nb_thread                          ,
     99                        bool              * num_thread_valid                   , //[nb_thread]
    90100                        bool                is_toplevel=false);
    91101

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/include/Types.h

    r136 r138  
    3535       NO_SPECULATIVE_LOAD     //each load wait all previous store before the data cache access
    3636      ,SPECULATIVE_LOAD_ACCESS //each load wait all previous store before the commiting
    37       ,SPECULATIVE_LOAD_COMMIT //each load commit the result before the end of dependence's check
     37    //,SPECULATIVE_LOAD_COMMIT //each load commit the result before the end of dependence's check
    3838    //,SPECULATIVE_LOAD_BYPASS //each load bypass the result before the end of dependence's check
    3939    } Tspeculative_load_t;
    … …  
    184184  public    : Tgeneral_address_t   _num_reg_rd       ;
    185185  public    : Texception_t         _exception        ;
     186  public    : Tcontrol_t           _can_speculative_commit;
    186187
    187188    friend std::ostream & operator << (std::ostream& os, const Tload_queue_entry_t & x)
    … …  
    194195                << "   * exception                         : " << toString(x._exception) << std::endl
    195196                << "   * check_hit, check_hit_byte         : " << toString(x._check_hit) << " - " << toString(x._check_hit_byte) << std::endl
     197                << "   * can_speculative_commit            : " << toString(x._can_speculative_commit) << std::endl
    196198                << std::hex
    197199                << "   * address                           : " << toString(x._address)<< std::endl
    … …  
    217219      case morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::NO_SPECULATIVE_LOAD     : return "no_speculative_load"    ; break;
    218220      case morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::SPECULATIVE_LOAD_ACCESS : return "speculative_load_access"; break;
    219       case morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::SPECULATIVE_LOAD_COMMIT : return "speculative_load_commit"; break;
    220 //       case morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::SPECULATIVE_LOAD_BYPASS : return "speculative_load_bypass"; break;
     221//    case morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::SPECULATIVE_LOAD_COMMIT : return "speculative_load_commit"; break;
     222//    case morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::SPECULATIVE_LOAD_BYPASS : return "speculative_load_bypass"; break;
    221223      default    : return ""      ; break;
    222224      }
    … …  
    225227  template<> inline morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::Tspeculative_load_t fromString<morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::Tspeculative_load_t>(const std::string& x)
    226228  {
    227     if ( (x.compare(toString(static_cast<uint32_t>(morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::NO_SPECULATIVE_LOAD    ))) == 0) or
    228          (x.compare("no_speculative_load")    == 0))
     229    if ((x.compare(toString(static_cast<uint32_t>(morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::NO_SPECULATIVE_LOAD    ))) == 0) or
     230        (x.compare(toString(                      morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::NO_SPECULATIVE_LOAD     )) == 0))
    229231      return morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::NO_SPECULATIVE_LOAD;
    230     if ( (x.compare(toString(static_cast<uint32_t>(morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::SPECULATIVE_LOAD_ACCESS))) == 0) or
    231          (x.compare("speculative_load_access") == 0))
     232    if ((x.compare(toString(static_cast<uint32_t>(morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::SPECULATIVE_LOAD_ACCESS))) == 0) or
     233        (x.compare(toString(                      morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::SPECULATIVE_LOAD_ACCESS )) == 0))
    232234      return morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::SPECULATIVE_LOAD_ACCESS;
    233     if ( (x.compare(toString(static_cast<uint32_t>(morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::SPECULATIVE_LOAD_COMMIT))) == 0) or
    234          (x.compare("speculative_load_commit") == 0))
    235       return morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::SPECULATIVE_LOAD_COMMIT;
    236 //     if ( (x.compare(toString(static_cast<uint32_t>(morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::SPECULATIVE_LOAD_BYPASS)))) or
    237 //          (x.compare("speculative_load_bypass") == 0))
    238 //       return morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::SPECULATIVE_LOAD_BYPASS;
     235//  if ((x.compare(toString(static_cast<uint32_t>(morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::SPECULATIVE_LOAD_COMMIT))) == 0) or
     236//      (x.compare(toString(                      morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::SPECULATIVE_LOAD_COMMIT )) == 0))
     237//    return morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::SPECULATIVE_LOAD_COMMIT;
     238//  if ((x.compare(toString(static_cast<uint32_t>(morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::SPECULATIVE_LOAD_BYPASS))) == 0) or
     239//      (x.compare(toString(                      morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::SPECULATIVE_LOAD_BYPASS )) == 0))
     240//    return morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::SPECULATIVE_LOAD_BYPASS;
    239241   
    240242    throw (ErrorMorpheo ("<fromString> : Unknow string : \""+x+"\""));

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Load_store_unit.cpp

    r132 r138  
    7777    switch (_param->_speculative_load)
    7878      {
    79       case SPECULATIVE_LOAD_COMMIT :
     79      case SPECULATIVE_LOAD_ACCESS :
    8080        {
    81           function_transition      = &morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::Load_store_unit::function_speculative_load_commit_transition     ;
    82           function_genMoore        = &morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::Load_store_unit::function_speculative_load_commit_genMoore       ;
    83           function_genMealy_dcache = &morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::Load_store_unit::function_speculative_load_commit_genMealy_dcache;
    84           function_genMealy_insert = &morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::Load_store_unit::function_speculative_load_commit_genMealy_insert;
    85           function_genMealy_retire = &morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::Load_store_unit::function_speculative_load_commit_genMealy_retire;
     81          function_transition      = &morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::Load_store_unit::function_speculative_load_access_transition     ;
     82          function_genMoore        = &morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::Load_store_unit::function_speculative_load_access_genMoore       ;
     83          function_genMealy_dcache = &morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::Load_store_unit::function_speculative_load_access_genMealy_dcache;
     84          function_genMealy_insert = &morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::Load_store_unit::function_speculative_load_access_genMealy_insert;
     85          function_genMealy_retire = &morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::Load_store_unit::function_speculative_load_access_genMealy_retire;
    8686          break;
    8787        }
    8888      case NO_SPECULATIVE_LOAD     :
    89       case SPECULATIVE_LOAD_ACCESS :
    90         //case SPECULATIVE_LOAD_BYPASS :
     89      // case SPECULATIVE_LOAD_COMMIT :
     90      //case SPECULATIVE_LOAD_BYPASS :
    9191      default                      :
    9292        {

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Load_store_unit_allocation.cpp

    r136 r138  
    160160
    161161        ALLOC1(reg_STORE_QUEUE_NB_CHECK                  ,Tlsq_ptr_t     ,_param->_size_store_queue);
     162//      ALLOC1(reg_STORE_QUEUE_INVALID                   ,Tcontrol_t     ,_param->_size_store_queue);
    162163
    163164//      ALLOC1(internal_SPECULATIVE_ACCESS_QUEUE_PTR_READ,Tlsq_ptr_t     ,_param->_nb_cache_port);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Load_store_unit_deallocation.cpp

    r136 r138  
    106106
    107107    DELETE1(reg_STORE_QUEUE_NB_CHECK                  ,_param->_size_store_queue);
     108//  DELETE1(reg_STORE_QUEUE_INVALID                   ,_param->_size_store_queue);
    108109
    109110//  DELETE1(internal_SPECULATIVE_ACCESS_QUEUE_PTR_READ,_param->_nb_cache_port);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Load_store_unit_function_speculative_load_access_genMealy_dcache.cpp

    r137 r138  
    2121
    2222#undef  FUNCTION
    23 #define FUNCTION "Load_store_unit::function_speculative_load_commit_genMealy_dcache"
    24   void Load_store_unit::function_speculative_load_commit_genMealy_dcache (void)
     23#define FUNCTION "Load_store_unit::function_speculative_load_access_genMealy_dcache"
     24  void Load_store_unit::function_speculative_load_access_genMealy_dcache (void)
    2525  {
    2626    log_begin(Load_store_unit,FUNCTION);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Load_store_unit_function_speculative_load_access_genMealy_insert.cpp

    r137 r138  
    2121
    2222#undef  FUNCTION
    23 #define FUNCTION "Load_store_unit::function_speculative_load_commit_genMealy_insert"
    24   void Load_store_unit::function_speculative_load_commit_genMealy_insert (void)
     23#define FUNCTION "Load_store_unit::function_speculative_load_access_genMealy_insert"
     24  void Load_store_unit::function_speculative_load_access_genMealy_insert (void)
    2525  {
    2626    log_begin(Load_store_unit,FUNCTION);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Load_store_unit_function_speculative_load_access_genMealy_retire.cpp

    r137 r138  
    2121
    2222#undef  FUNCTION
    23 #define FUNCTION "Load_store_unit::function_speculative_load_commit_genMealy_retire"
    24   void Load_store_unit::function_speculative_load_commit_genMealy_retire (void)
     23#define FUNCTION "Load_store_unit::function_speculative_load_access_genMealy_retire"
     24  void Load_store_unit::function_speculative_load_access_genMealy_retire (void)
    2525  {
    2626    log_begin(Load_store_unit,FUNCTION);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Load_store_unit_function_speculative_load_access_genMoore.cpp

    r137 r138  
    2121
    2222#undef  FUNCTION
    23 #define FUNCTION "Load_store_unit::function_speculative_load_commit_genMoore"
    24   void Load_store_unit::function_speculative_load_commit_genMoore (void)
     23#define FUNCTION "Load_store_unit::function_speculative_load_access_genMoore"
     24  void Load_store_unit::function_speculative_load_access_genMoore (void)
    2525  {
    2626    log_begin(Load_store_unit,FUNCTION);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Load_store_unit_function_speculative_load_access_transition.cpp

    r137 r138  
    228228
    229229#undef  FUNCTION
    230 #define FUNCTION "Load_store_unit::function_speculative_load_commit_transition"
    231   void Load_store_unit::function_speculative_load_commit_transition (void)
     230#define FUNCTION "Load_store_unit::function_speculative_load_access_transition"
     231  void Load_store_unit::function_speculative_load_access_transition (void)
    232232  {
    233233    log_begin(Load_store_unit,FUNCTION);
    … …  
    245245          {
    246246            reg_STORE_QUEUE_NB_CHECK  [i] = 0;
     247//          reg_STORE_QUEUE_INVALID   [i] = 0;
    247248            _store_queue              [i]._state                 = STORE_QUEUE_EMPTY;
    248249            _store_queue              [i]._context_id            = 0; // not necessary
    … …  
    283284            _load_queue               [i]._num_reg_rd            = 0; // not necessary
    284285            _load_queue               [i]._exception             = 0; // not necessary
     286            _load_queue               [i]._can_speculative_commit= 0; // not necessary
    285287          }
    286288
    … …  
    407409
    408410                // find a entry that it need a check
    409                 Tlsq_ptr_t store_queue_ptr_write = _load_queue[index_load_queue]._store_queue_ptr_write;
    410                 Tlsq_ptr_t store_queue_ptr_read  = _load_queue[index_load_queue]._store_queue_ptr_read ;
    411                 Tlsq_ptr_t store_queue_empty     = _load_queue[index_load_queue]._store_queue_empty    ;
     411                Tlsq_ptr_t store_queue_ptr_write     = _load_queue[index_load_queue]._store_queue_ptr_write;
     412                Tlsq_ptr_t store_queue_ptr_read      = _load_queue[index_load_queue]._store_queue_ptr_read ;
     413                Tlsq_ptr_t store_queue_empty         = _load_queue[index_load_queue]._store_queue_empty    ;
    412414//              Tlsq_ptr_t store_queue_ptr_write_old = store_queue_ptr_write;
    413415
    … …  
    442444
    443445                    log_printf(TRACE,Load_store_unit,FUNCTION,"      * store_queue_ptr_write : %d",store_queue_ptr_write);
     446
     447                    bool test_thread_id = true;
     448                   
     449                    // Test thread id
     450                    if (_param->_have_port_context_id)
     451                      test_thread_id &= (_load_queue[index_load_queue]._context_id    == _store_queue[store_queue_ptr_write]._context_id);
     452                    if (_param->_have_port_front_end_id)
     453                      test_thread_id &= (_load_queue[index_load_queue]._front_end_id  == _store_queue[store_queue_ptr_write]._front_end_id);
     454                    if (_param->_have_port_ooo_engine_id)
     455                      test_thread_id &= (_load_queue[index_load_queue]._ooo_engine_id == _store_queue[store_queue_ptr_write]._ooo_engine_id);
    444456                   
    445457                    // switch on store_queue state
    … …  
    450462                      case STORE_QUEUE_VALID_SPECULATIVE :
    451463                        {
    452                          
    453                           log_printf(TRACE,Load_store_unit,FUNCTION,"      * store have a valid entry");
     464                          log_printf(TRACE,Load_store_unit,FUNCTION,"      * store have a valid entry");
    454465                         
    455466                          // TODO : MMU - nous considérons que les adresses sont physique
    456                           bool test_thread_id = true;
    457                          
    458                           // Test thread id
    459                           if (_param->_have_port_context_id)
    460                             test_thread_id &= (_load_queue[index_load_queue]._context_id    == _store_queue[store_queue_ptr_write]._context_id);
    461                           if (_param->_have_port_front_end_id)
    462                             test_thread_id &= (_load_queue[index_load_queue]._front_end_id  == _store_queue[store_queue_ptr_write]._front_end_id);
    463                           if (_param->_have_port_ooo_engine_id)
    464                             test_thread_id &= (_load_queue[index_load_queue]._ooo_engine_id == _store_queue[store_queue_ptr_write]._ooo_engine_id);
    465                          
    466467                          if (test_thread_id)
    467468                            {
    … …  
    481482                                {
    482483                                  log_printf(TRACE,Load_store_unit,FUNCTION,"            * address_msb is the same.");
     484
    483485                                  // all case - [] : store, () : load
    484486                                  // (1) store_max >= load_max and store_min <= load_min  ...[...(...)...]... Ok - inclusion in store
    … …  
    533535                                  log_printf(TRACE,Load_store_unit,FUNCTION,"            * store_num_byte_min      : %d",store_num_byte_min);
    534536                                  log_printf(TRACE,Load_store_unit,FUNCTION,"            * store_num_byte_max      : %d",store_num_byte_max);
    535 
    536 //                                   uint32_t load_nb_byte      = (1<<memory_access(_load_queue[index_load_queue]._operation));
    537 
    538 //                                uint32_t load_num_byte_min = (load_addr & _param->_mask_address_lsb);
    539 //                                uint32_t load_num_byte_max = load_num_byte_min+load_nb_byte;
    540 
    541 //                                log_printf(TRACE,Load_store_unit,FUNCTION,"            * load_num_byte_min       : %d",load_num_byte_min);
    542 //                                log_printf(TRACE,Load_store_unit,FUNCTION,"            * load_num_byte_max       : %d",load_num_byte_max);
    543 
    544 //                                for (uint32_t num_load_byte=load_num_byte_min; num_load_byte<load_num_byte_max; num_load_byte ++)
    545 //                                  {
    546 //                                       // Make a mask
    547 //                                       uint32_t num_store_byte = num_load_byte;
    548                                      
    549537
    550538
    … …  
    671659                                  // The check is finish if all bit is set
    672660                                  end_check = (_load_queue[index_load_queue]._check_hit_byte == _param->_mask_check_hit_byte);
    673 
    674661                                }
    675662                            }
    … …  
    679666                        }
    680667                      case STORE_QUEUE_EMPTY :
     668                        {
     669                          log_printf(TRACE,Load_store_unit,FUNCTION,"      * store is empty ... wait.");
     670                          break;
     671                        }
     672
    681673                      case STORE_QUEUE_NO_VALID_NO_SPECULATIVE :
    682674                        {
    683                           log_printf(TRACE,Load_store_unit,FUNCTION,"      * store have an invalid entry");
     675                          log_printf(TRACE,Load_store_unit,FUNCTION,"      * store have an invalid entry");
     676
     677                          if (test_thread_id)
     678                            {
     679                              end_check    = true; // previous store is invalid -> exception
     680                              change_state = true;
     681                            }
     682                          else
     683                            next = true;
     684                           
    684685                          break;
    685686                        }
    … …  
    852853                  case STORE_QUEUE_EMPTY                   :
    853854                    {
     855//                    reg_STORE_QUEUE_INVALID [index] = false; // new first store instruction
     856
    854857                      if (is_operation_memory_store_head(operation) == true)
    855858                        {
    … …  
    858861                          // test if is a speculation
    859862                          if (operation == OPERATION_MEMORY_STORE_HEAD_KO)
    860                             new_exception = EXCEPTION_MEMORY_MISS_SPECULATION;
     863                            {
     864                              new_exception = EXCEPTION_MEMORY_MISS_SPECULATION;
     865//                            reg_STORE_QUEUE_INVALID [index] = true;
     866                            }
    861867                          else
    862868                            new_exception = EXCEPTION_MEMORY_NONE;
    … …  
    901907#endif
    902908                      if (operation == OPERATION_MEMORY_STORE_HEAD_KO)
    903                         new_exception = EXCEPTION_MEMORY_MISS_SPECULATION; // great prioritary
    904                      
     909                        {
     910                          new_exception = EXCEPTION_MEMORY_MISS_SPECULATION; // great prioritary
     911//                        reg_STORE_QUEUE_INVALID [index] = true;
     912                        }
     913
    905914                      if (new_exception != EXCEPTION_MEMORY_NONE)
    906915                        new_state = STORE_QUEUE_COMMIT;
    … …  
    913922                  case STORE_QUEUE_COMMIT                  :
    914923                    {
    915                       throw ERRORMORPHEO(FUNCTION,"<Load_store_unit::function_speculative_load_commit_transition> Invalid state and operation");
     924                      throw ERRORMORPHEO(FUNCTION,"<Load_store_unit::function_speculative_load_access_transition> Invalid state and operation");
    916925                    }
    917926                  }
    … …  
    11151124            _load_queue [ptr_write]._exception             = exception;
    11161125            _load_queue [ptr_write]._rdata                 = address; // to the exception
     1126
     1127            switch (_param->_speculative_commit_predictor_scheme)
     1128              {
     1129
     1130              case PREDICTOR_NEVER_TAKE  : {_load_queue [ptr_write]._can_speculative_commit = false; break;}
     1131              case PREDICTOR_ALWAYS_TAKE : {_load_queue [ptr_write]._can_speculative_commit = true ; break;}
     1132              case PREDICTOR_COUNTER     : {_load_queue [ptr_write]._can_speculative_commit = false; break;} // TODO
     1133              default :
     1134                {
     1135                  // throw ERRORMORPHEO(FUNCTION,_("Invalid predictor scheme.\n"));
     1136                  _load_queue [ptr_write]._can_speculative_commit = false;
     1137                  break;
     1138                }
     1139              }
    11171140           
    11181141            log_printf(TRACE,Load_store_unit,FUNCTION,"    * speculative_access_queue");

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Parameters.cpp

    r124 r138  
    2020#undef  FUNCTION
    2121#define FUNCTION "Load_store_unit::Parameters"
    22   Parameters::Parameters (uint32_t            size_store_queue       ,
    23                           uint32_t            size_load_queue        ,
    24                           uint32_t            size_speculative_access_queue,
    25                           uint32_t            nb_port_check          ,
    26                           Tspeculative_load_t speculative_load       ,
    27                           uint32_t            nb_bypass_memory       ,
    28                           uint32_t            nb_cache_port          ,
    29                           uint32_t            nb_inst_memory         ,
    30                           uint32_t            nb_context             ,
    31                           uint32_t            nb_front_end           ,
    32                           uint32_t            nb_ooo_engine          ,
    33                           uint32_t            nb_packet              ,
    34                           uint32_t            size_general_data      ,
    35                           uint32_t            size_special_data      ,
    36                           uint32_t            nb_general_register    ,
    37                           uint32_t            nb_special_register    ,
    38                           uint32_t            nb_thread              ,
    39                           bool              * num_thread_valid       , //[nb_thread]
     22  Parameters::Parameters (uint32_t            size_store_queue                   ,
     23                          uint32_t            size_load_queue                    ,
     24                          uint32_t            size_speculative_access_queue      ,
     25                          uint32_t            nb_store_queue_bank                ,
     26                          uint32_t            nb_load_queue_bank                 ,
     27                          uint32_t            nb_port_check                      ,
     28                          Tspeculative_load_t speculative_load                   ,
     29                          Tpredictor_t        speculative_commit_predictor_scheme,
     30                          uint32_t          * lsu_pht_size_counter               ,//[1]
     31                          uint32_t          * lsu_pht_nb_counter                 ,//[1]
     32                          uint32_t            nb_bypass_memory                   ,
     33                          uint32_t            nb_cache_port                      ,
     34                          uint32_t            nb_inst_memory                     ,
     35                          uint32_t            nb_context                         ,
     36                          uint32_t            nb_front_end                       ,
     37                          uint32_t            nb_ooo_engine                      ,
     38                          uint32_t            nb_packet                          ,
     39                          uint32_t            size_general_data                  ,
     40                          uint32_t            size_special_data                  ,
     41                          uint32_t            nb_general_register                ,
     42                          uint32_t            nb_special_register                ,
     43                          uint32_t            nb_thread                          ,
     44                          bool              * num_thread_valid                   , //[nb_thread]
    4045                          bool                is_toplevel)
    4146  {
    4247    log_printf(FUNC,Load_store_unit,FUNCTION,"Begin");
    4348
    44     _size_store_queue                      = size_store_queue       ;
    45     _size_load_queue                       = size_load_queue        ;
    46     _size_speculative_access_queue         = size_speculative_access_queue;
    47     _nb_port_check                         = nb_port_check          ;
    48     _speculative_load                      = speculative_load       ;
    49     _nb_bypass_memory                      = nb_bypass_memory       ;
    50     _nb_cache_port                         = nb_cache_port          ;
    51     _nb_inst_memory                        = nb_inst_memory         ;
    52     _nb_context                            = nb_context             ;
    53     _nb_front_end                          = nb_front_end           ;
    54     _nb_ooo_engine                         = nb_ooo_engine          ;
    55     _nb_packet                             = nb_packet              ;
    56     _nb_general_register                   = nb_general_register    ;
    57     _nb_special_register                   = nb_special_register    ;
    58     _nb_thread                             = nb_thread              ;
    59     _num_thread_valid                      = num_thread_valid       ;
     49    _size_store_queue                      = size_store_queue                   ;
     50    _size_load_queue                       = size_load_queue                    ;
     51    _size_speculative_access_queue         = size_speculative_access_queue      ;
     52    _nb_store_queue_bank                   = nb_store_queue_bank                ;
     53    _nb_load_queue_bank                    = nb_load_queue_bank                 ;
     54    _nb_port_check                         = nb_port_check                      ;
     55    _speculative_load                      = speculative_load                   ;
     56    _speculative_commit_predictor_scheme   = speculative_commit_predictor_scheme;
     57    _lsu_pht_size_counter                  = lsu_pht_size_counter               ;
     58    _lsu_pht_nb_counter                    = lsu_pht_nb_counter                 ;
     59    _nb_bypass_memory                      = nb_bypass_memory                   ;
     60    _nb_cache_port                         = nb_cache_port                      ;
     61    _nb_inst_memory                        = nb_inst_memory                     ;
     62    _nb_context                            = nb_context                         ;
     63    _nb_front_end                          = nb_front_end                       ;
     64    _nb_ooo_engine                         = nb_ooo_engine                      ;
     65    _nb_packet                             = nb_packet                          ;
     66    _nb_general_register                   = nb_general_register                ;
     67    _nb_special_register                   = nb_special_register                ;
     68    _nb_thread                             = nb_thread                          ;
     69    _num_thread_valid                      = num_thread_valid                   ;
    6070   
    6171    _size_speculative_access_queue_ptr     = log2(size_speculative_access_queue);
    … …  
    99109    log_printf(FUNC,Load_store_unit,FUNCTION,"End");
    100110  };
    101  
    102 // #undef  FUNCTION
    103 // #define FUNCTION "Load_store_unit::Parameters (copy)"
    104 //   Parameters::Parameters (Parameters & param):
    105 //     _size_store_queue        (param._size_store_queue       ),
    106 //     _size_load_queue         (param._size_load_queue        ),
    107 //     _size_speculative_access_queue (param._size_speculative_access_queue),
    108 //     _nb_port_check           (param._nb_port_check          ),
    109 //     _speculative_load        (param._speculative_load       ),
    110 //     _nb_bypass_memory        (param._nb_bypass_memory       ),
    111 //     _nb_cache_port           (param._nb_cache_port          ),
    112 //     _nb_inst_memory          (param._nb_inst_memory         ),
    113 //     _nb_context              (param._nb_context             ),
    114 //     _nb_front_end            (param._nb_front_end           ),
    115 //     _nb_ooo_engine           (param._nb_ooo_engine          ),
    116 //     _nb_packet               (param._nb_packet              ),
    117 //     _size_general_data       (param._size_general_data      ),
    118 //     _size_special_data       (param._size_special_data      ),
    119 //     _nb_general_register     (param._nb_general_register    ),
    120 //     _nb_special_register     (param._nb_special_register    ),
    121 
    122 //     _size_address_store_queue              (param._size_address_store_queue             ),
    123 //     _size_address_load_queue               (param._size_address_load_queue              ),
    124 //     _size_address_speculative_access_queue (param._size_address_speculative_access_queue),
    125 
    126 //     _size_context_id         (param._size_context_id        ),
    127 //     _size_front_end_id       (param._size_front_end_id      ),
    128 //     _size_ooo_engine_id      (param._size_ooo_engine_id     ),
    129 //     _size_packet_id          (param._size_packet_id         ),
    130 //     _size_general_register   (param._size_general_register  ),
    131 //     _size_special_register   (param._size_special_register  ),
    132 //     _size_dcache_context_id  (param._size_dcache_context_id ),
    133 //     _size_dcache_packet_id   (param._size_dcache_packet_id  ),
    134 
    135 //     _have_port_context_id    (param._have_port_context_id   ),
    136 //     _have_port_front_end_id  (param._have_port_front_end_id ),
    137 //     _have_port_ooo_engine_id (param._have_port_ooo_engine_id),
    138 //     _have_port_packet_id     (param._have_port_packet_id    ),
    139 //     _have_port_dcache_context_id(param._have_port_dcache_context_id),
    140 //     _have_port_load_queue_ptr(param._have_port_load_queue_ptr),
    141 
    142 //     _mask_address_lsb        (param._mask_address_lsb),
    143 //     _mask_address_msb        (param._mask_address_msb)
    144 //   {
    145 //     log_printf(FUNC,Load_store_unit,FUNCTION,"Begin");
    146 //     test();
    147 //     log_printf(FUNC,Load_store_unit,FUNCTION,"End");
    148 //   };
    149111
    150112#undef  FUNCTION

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Parameters_msg_error.cpp

    r88 r138  
    66 */
    77
     8#include "Behavioural/include/Test.h"
    89#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/include/Parameters.h"
    910#include <sstream>
    … …  
    2930    switch (_speculative_load)
    3031      {
    31       case SPECULATIVE_LOAD_COMMIT :
     32      case SPECULATIVE_LOAD_ACCESS :
    3233        {
    3334          if (not (_nb_bypass_memory == 0))
    … …  
    3738        }
    3839      case NO_SPECULATIVE_LOAD     :
    39       case SPECULATIVE_LOAD_ACCESS :
    4040      // case SPECULATIVE_LOAD_BYPASS :
     41      // case SPECULATIVE_LOAD_COMMIT :
    4142      default                      :
    4243        {
    … …  
    5556      test.error(_("Bypass number must be less than load_queue's size.\n"));
    5657
     58    if (not is_multiple(_nb_store_queue_bank,_nb_inst_memory))
     59      test.error(_("Number of bank of store queue must be a multiple of number input instruction.\n"));
     60
     61    if (not is_multiple(_nb_load_queue_bank,_nb_inst_memory))
     62      test.error(_("Number of bank of load queue must be a multiple of number input instruction.\n"));
     63   
     64    switch (_speculative_commit_predictor_scheme)
     65      {
     66      case PREDICTOR_NEVER_TAKE  :
     67      case PREDICTOR_ALWAYS_TAKE :
     68      case PREDICTOR_COUNTER     :
     69        {
     70          break;
     71        }
     72      case PREDICTOR_STATIC      :
     73      case PREDICTOR_LAST_TAKE   :
     74      case PREDICTOR_LOCAL       :
     75      case PREDICTOR_GLOBAL      :
     76      case PREDICTOR_META        :
     77      case PREDICTOR_CUSTOM      :
     78        {
     79          test.error(toString(_("Predictor scheme \"%s\" is unsupported for load scheme.\n"),toString(_speculative_commit_predictor_scheme).c_str()));
     80          break;
     81        }
     82      }
     83   
    5784    if (_nb_cache_port > 1)
    5885      test.warning(_("nb_cache_port > 1 is unsupported (Coming Soon).\n"));

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/include/Parameters.h

    r88 r138  
    2626  {
    2727    //-----[ fields ]------------------------------------------------------------
     28  public : uint32_t    _nb_inst_read            ;
    2829  public : uint32_t    _size_read_queue         ;
    2930  public : uint32_t    _size_reservation_station;
    … …  
    6364
    6465    //-----[ methods ]-----------------------------------------------------------
    65   public : Parameters  (uint32_t size_read_queue         ,
     66  public : Parameters  (uint32_t nb_inst_read            ,
     67                        uint32_t size_read_queue         ,
    6668                        uint32_t size_reservation_station,
    6769                        uint32_t nb_context              ,

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/src/Parameters.cpp

    r88 r138  
    1919#undef  FUNCTION
    2020#define FUNCTION "Read_unit::Parameters"
    21   Parameters::Parameters (uint32_t size_read_queue         ,
     21  Parameters::Parameters (uint32_t nb_inst_read            ,
     22                          uint32_t size_read_queue         ,
    2223                          uint32_t size_reservation_station,
    2324                          uint32_t nb_context              ,
    … …  
    4041    log_printf(FUNC,Read_unit,FUNCTION,"Begin");
    4142
     43    _nb_inst_read             = nb_inst_read            ;
    4244    _size_read_queue          = size_read_queue         ;
    4345    _size_reservation_station = size_reservation_station;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/src/Parameters_msg_error.cpp

    r81 r138  
    2727    Parameters_test test ("Read_unit");
    2828
     29    if (_nb_inst_read != 1)
     30      test.error(_("nb_inst_read must be equal at 1.\n"));
     31
    2932    log_printf(FUNC,Read_unit,FUNCTION,"End");
    3033

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/include/Parameters.h

    r115 r138  
    2828  {
    2929    //-----[ fields ]------------------------------------------------------------
     30  public : uint32_t              _nb_inst_write                ;
    3031  public : uint32_t              _size_write_queue             ;
    3132  public : uint32_t              _size_execute_queue           ;
    … …  
    6162
    6263    //-----[ methods ]-----------------------------------------------------------
    63   public : Parameters  (uint32_t              size_write_queue   ,
     64  public : Parameters  (uint32_t              nb_inst_write      ,
     65                        uint32_t              size_write_queue   ,
    6466                        uint32_t              size_execute_queue ,
    6567                        uint32_t              nb_context         ,

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/src/Parameters.cpp

    r115 r138  
    1919#undef  FUNCTION
    2020#define FUNCTION "Write_unit::Parameters"
    21   Parameters::Parameters (uint32_t              size_write_queue   ,
     21  Parameters::Parameters (uint32_t              nb_inst_write      ,
     22                          uint32_t              size_write_queue   ,
    2223                          uint32_t              size_execute_queue ,
    2324                          uint32_t              nb_context         ,
    … …  
    3637    log_printf(FUNC,Write_unit,FUNCTION,"Begin");
    3738
     39    _nb_inst_write                = nb_inst_write      ;
    3840    _size_write_queue             = size_write_queue   ;
    3941    _size_execute_queue           = size_execute_queue ;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/src/Parameters_msg_error.cpp

    r81 r138  
    2727
    2828    if (_size_write_queue == 0)
    29       test.error("Write queue must have a less one entry.");
     29      test.error(_("Write queue must have a less one entry.\n"));
     30
     31    if (_nb_inst_write != 1)
     32      test.error(_("nb_inst_write must be equal at 1.\n"));
    3033
    3134    log_printf(FUNC,Write_unit,FUNCTION,"End");

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/include/Parameters.h

    r136 r138  
    5454  public : uint32_t            * _size_load_queue                               ; //[nb_load_store_unit]
    5555  public : uint32_t            * _size_speculative_access_queue                 ; //[nb_load_store_unit]
     56  public : uint32_t            * _nb_store_queue_bank                           ; //[nb_load_store_unit]
     57  public : uint32_t            * _nb_load_queue_bank                            ; //[nb_load_store_unit]
    5658  public : uint32_t            * _nb_port_check                                 ; //[nb_load_store_unit]
    5759  public : Tspeculative_load_t * _speculative_load                              ; //[nb_load_store_unit]
     60  public : Tpredictor_t        * _speculative_commit_predictor_scheme           ; //[nb_load_store_unit]
     61  public : uint32_t           ** _lsu_pht_size_counter                          ; //[nb_load_store_unit][1]
     62  public : uint32_t           ** _lsu_pht_nb_counter                            ; //[nb_load_store_unit][1]
    5863  public : uint32_t            * _nb_bypass_memory                              ; //[nb_load_store_unit]
    5964  public : uint32_t            * _nb_cache_port                                 ; //[nb_load_store_unit]
    6065  public : uint32_t            * _nb_inst_memory                                ; //[nb_load_store_unit]
    6166    //  * read_unit                                                                   
     67  public : uint32_t            * _nb_inst_read                                  ; //[nb_read_unit]
    6268  public : uint32_t            * _size_read_queue                               ; //[nb_read_unit]
    6369  public : uint32_t            * _size_reservation_station                      ; //[nb_read_unit]
    … …  
    7076  public : bool               ** _link_read_unit_with_thread                    ; //[nb_read_unit][nb_thread]
    7177    //  * write_unit                                                                 
     78  public : uint32_t            * _nb_inst_write                                 ; //[nb_write_unit]
    7279  public : uint32_t            * _size_write_queue                              ; //[nb_write_unit]
    7380  public : uint32_t            * _size_execute_queue                            ; //[nb_write_unit]
    … …  
    158165                        uint32_t              size_special_data                             ,
    159166                       
     167                        uint32_t            * nb_inst_read                                  ,//[nb_read_unit]
    160168                        uint32_t            * size_read_queue                               ,//[nb_read_unit]
    161169                        uint32_t            * size_reservation_station                      ,//[nb_read_unit]
    … …  
    169177                        uint32_t            * size_load_queue                               ,//[nb_load_store_unit]
    170178                        uint32_t            * size_speculative_access_queue                 ,//[nb_load_store_unit]
     179                        uint32_t            * nb_store_queue_bank                           ,//[nb_load_store_unit]
     180                        uint32_t            * nb_load_queue_bank                            ,//[nb_load_store_unit]
    171181                        uint32_t            * nb_port_check                                 ,//[nb_load_store_unit]
    172182                        Tspeculative_load_t * speculative_load                              ,//[nb_load_store_unit]
     183                        Tpredictor_t        * speculative_commit_predictor_scheme           ,//[nb_load_store_unit]
     184                        uint32_t           ** lsu_pht_size_counter                          ,//[nb_load_store_unit][1]
     185                        uint32_t           ** lsu_pht_nb_counter                            ,//[nb_load_store_unit][1]
    173186                        uint32_t            * nb_bypass_memory                              ,//[nb_load_store_unit]
    174187                        uint32_t            * nb_cache_port                                 ,//[nb_load_store_unit]
    175188                        uint32_t            * nb_inst_memory                                ,//[nb_load_store_unit]
    176189                       
     190                        uint32_t            * nb_inst_write                                 ,//[nb_write_unit]
    177191                        uint32_t            * size_write_queue                              ,//[nb_write_unit]
    178192                        uint32_t            * size_execute_queue                            ,//[nb_write_unit]

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/src/Parameters.cpp

    r136 r138  
    3131                          uint32_t              size_special_data                         ,
    3232                         
     33                          uint32_t            * nb_inst_read                              ,//[nb_read_unit]
    3334                          uint32_t            * size_read_queue                           ,//[nb_read_unit]
    3435                          uint32_t            * size_reservation_station                  ,//[nb_read_unit]
    … …  
    4243                          uint32_t            * size_load_queue                           ,//[nb_load_store_unit]
    4344                          uint32_t            * size_speculative_access_queue             ,//[nb_load_store_unit]
    44                           uint32_t            * nb_port_check                             ,//[nb_load_store_unit]
    45                           Tspeculative_load_t * speculative_load                          ,//[nb_load_store_unit]
     45                          uint32_t            * nb_store_queue_bank                       ,//[nb_load_store_unit]
     46                          uint32_t            * nb_load_queue_bank                        ,//[nb_load_store_unit]
     47                          uint32_t            * nb_port_check                             ,//[nb_load_store_unit]
     48                          Tspeculative_load_t * speculative_load                          ,//[nb_load_store_unit]
     49                          Tpredictor_t        * speculative_commit_predictor_scheme       ,//[nb_load_store_unit]
     50                          uint32_t           ** lsu_pht_size_counter                      ,//[nb_load_store_unit][1]
     51                          uint32_t           ** lsu_pht_nb_counter                        ,//[nb_load_store_unit][1]
    4652                          uint32_t            * nb_bypass_memory                          ,//[nb_load_store_unit]
    4753                          uint32_t            * nb_cache_port                             ,//[nb_load_store_unit]
    4854                          uint32_t            * nb_inst_memory                            ,//[nb_load_store_unit]
    4955
     56                          uint32_t            * nb_inst_write                             ,//[nb_write_unit]
    5057                          uint32_t            * size_write_queue                          ,//[nb_write_unit]
    5158                          uint32_t            * size_execute_queue                        ,//[nb_write_unit]
    … …  
    9299    _nb_packet                                  = nb_packet                            ;
    93100                                               
     101    _nb_inst_read                               = nb_inst_read                         ;
    94102    _size_read_queue                            = size_read_queue                      ;
    95103    _size_reservation_station                   = size_reservation_station             ;
    … …  
    100108    _get_custom_information                     = get_custom_information               ;
    101109                                               
     110    _nb_inst_write                              = nb_inst_write                        ;
    102111    _size_store_queue                           = size_store_queue                     ;
    103112    _size_load_queue                            = size_load_queue                      ;
    104113    _size_speculative_access_queue              = size_speculative_access_queue        ;
     114    _nb_store_queue_bank                        = nb_store_queue_bank                  ;
     115    _nb_load_queue_bank                         = nb_load_queue_bank                   ;
    105116    _nb_port_check                              = nb_port_check                        ;
    106117    _speculative_load                           = speculative_load                     ;
     118    _speculative_commit_predictor_scheme        = speculative_commit_predictor_scheme  ;
     119    _lsu_pht_size_counter                       = lsu_pht_size_counter                 ;
     120    _lsu_pht_nb_counter                         = lsu_pht_nb_counter                   ;
    107121    _nb_bypass_memory                           = nb_bypass_memory                     ;
    108122    _nb_cache_port                              = nb_cache_port                        ;
    … …  
    379393    for (uint32_t i=0; i<_nb_read_unit; i++)
    380394      _param_read_unit [i] = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_read_unit::read_unit::Parameters
    381         (_size_read_queue               [i],
     395        (_nb_inst_read                  [i],
     396         _size_read_queue               [i],
    382397         _size_reservation_station      [i],
    383398         _nb_context                       ,
    … …  
    421436        else
    422437          _param_load_store_unit [x] = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::Parameters
    423             (_size_store_queue              [x],
    424              _size_load_queue               [x],
    425              _size_speculative_access_queue [x],
    426              _nb_port_check                 [x],
    427              _speculative_load              [x],
    428              _nb_bypass_memory              [x],
    429              _nb_cache_port                 [x],
    430              _nb_inst_memory                [x],
    431              _nb_context                       ,
    432              _nb_front_end                     ,
    433              _nb_ooo_engine                    ,
    434              _nb_packet                        ,
    435               size_general_data                ,
    436               size_special_data                ,
    437              _max_nb_special_register          ,
    438              _max_nb_general_register          ,
    439              _nb_thread                        ,
    440              _num_thread_valid                 );
     438            (_size_store_queue                    [x],
     439             _size_load_queue                     [x],
     440             _size_speculative_access_queue       [x],
     441
     442             _nb_store_queue_bank                 [x],
     443             _nb_load_queue_bank                  [x],
     444             _nb_port_check                       [x],
     445             _speculative_load                    [x],
     446             _speculative_commit_predictor_scheme [x],
     447             _lsu_pht_size_counter                [x],
     448             _lsu_pht_nb_counter                  [x],
     449             _nb_bypass_memory                    [x],
     450             _nb_cache_port                       [x],
     451             _nb_inst_memory                      [x],
     452             _nb_context                             ,
     453             _nb_front_end                           ,
     454             _nb_ooo_engine                          ,
     455             _nb_packet                              ,
     456              size_general_data                      ,
     457              size_special_data                      ,
     458             _max_nb_special_register                ,
     459             _max_nb_general_register                ,
     460             _nb_thread                              ,
     461             _num_thread_valid                       );
    441462      }
    442463
    … …  
    446467    for (uint32_t i=0; i<_nb_write_unit; i++)
    447468      _param_write_unit [i] = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::Parameters
    448         (_size_write_queue        [i],
     469        (_nb_inst_write           [i],
     470         _size_write_queue        [i],
    449471         _size_execute_queue      [i],
    450472         _nb_context                 ,
Note: See TracChangeset for help on using the changeset viewer.