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/Issue_queue
Files:
1 deleted
9 edited

Legend:

Unmodified
Added
Removed
  • 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;
Note: See TracChangeset for help on using the changeset viewer.