Ignore:
Timestamp:
Feb 27, 2009, 7:37:40 PM (15 years ago)
Author:
rosiere
Message:

1) Decod_queue : multi implementation (one_fifo, multi_fifo)
2) Issue_queue : multi implementation (in_order, out_of_order)
3) Direction : Add Meta predictor
4) Context_State : re add Branch_complete, More priority to Load miss (is not speculative)
5) Return_Address_Stack : update reg_PREDICT pointer on decod miss prediction
6) UPT : Fix bug in multi event
7) Prediction_glue : in read_stack case, insert in UPT pc_next
8) Rename select : when rob have an event (need flush), read_r{a,b,c} and write_r{d,e} is set at 0

Location:
trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/src
Files:
7 added
7 edited

Legend:

Unmodified
Added
Removed

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

    r110 r111  
    7575    if (usage_is_set(_usage,USE_SYSTEMC))
    7676      {
    77         log_printf(INFO,Issue_queue,FUNCTION,_("<%s> : Method - transition"),_name.c_str());
     77        // Function pointer
     78        switch (_param->_queue_scheme)
     79          {
     80          case ISSUE_QUEUE_SCHEME_IN_ORDER        :
     81            {
     82              function_transition         = &morpheo::behavioural::core::multi_ooo_engine::ooo_engine::issue_queue::Issue_queue::function_in_order_transition        ;
     83              function_genMoore           = &morpheo::behavioural::core::multi_ooo_engine::ooo_engine::issue_queue::Issue_queue::function_in_order_genMoore          ;
     84              function_genMealy_issue_in  = NULL;
     85              function_genMealy_issue_out = &morpheo::behavioural::core::multi_ooo_engine::ooo_engine::issue_queue::Issue_queue::function_in_order_genMealy_issue_out;
     86             
     87              break;
     88            }
     89          case ISSUE_QUEUE_SCHEME_OUT_OF_ORDER    :
     90            {
     91              function_transition         = &morpheo::behavioural::core::multi_ooo_engine::ooo_engine::issue_queue::Issue_queue::function_out_of_order_transition        ;
     92              function_genMoore           = &morpheo::behavioural::core::multi_ooo_engine::ooo_engine::issue_queue::Issue_queue::function_out_of_order_genMoore          ;
     93              function_genMealy_issue_in  = NULL;
     94              function_genMealy_issue_out = NULL;
     95             
     96              break;
     97            }
     98          default :
     99            {
     100              break;
     101            }
     102          }
    78103
    79         SC_METHOD (transition);
    80         dont_initialize ();
    81         sensitive << (*(in_CLOCK)).pos();
    82        
     104        if (function_transition != NULL)
     105          {
     106            log_printf(INFO,Issue_queue,FUNCTION,_("<%s> : Method - transition"),_name.c_str());
     107           
     108            SC_METHOD (transition);
     109            dont_initialize ();
     110            sensitive << (*(in_CLOCK)).pos();
     111           
    83112# ifdef SYSTEMCASS_SPECIFIC
    84         // List dependency information
     113            // List dependency information
    85114# endif   
     115          }
    86116
    87         log_printf(INFO,Issue_queue,FUNCTION,_("<%s> : Method - genMoore"),_name.c_str());
     117        if (function_genMoore != NULL)
     118          {
     119            log_printf(INFO,Issue_queue,FUNCTION,_("<%s> : Method - genMoore"),_name.c_str());
     120           
     121            SC_METHOD (genMoore);
     122            dont_initialize ();
     123            sensitive << (*(in_CLOCK)).neg(); // need internal register
     124           
     125# ifdef SYSTEMCASS_SPECIFIC
     126            // List dependency information
     127# endif   
     128          }
    88129
    89         SC_METHOD (genMoore);
    90         dont_initialize ();
    91         sensitive << (*(in_CLOCK)).neg(); // need internal register
    92        
     130        if (function_genMealy_issue_in != NULL)
     131          {
     132            log_printf(INFO,Issue_queue,FUNCTION,_("<%s> : Method - genMealy_issue_in"),_name.c_str());
     133           
     134            SC_METHOD (genMealy_issue_in);
     135            dont_initialize ();
     136            sensitive << (*(in_CLOCK)).neg(); // need internal register
     137           
    93138# ifdef SYSTEMCASS_SPECIFIC
    94         // List dependency information
     139            // List dependency information
    95140# endif   
     141          }
     142
     143        if (function_genMealy_issue_out != NULL)
     144          {
     145            log_printf(INFO,Issue_queue,FUNCTION,_("<%s> : Method - genMealy_issue_out"),_name.c_str());
     146           
     147            SC_METHOD (genMealy_issue_out);
     148            dont_initialize ();
     149            sensitive << (*(in_CLOCK)).neg(); // need internal register
     150
     151            if (_param->_queue_scheme == ISSUE_QUEUE_SCHEME_IN_ORDER)
     152              {
     153                for (uint32_t i=0; i<_param->_nb_inst_issue; ++i)
     154                  sensitive << (*(in_ISSUE_OUT_ACK [i]));
     155              }
     156           
     157# ifdef SYSTEMCASS_SPECIFIC
     158            // List dependency information
     159# endif   
     160          }
    96161
    97162#endif

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

    r110 r111  
    154154
    155155    ALLOC1(internal_REEXECUTE_ACK           ,Tcontrol_t,_param->_nb_inst_reexecute);
     156
     157    if (_param->_queue_scheme == ISSUE_QUEUE_SCHEME_OUT_OF_ORDER)
     158      {
     159    ALLOC1(internal_BANK_IN_ACK             ,Tcontrol_t,_param->_nb_bank);
     160    ALLOC1(internal_BANK_IN_NUM_RENAME_UNIT ,uint32_t  ,_param->_nb_bank);
     161    ALLOC1(internal_BANK_IN_NUM_INST        ,uint32_t  ,_param->_nb_bank);
     162      }
     163    if (_param->_queue_scheme == ISSUE_QUEUE_SCHEME_IN_ORDER)
     164      {
     165    ALLOC2(internal_ISSUE_IN_ACK            ,Tcontrol_t,_param->_nb_rename_unit,_param->_nb_inst_rename[it1]);
     166      }
    156167      }
    157168
    158169    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    159 
    160170    _priority_in  = new generic::priority::Priority (_name+"_priority_in"   ,
    161171                                                     _param->_priority      ,
    … …  
    165175                                                     _param->_nb_rename_unit_select);
    166176
     177    if (_param->_queue_scheme == ISSUE_QUEUE_SCHEME_OUT_OF_ORDER)
     178      {
    167179    _priority_out = new generic::priority::Priority (_name+"_priority_out"  ,
    168180                                                     _param->_priority      ,
    … …  
    174186                                                     _param->_nb_bank,
    175187                                                     _param->_nb_bank);
     188      }
    176189
    177190#ifdef POSITION

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

    r110 r111  
    9898       
    9999        // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    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 
    104100        DELETE1(internal_ISSUE_OUT_VAL           ,_param->_nb_inst_issue);
    105101        DELETE1(internal_ISSUE_OUT_FROM_REEXECUTE,_param->_nb_inst_issue);
    … …  
    108104
    109105        DELETE1(internal_REEXECUTE_ACK           ,_param->_nb_inst_reexecute);
     106
     107        if (_param->_queue_scheme == ISSUE_QUEUE_SCHEME_OUT_OF_ORDER)
     108          {
     109        DELETE1(internal_BANK_IN_ACK             ,_param->_nb_bank);
     110        DELETE1(internal_BANK_IN_NUM_RENAME_UNIT ,_param->_nb_bank);
     111        DELETE1(internal_BANK_IN_NUM_INST        ,_param->_nb_bank);
     112          }
     113        if (_param->_queue_scheme == ISSUE_QUEUE_SCHEME_IN_ORDER)
     114          {
     115        DELETE2(internal_ISSUE_IN_ACK            ,_param->_nb_rename_unit,_param->_nb_inst_rename[it1]);
     116          }
    110117      }
    111118   
    … …  
    113120   
    114121    delete    _priority_in ;
    115     delete    _priority_out;
    116     delete    _priority_reg;
     122    if (_param->_queue_scheme == ISSUE_QUEUE_SCHEME_OUT_OF_ORDER)
     123      {
     124        delete    _priority_out;
     125        delete    _priority_reg;
     126      }
    117127    delete    _component;
    118128

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

    r110 r111  
    3939      }
    4040
    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;
    125            
    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     }
     41    (this->*function_genMoore) ();
    22442
    22543    log_end(Issue_queue,FUNCTION);

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

    r110 r111  
    2727      {
    2828        _priority_in ->reset();
    29         _priority_out->reset();
    30         _priority_reg->reset();
    31        
    32         for (uint32_t i=0; i<_param->_nb_bank; i++)
    33           _issue_queue [i].clear();
    3429        _reexecute_queue.clear();
    3530      }
    … …  
    3732      {
    3833        _priority_in ->transition();
    39         _priority_out->transition();
    40         _priority_reg->transition();
    41 
    42         // ===================================================================
    43         // =====[ ISSUE_IN ]==================================================
    44         // ===================================================================
    45 
    46         for (uint32_t i=0; i<_param->_nb_bank; i++)
    47           if (internal_BANK_IN_ACK [i])
    48             {
    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 
    56 #ifdef STATISTICS
    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             }
    8634
    8735        // ===================================================================
    … …  
    13078          if (internal_ISSUE_OUT_VAL [i] and PORT_READ(in_ISSUE_OUT_ACK [i]))
    13179            {
    132               entry_t * entry    = internal_ISSUE_OUT_ENTRY    [i];
    133 
     80#ifdef STATISTICS
     81              if (usage_is_set(_usage,USE_STATISTICS))
     82                (*_stat_nb_inst_issue_out ) ++;
     83#endif
    13484              if (internal_ISSUE_OUT_FROM_REEXECUTE [i])
    13585                {
     86                  entry_t * entry = internal_ISSUE_OUT_ENTRY    [i];
     87                 
    13688                  log_printf(TRACE,Issue_queue,FUNCTION,"  * ISSUE_OUT [%d] - From Reexecute_queue",i);
    13789                 
    13890                  _reexecute_queue.remove(entry);
     91                 
     92                  delete entry;
    13993                }
    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             }
     94                // else ... in function specific
     95            }
    15296      }
    15397
    154 #if defined(DEBUG) and defined(DEBUG_Issue_queue) and (DEBUG >= DEBUG_TRACE)
     98    // specific implementation
     99    (this->*function_transition) ();
     100
     101    // ===================================================================
     102    // =====[ PRINT ]====================================================
     103    // ===================================================================
     104
     105#if defined(DEBUG) and DEBUG_Issue_queue and (DEBUG >= DEBUG_TRACE)
    155106    log_printf(TRACE,Issue_queue,FUNCTION,"  * Dump Issue_queue");
    156107
    … …  
    245196#endif
    246197
     198
     199
    247200#if defined(STATISTICS) or defined(VHDL_TESTBENCH)
    248201    end_cycle ();

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

    r110 r111  
    1919#undef  FUNCTION
    2020#define FUNCTION "Issue_queue::Parameters"
    21   Parameters::Parameters (uint32_t          nb_context              ,
    22                           uint32_t          nb_front_end            ,
    23                           uint32_t          nb_rename_unit          ,
    24                           uint32_t          size_queue              ,
    25                           uint32_t          nb_bank                 ,
    26                           uint32_t          size_packet             ,
    27                           uint32_t          size_general_data       ,
    28                           uint32_t          size_special_data       ,
    29                           uint32_t          size_general_register   ,
    30                           uint32_t          size_special_register   ,
    31                           uint32_t          size_store_queue_ptr    ,
    32                           uint32_t          size_load_queue_ptr     ,
    33                           uint32_t          nb_inst_issue           ,
    34                           uint32_t        * nb_inst_rename          ,
    35                           uint32_t          nb_inst_reexecute       ,
    36                           uint32_t          nb_rename_unit_select   ,
    37                           Tpriority_t       priority                ,
    38                           Tload_balancing_t load_balancing          ,
    39                           bool           ** table_routing           ,
    40                           bool           ** table_issue_type        ,
    41                           bool              is_toplevel             )
     21  Parameters::Parameters (uint32_t              nb_context              ,
     22                          uint32_t              nb_front_end            ,
     23                          uint32_t              nb_rename_unit          ,
     24                          uint32_t              size_queue              ,
     25                          Tissue_queue_scheme_t queue_scheme            ,
     26                          uint32_t              nb_bank                 ,
     27                          uint32_t              size_packet             ,
     28                          uint32_t              size_general_data       ,
     29                          uint32_t              size_special_data       ,
     30                          uint32_t              size_general_register   ,
     31                          uint32_t              size_special_register   ,
     32                          uint32_t              size_store_queue_ptr    ,
     33                          uint32_t              size_load_queue_ptr     ,
     34                          uint32_t              nb_inst_issue           ,
     35                          uint32_t            * nb_inst_rename          ,
     36                          uint32_t              nb_inst_reexecute       ,
     37                          uint32_t              nb_rename_unit_select   ,
     38                          Tpriority_t           priority                ,
     39                          Tload_balancing_t     load_balancing          ,
     40                          bool               ** table_routing           ,
     41                          bool               ** table_issue_type        ,
     42                          bool                  is_toplevel             )
    4243  {
    4344    log_begin(Issue_queue,FUNCTION);
    … …  
    4748    _nb_rename_unit           = nb_rename_unit       ;
    4849    _size_queue               = size_queue           ;
     50    _queue_scheme             = queue_scheme         ;
    4951    _nb_bank                  = nb_bank              ;   
    5052    _nb_inst_issue            = nb_inst_issue        ;

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

    r109 r111  
    2525
    2626    Parameters_test test ("Issue_queue");
     27
     28    switch (_queue_scheme)
     29      {
     30      case ISSUE_QUEUE_SCHEME_IN_ORDER        :
     31      case ISSUE_QUEUE_SCHEME_OUT_OF_ORDER    :
     32        {
     33          // supported
     34          break;
     35        }
     36      default :
     37        {
     38          test.error(toString(_("Issue queue scheme '%s' is not supported. Please wait a next revision.\n"),toString(_queue_scheme).c_str()));
     39          break;
     40        }
     41      }
     42
     43    if (// (_queue_scheme == ISSUE_QUEUE_SCHEME_IN_BUNDLE_ORDER) or
     44        (_queue_scheme == ISSUE_QUEUE_SCHEME_OUT_OF_ORDER   ))
     45      test.warning(toString(_("Can have deadlock with the queue scheme \"%s\".\n"),toString(_queue_scheme).c_str()));
    2746
    2847    if (not is_multiple(_size_queue, _nb_bank))
Note: See TracChangeset for help on using the changeset viewer.