Ignore:
Timestamp:
May 21, 2009, 12:01:32 AM (15 years ago)
Author:
rosiere
Message:

1) Stat List : scan all queue to find free register
2) Write_queue : test "genMealy" add bypass [0]
3) Functionnal_unit : add const parameters to add or not the pipeline_in
4) Load Store Unit : if load make an exception, free nb_check
5) Debug, change test to add model

Location:
trunk/IPs/systemC/processor/Morpheo/Behavioural/Core
Files:
1 added
33 edited
1 moved

Legend:

Unmodified
Added
Removed
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Core_Glue/include/Core_Glue.h

    r117 r118  
    209209
    210210    // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
     211  private   : uint32_t                        reg_PRIORITY ;
    211212
    212213    // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Core_Glue/src/Core_Glue_genMealy_issue.cpp

    r117 r118  
    142142                  for (uint32_t num_execute_loop=0; num_execute_loop<_param->_nb_execute_loop; ++num_execute_loop)
    143143                    {
    144                       for (uint32_t num_read_unit=0; num_read_unit<_param->_nb_read_unit[num_execute_loop]; ++num_read_unit)
     144                      for (uint32_t _num_read_unit=0; _num_read_unit<_param->_nb_read_unit[num_execute_loop]; ++_num_read_unit)
    145145                        {
     146                          uint32_t num_read_unit = (_num_read_unit+reg_PRIORITY)%_param->_nb_read_unit[num_execute_loop];
    146147                          Tcontrol_t ack = READ_UNIT_ENABLE [num_execute_loop][num_read_unit];
    147148                         
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Core_Glue/src/Core_Glue_transition.cpp

    r117 r118  
    2929          }
    3030        _priority_ooo_engine->reset();
    31  
     31
     32        reg_PRIORITY = 0;
    3233      }
    3334    else
     
    4041          }
    4142        _priority_ooo_engine->transition();
     43
     44        reg_PRIORITY ++;
    4245      }
    4346
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/include/Functionnal_unit.h

    r116 r118  
    4040namespace execute_unit {
    4141namespace functionnal_unit {
    42 
    4342
    4443  class Functionnal_unit
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/include/Parameters.h

    r116 r118  
    4040//public : uint32_t            _size_load_queue              ;
    4141  public : const Tfunctionnal_unit_scheme_t _functionnal_unit_scheme;
     42  public : const bool                       _have_pipeline_in       ;
    4243
    4344  public : execute_timing_t ** _timing                       ;
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/src/Functionnal_unit_allocation.cpp

    r112 r118  
    104104     if (usage_is_set(_usage,USE_SYSTEMC))
    105105       {
     106     if (_param->_have_pipeline_in)
    106107     _execute_operation_in  = new execute_operation_t;
    107108     _execute_operation_out = new execute_operation_t;
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/src/Functionnal_unit_deallocation.cpp

    r115 r118  
    7777        DELETE3(_execute_register,_param->_nb_context,_param->_nb_front_end,_param->_nb_ooo_engine);
    7878        DELETE0(_execute_param);
     79        if (_param->_have_pipeline_in)
    7980        DELETE0(_execute_operation_in);
    8081        DELETE0(_execute_operation_out);
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/src/Functionnal_unit_genMealy.cpp

    r117 r118  
    2929      {
    3030        {
     31          // Can out if : have an instruction and is finish (latence == 0)
    3132          internal_EXECUTE_OUT_VAL = (reg_BUSY_OUT and (_execute_operation_out->_timing._latence == 0));
    3233         
    33           PORT_WRITE(out_EXECUTE_OUT_VAL          , internal_EXECUTE_OUT_VAL);
     34          PORT_WRITE(out_EXECUTE_OUT_VAL, internal_EXECUTE_OUT_VAL);
    3435        }
    3536       
    3637        {
     38          // Can accept an instruction if :
     39          //  * pipeline in is not busy (not previous instruction)
     40          //  * pipeline in is     busy (    previous instruction) and the instruction go to pipeline out
     41          if (_param->_have_pipeline_in)
     42            {         
    3743          internal_EXECUTE_IN_ACK = (not reg_BUSY_IN or
    3844                                     (reg_BUSY_IN and (not reg_BUSY_OUT or
    3945                                                       (internal_EXECUTE_OUT_VAL and PORT_READ(in_EXECUTE_OUT_ACK)))));
    40          
    41           PORT_WRITE(out_EXECUTE_IN_ACK           , internal_EXECUTE_IN_ACK);
     46            }
     47          else
     48            {
     49          internal_EXECUTE_IN_ACK = (not reg_BUSY_OUT or
     50                                     (internal_EXECUTE_OUT_VAL and PORT_READ(in_EXECUTE_OUT_ACK)));
     51            }
     52
     53          PORT_WRITE(out_EXECUTE_IN_ACK , internal_EXECUTE_IN_ACK);
    4254        }
    4355      }
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/src/Functionnal_unit_transition.cpp

    r117 r118  
    2828    if (PORT_READ(in_NRESET) == 0)
    2929      {
     30        if (_param->_have_pipeline_in)
    3031        reg_BUSY_IN  = false;
    3132        reg_BUSY_OUT = false;
     
    5051    else
    5152      {
    52         // Test if pop
     53        // Test if pop an instruction
    5354        if (internal_EXECUTE_OUT_VAL and PORT_READ(in_EXECUTE_OUT_ACK))
    5455          {
    5556            log_printf(TRACE,Functionnal_unit,FUNCTION,"  * EXECUTE_OUT : Transaction Accepted");
    56             // transaction
    5757            reg_BUSY_OUT = false;
    5858          }
    5959       
    60 
     60        // Test if can move instruction in pipeline in to pipeline out
     61        if (_param->_have_pipeline_in)
    6162        if (reg_BUSY_IN and not reg_BUSY_OUT)
    6263          {
     
    8788          }
    8889
    89 
    90 
    9190        // Test if push
    9291        execute_register_t * execute_register = NULL;
     
    9695            log_printf(TRACE,Functionnal_unit,FUNCTION,"  * EXECUTE_IN : Transaction Accepted");
    9796
    98             reg_BUSY_IN = true;
     97            execute_operation_t * execute_operation;
     98
     99            if (_param->_have_pipeline_in)
     100              {
     101            reg_BUSY_IN       = true;
     102            execute_operation = _execute_operation_in;
     103              }
     104            else
     105              {
     106            reg_BUSY_OUT      = true;
     107            execute_operation = _execute_operation_out;
     108              }
    99109
    100110            Tcontext_t   context_id    = (_param->_have_port_context_id   )?PORT_READ(in_EXECUTE_IN_CONTEXT_ID   ):0;
     
    104114            Toperation_t operation     = PORT_READ(in_EXECUTE_IN_OPERATION);
    105115            Ttype_t      type          = PORT_READ(in_EXECUTE_IN_TYPE);
    106            
    107             _execute_operation_in->_context_id    = context_id   ;
    108             _execute_operation_in->_front_end_id  = front_end_id ;
    109             _execute_operation_in->_ooo_engine_id = ooo_engine_id;
    110             _execute_operation_in->_packet_id     = packet_id    ;
    111             _execute_operation_in->_operation     = operation    ;
    112             _execute_operation_in->_type          = type         ;
    113             _execute_operation_in->_has_immediat  = PORT_READ(in_EXECUTE_IN_HAS_IMMEDIAT);
    114             _execute_operation_in->_immediat      = PORT_READ(in_EXECUTE_IN_IMMEDIAT    );
    115             _execute_operation_in->_data_ra       = PORT_READ(in_EXECUTE_IN_DATA_RA     );
    116             _execute_operation_in->_data_rb       = PORT_READ(in_EXECUTE_IN_DATA_RB     );
    117             _execute_operation_in->_data_rc       = PORT_READ(in_EXECUTE_IN_DATA_RC     );
    118             _execute_operation_in->_write_rd      = PORT_READ(in_EXECUTE_IN_WRITE_RD    );
    119             _execute_operation_in->_num_reg_rd    = PORT_READ(in_EXECUTE_IN_NUM_REG_RD  );
    120             _execute_operation_in->_data_rd       = 0; // no necessaray
    121             _execute_operation_in->_write_re      = PORT_READ(in_EXECUTE_IN_WRITE_RE    );
    122             _execute_operation_in->_num_reg_re    = PORT_READ(in_EXECUTE_IN_NUM_REG_RE  );
    123             _execute_operation_in->_data_re       = 0; // no necessaray
    124 
    125             log_printf(TRACE,Functionnal_unit,FUNCTION,"    * context_id    : %d",_execute_operation_in->_context_id   );
    126             log_printf(TRACE,Functionnal_unit,FUNCTION,"    * front_end_id  : %d",_execute_operation_in->_front_end_id );
    127             log_printf(TRACE,Functionnal_unit,FUNCTION,"    * ooo_engine_id : %d",_execute_operation_in->_ooo_engine_id);
    128             log_printf(TRACE,Functionnal_unit,FUNCTION,"    * packet_id     : %d",_execute_operation_in->_packet_id    );
    129             log_printf(TRACE,Functionnal_unit,FUNCTION,"    * operation     : %d",_execute_operation_in->_operation    );
    130             log_printf(TRACE,Functionnal_unit,FUNCTION,"    * type          : %s",toString(_execute_operation_in->_type).c_str());
    131             log_printf(TRACE,Functionnal_unit,FUNCTION,"    * has_immediat  : %d",_execute_operation_in->_has_immediat );
    132             log_printf(TRACE,Functionnal_unit,FUNCTION,"    * immediat      : %.8x",_execute_operation_in->_immediat     );
    133             log_printf(TRACE,Functionnal_unit,FUNCTION,"    * data_ra       : %.8x",_execute_operation_in->_data_ra      );
    134             log_printf(TRACE,Functionnal_unit,FUNCTION,"    * data_rb       : %.8x",_execute_operation_in->_data_rb      );
    135             log_printf(TRACE,Functionnal_unit,FUNCTION,"    * data_rc       : %.8x",_execute_operation_in->_data_rc      );
    136             log_printf(TRACE,Functionnal_unit,FUNCTION,"    * write_rd      : %d"  ,_execute_operation_in->_write_rd     );
    137             log_printf(TRACE,Functionnal_unit,FUNCTION,"    * num_reg_rd    : %d"  ,_execute_operation_in->_num_reg_rd   );
    138             log_printf(TRACE,Functionnal_unit,FUNCTION,"    * write_re      : %d"  ,_execute_operation_in->_write_re     );
    139             log_printf(TRACE,Functionnal_unit,FUNCTION,"    * num_reg_re    : %d"  ,_execute_operation_in->_num_reg_re   );
     116
     117            execute_operation->_context_id    = context_id   ;
     118            execute_operation->_front_end_id  = front_end_id ;
     119            execute_operation->_ooo_engine_id = ooo_engine_id;
     120            execute_operation->_packet_id     = packet_id    ;
     121            execute_operation->_operation     = operation    ;
     122            execute_operation->_type          = type         ;
     123            execute_operation->_has_immediat  = PORT_READ(in_EXECUTE_IN_HAS_IMMEDIAT);
     124            execute_operation->_immediat      = PORT_READ(in_EXECUTE_IN_IMMEDIAT    );
     125            execute_operation->_data_ra       = PORT_READ(in_EXECUTE_IN_DATA_RA     );
     126            execute_operation->_data_rb       = PORT_READ(in_EXECUTE_IN_DATA_RB     );
     127            execute_operation->_data_rc       = PORT_READ(in_EXECUTE_IN_DATA_RC     );
     128            execute_operation->_write_rd      = PORT_READ(in_EXECUTE_IN_WRITE_RD    );
     129            execute_operation->_num_reg_rd    = PORT_READ(in_EXECUTE_IN_NUM_REG_RD  );
     130            execute_operation->_data_rd       = 0; // no necessaray
     131            execute_operation->_write_re      = PORT_READ(in_EXECUTE_IN_WRITE_RE    );
     132            execute_operation->_num_reg_re    = PORT_READ(in_EXECUTE_IN_NUM_REG_RE  );
     133            execute_operation->_data_re       = 0; // no necessaray
     134
     135            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * context_id    : %d",execute_operation->_context_id   );
     136            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * front_end_id  : %d",execute_operation->_front_end_id );
     137            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * ooo_engine_id : %d",execute_operation->_ooo_engine_id);
     138            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * packet_id     : %d",execute_operation->_packet_id    );
     139            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * operation     : %d",execute_operation->_operation    );
     140            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * type          : %s",toString(execute_operation->_type).c_str());
     141            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * has_immediat  : %d",execute_operation->_has_immediat );
     142            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * immediat      : %.8x",execute_operation->_immediat     );
     143            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * data_ra       : %.8x",execute_operation->_data_ra      );
     144            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * data_rb       : %.8x",execute_operation->_data_rb      );
     145            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * data_rc       : %.8x",execute_operation->_data_rc      );
     146            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * write_rd      : %d"  ,execute_operation->_write_rd     );
     147            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * num_reg_rd    : %d"  ,execute_operation->_num_reg_rd   );
     148            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * write_re      : %d"  ,execute_operation->_write_re     );
     149            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * num_reg_re    : %d"  ,execute_operation->_num_reg_re   );
    140150           
    141151#ifdef DEBUG_TEST
     
    156166//                                                   ooo_engine_id,_param->_size_ooo_engine_id);
    157167
    158                 (*(_param->_get_custom_information()._get_custom_execute_genMoore(operation))) (_execute_operation_in, execute_register, _execute_param);
     168                (*(_param->_get_custom_information()._get_custom_execute_genMoore(operation))) (execute_operation, execute_register, _execute_param);
    159169              }
    160170            else
    161               (*(_function_execute[type][operation])) (_execute_operation_in, execute_register, _execute_param);
     171              (*(_function_execute[type][operation])) (execute_operation, execute_register, _execute_param);
    162172
    163173
    164174            log_printf(TRACE,Functionnal_unit,FUNCTION,"    -----------------");
    165             log_printf(TRACE,Functionnal_unit,FUNCTION,"    * latence       : %.8x",_execute_operation_in->_timing._latence);
    166             log_printf(TRACE,Functionnal_unit,FUNCTION,"    * delay         : %.8x",_execute_operation_in->_timing._delay);
    167             log_printf(TRACE,Functionnal_unit,FUNCTION,"    * data_rd       : %.8x",_execute_operation_in->_data_rd    );
    168             log_printf(TRACE,Functionnal_unit,FUNCTION,"    * data_re       : %.8x",_execute_operation_in->_data_re    );
    169             log_printf(TRACE,Functionnal_unit,FUNCTION,"    * exception     : %d"  ,_execute_operation_in->_exception  );
    170             log_printf(TRACE,Functionnal_unit,FUNCTION,"    * no_sequence   : %d"  ,_execute_operation_in->_no_sequence);
    171             log_printf(TRACE,Functionnal_unit,FUNCTION,"    * address       : %.8x (%.8x)",_execute_operation_in->_address,_execute_operation_in->_address<<2);
     175            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * latence       : %.8x",execute_operation->_timing._latence);
     176            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * delay         : %.8x",execute_operation->_timing._delay);
     177            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * data_rd       : %.8x",execute_operation->_data_rd    );
     178            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * data_re       : %.8x",execute_operation->_data_re    );
     179            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * exception     : %d"  ,execute_operation->_exception  );
     180            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * no_sequence   : %d"  ,execute_operation->_no_sequence);
     181            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * address       : %.8x (%.8x)",execute_operation->_address,execute_operation->_address<<2);
    172182
    173183#ifdef STATISTICS
     
    175185              {
    176186                (*_stat_use_functionnal_unit) ++;
    177                 (*_stat_sum_delay)   += _execute_operation_in->_timing._delay;
    178                 (*_stat_sum_latence) += _execute_operation_in->_timing._latence;
     187                (*_stat_sum_delay)   += execute_operation->_timing._delay;
     188                (*_stat_sum_latence) += execute_operation->_timing._latence;
    179189              }
    180190#endif
     
    213223        if (reg_BUSY_OUT and (_execute_operation_out->_timing._latence > 0))
    214224          _execute_operation_out->_timing._latence --;
     225
     226#if defined(DEBUG) and DEBUG_Functionnal_unit and (DEBUG >= DEBUG_TRACE)
     227        {
     228          log_printf(TRACE,Functionnal_unit,FUNCTION,"  * Dump ALU (Functionnal_unit)");
     229
     230          if (_param->_have_pipeline_in)
     231          log_printf(TRACE,Functionnal_unit,FUNCTION,"    * reg_BUSY_IN  : %d",reg_BUSY_IN );
     232          log_printf(TRACE,Functionnal_unit,FUNCTION,"    * reg_BUSY_OUT : %d",reg_BUSY_OUT);
     233        }
     234#endif
    215235      }
    216236   
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/src/Parameters.cpp

    r116 r118  
    3333                          morpheo::behavioural::custom::custom_information_t (*get_custom_information) (void),
    3434                          bool               is_toplevel):
    35     _functionnal_unit_scheme (FUNCTIONNAL_UNIT_SCHEME_GLOBAL_REGISTERFILE)
     35    _functionnal_unit_scheme (FUNCTIONNAL_UNIT_SCHEME_GLOBAL_REGISTERFILE),
     36    _have_pipeline_in        (false)
    3637  {
    3738    log_printf(FUNC,Functionnal_unit,FUNCTION,"Begin");
  • 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_commit_transition.cpp

    r117 r118  
    350350                // find a entry that it need a check
    351351                Tlsq_ptr_t index_store     = _load_queue[index_load]._store_queue_ptr_write;
    352                 Tlsq_ptr_t index_store_old = index_store;
     352//              Tlsq_ptr_t index_store_old = index_store;
    353353
    354354                // Init variable
     
    10911091                    _load_queue [packet_id]._exception = EXCEPTION_MEMORY_BUS_ERROR;
    10921092                    _load_queue [packet_id]._state     = LOAD_QUEUE_COMMIT;
     1093
     1094                   
     1095                    uint32_t i=_load_queue[packet_id]._store_queue_ptr_write;
     1096                    while (i!=reg_STORE_QUEUE_PTR_READ)
     1097                      {
     1098                        i=((i==0)?_param->_size_store_queue:i)-1;
     1099                       
     1100#ifdef DEBUG
     1101                        if (reg_STORE_QUEUE_NB_CHECK [i] == 0)
     1102                          throw ERRORMORPHEO(FUNCTION,_("reg_STORE_QUEUE_NB_CHECK must be > 0\n"));
     1103#endif
     1104                       
     1105                        reg_STORE_QUEUE_NB_CHECK [i] --;
     1106                        //i=(i+1)%_param->_size_store_queue;
     1107                      }
    10931108                  }
    10941109                else
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/src/Reservation_station_transition.cpp

    r98 r118  
    6060      log_printf(TRACE,Reservation_station,FUNCTION,"    * nb_elt : %d",_queue_control->nb_elt()); \
    6161      for (uint32_t it_dump=0;it_dump<_param->_size_queue; it_dump++)   \
    62         log_printf(TRACE,Reservation_station,FUNCTION,"    * [%.4d] %.2d %.2d %.2d %.4d, %.2d %.3d, %.2d %.2d, %.1d %.8x, %.4d %.1d %.8x, %.4d %.1d %.8x, %.4d %.1d %.2x, %.1d %.4d, %.1d %.4d (%s)", \
    63                    (*_queue_control)[it_dump],                          \
    64                    _queue[(*_queue_control)[it_dump]]._context_id           , \
    65                    _queue[(*_queue_control)[it_dump]]._front_end_id         , \
    66                    _queue[(*_queue_control)[it_dump]]._ooo_engine_id        , \
    67                    _queue[(*_queue_control)[it_dump]]._rob_id               , \
    68                    _queue[(*_queue_control)[it_dump]]._type                 , \
    69                    _queue[(*_queue_control)[it_dump]]._operation            , \
    70                    _queue[(*_queue_control)[it_dump]]._store_queue_ptr_write, \
    71                    _queue[(*_queue_control)[it_dump]]._load_queue_ptr_write , \
    72                    _queue[(*_queue_control)[it_dump]]._has_immediat         , \
    73                    _queue[(*_queue_control)[it_dump]]._immediat             , \
    74                    _queue[(*_queue_control)[it_dump]]._num_reg_ra           , \
    75                    _queue[(*_queue_control)[it_dump]]._data_ra_val          , \
    76                    _queue[(*_queue_control)[it_dump]]._data_ra              , \
    77                    _queue[(*_queue_control)[it_dump]]._num_reg_rb           , \
    78                    _queue[(*_queue_control)[it_dump]]._data_rb_val          , \
    79                    _queue[(*_queue_control)[it_dump]]._data_rb              , \
    80                    _queue[(*_queue_control)[it_dump]]._num_reg_rc           , \
    81                    _queue[(*_queue_control)[it_dump]]._data_rc_val          , \
    82                    _queue[(*_queue_control)[it_dump]]._data_rc              , \
    83                    _queue[(*_queue_control)[it_dump]]._write_rd             , \
    84                    _queue[(*_queue_control)[it_dump]]._num_reg_rd           , \
    85                    _queue[(*_queue_control)[it_dump]]._write_re             , \
    86                    _queue[(*_queue_control)[it_dump]]._num_reg_re           , \
    87                    toString(_queue[(*_queue_control)[it_dump]]._type).c_str());       \
     62        if (it_dump < _queue_control->nb_elt())                         \
     63          log_printf(TRACE,Reservation_station,FUNCTION,"    * [%.4d] %.2d %.2d %.2d %.4d, %.2d %.3d, %.2d %.2d, %.1d %.8x, %.4d %.1d %.8x, %.4d %.1d %.8x, %.4d %.1d %.2x, %.1d %.4d, %.1d %.4d (%s)", \
     64                     (*_queue_control)[it_dump],                        \
     65                     _queue[(*_queue_control)[it_dump]]._context_id           , \
     66                     _queue[(*_queue_control)[it_dump]]._front_end_id         , \
     67                     _queue[(*_queue_control)[it_dump]]._ooo_engine_id        , \
     68                     _queue[(*_queue_control)[it_dump]]._rob_id               , \
     69                     _queue[(*_queue_control)[it_dump]]._type                 , \
     70                     _queue[(*_queue_control)[it_dump]]._operation            , \
     71                     _queue[(*_queue_control)[it_dump]]._store_queue_ptr_write, \
     72                     _queue[(*_queue_control)[it_dump]]._load_queue_ptr_write , \
     73                     _queue[(*_queue_control)[it_dump]]._has_immediat         , \
     74                     _queue[(*_queue_control)[it_dump]]._immediat             , \
     75                     _queue[(*_queue_control)[it_dump]]._num_reg_ra           , \
     76                     _queue[(*_queue_control)[it_dump]]._data_ra_val          , \
     77                     _queue[(*_queue_control)[it_dump]]._data_ra              , \
     78                     _queue[(*_queue_control)[it_dump]]._num_reg_rb           , \
     79                     _queue[(*_queue_control)[it_dump]]._data_rb_val          , \
     80                     _queue[(*_queue_control)[it_dump]]._data_rb              , \
     81                     _queue[(*_queue_control)[it_dump]]._num_reg_rc           , \
     82                     _queue[(*_queue_control)[it_dump]]._data_rc_val          , \
     83                     _queue[(*_queue_control)[it_dump]]._data_rc              , \
     84                     _queue[(*_queue_control)[it_dump]]._write_rd             , \
     85                     _queue[(*_queue_control)[it_dump]]._num_reg_rd           , \
     86                     _queue[(*_queue_control)[it_dump]]._write_re             , \
     87                     _queue[(*_queue_control)[it_dump]]._num_reg_re           , \
     88                     toString(_queue[(*_queue_control)[it_dump]]._type).c_str()); \
     89        else                                                            \
     90          log_printf(TRACE,Reservation_station,FUNCTION,"    * [%.4d]", \
     91                     (*_queue_control)[it_dump]);                       \
    8892    } while (0)
    8993#endif
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/include/Parameters.h

    r115 r118  
    2424
    2525
     26
    2627  class Parameters : public morpheo::behavioural::Parameters
    2728  {
    2829    //-----[ fields ]------------------------------------------------------------
    29   public : uint32_t              _size_queue                   ;
    30   public : uint32_t              _nb_context                   ;
    31   public : uint32_t              _nb_front_end                 ;
    32   public : uint32_t              _nb_ooo_engine                ;
    33   public : uint32_t              _nb_packet                    ;
    34 //public : uint32_t              _size_general_data            ;
    35   public : uint32_t              _nb_general_register          ;
    36 //public : uint32_t              _size_special_data            ;
    37   public : uint32_t              _nb_special_register          ;
    38   public : uint32_t              _nb_bypass_write              ;
    39   public : Twrite_queue_scheme_t _queue_scheme                 ;
    40 
    41   public : uint32_t              _nb_gpr_write                 ;
    42   public : uint32_t              _nb_spr_write                 ;
    43                                
    44 //public : uint32_t              _size_context_id              ;
    45 //public : uint32_t              _size_front_end_id            ;
    46 //public : uint32_t              _size_ooo_engine_id           ;
    47 //public : uint32_t              _size_packet_id               ;
    48 //public : uint32_t              _size_general_register        ;
    49 //public : uint32_t              _size_special_register        ;
    50   public : uint32_t              _size_internal_queue          ;
    51                                
    52 //public : bool                  _have_port_context_id         ;
    53 //public : bool                  _have_port_front_end_id      ;
    54 //public : bool                  _have_port_ooo_engine_id      ;
    55 //public : bool                  _have_port_packet_id          ;
     30  public : uint32_t               _size_queue             ;
     31  public : uint32_t               _nb_context             ;
     32  public : uint32_t               _nb_front_end           ;
     33  public : uint32_t               _nb_ooo_engine          ;
     34  public : uint32_t               _nb_packet              ;
     35//public : uint32_t               _size_general_data      ;
     36  public : uint32_t               _nb_general_register    ;
     37//public : uint32_t               _size_special_data      ;
     38  public : uint32_t               _nb_special_register    ;
     39  public : uint32_t               _nb_bypass_write        ;
     40  public : Twrite_queue_scheme_t  _queue_scheme           ;
     41  public : Tbypass_write_scheme_t _bypass_write_scheme    ;
     42  public : uint32_t               _nb_gpr_write           ;
     43  public : uint32_t               _nb_spr_write           ;
     44                                  
     45//public : uint32_t               _size_context_id        ;
     46//public : uint32_t               _size_front_end_id      ;
     47//public : uint32_t               _size_ooo_engine_id     ;
     48//public : uint32_t               _size_packet_id         ;
     49//public : uint32_t               _size_general_register  ;
     50//public : uint32_t               _size_special_register  ;
     51  public : uint32_t               _size_internal_queue    ;
     52                                  
     53//public : bool                   _have_port_context_id   ;
     54//public : bool                   _have_port_front_end_id ;
     55//public : bool                   _have_port_ooo_engine_id;
     56//public : bool                   _have_port_packet_id    ;
    5657
    5758    //-----[ methods ]-----------------------------------------------------------
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/include/Types.h

    r115 r118  
    2525      ,WRITE_QUEUE_SCHEME_MEALY // Write register and pop can be in same cycle
    2626    } Twrite_queue_scheme_t;
     27
     28  typedef enum
     29    {
     30      BYPASS_WRITE_FROM_ALU,
     31      BYPASS_WRITE_FROM_QUEUE
     32    } Tbypass_write_scheme_t;
    2733
    2834  class write_queue_entry_t
     
    108114  };
    109115
     116  template<> inline std::string toString<morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::write_queue::Tbypass_write_scheme_t>(const morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::write_queue::Tbypass_write_scheme_t& x)
     117  {
     118    switch (x)
     119      {
     120      case morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::write_queue::BYPASS_WRITE_FROM_ALU   : return "alu"  ; break;
     121      case morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::write_queue::BYPASS_WRITE_FROM_QUEUE : return "queue"; break;
     122      default : return ""; break;
     123      }
     124  };
     125
     126  template<> inline morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::write_queue::Tbypass_write_scheme_t fromString<morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::write_queue::Tbypass_write_scheme_t>(const std::string& x)
     127  {
     128    if ( (x.compare(toString(static_cast<uint32_t>(morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::write_queue::BYPASS_WRITE_FROM_ALU))) == 0) or
     129         (x.compare("alu") == 0))
     130      return morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::write_queue::BYPASS_WRITE_FROM_ALU;
     131    if ( (x.compare(toString(static_cast<uint32_t>(morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::write_queue::BYPASS_WRITE_FROM_QUEUE))) == 0) or
     132         (x.compare("queue") == 0))
     133      return morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::write_queue::BYPASS_WRITE_FROM_QUEUE;
     134   
     135    throw (ErrorMorpheo ("<fromString> : Unknow string : \""+x+"\""));
     136  };
     137
    110138}; // end namespace morpheo             
    111139
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/include/Write_queue.h

    r115 r118  
    172172  public  : void     transition                (void);
    173173  public  : void     genMoore                  (void);
    174   public  : void     genMealy                  (void);
     174  public  : void     genMealy_write            (void);
     175  public  : void     genMealy_bypass           (void);
    175176#endif                                         
    176177#ifdef STATISTICS
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/src/Parameters.cpp

    r115 r118  
    4545    _nb_bypass_write         = nb_bypass_write    ;
    4646    _queue_scheme            = queue_scheme       ;
     47    _bypass_write_scheme     = BYPASS_WRITE_FROM_ALU;
     48//  _bypass_write_scheme     = BYPASS_WRITE_FROM_QUEUE;
    4749
    4850    _nb_gpr_write            = 1;
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/src/Parameters_msg_error.cpp

    r113 r118  
    2828    Parameters_test test (_type);
    2929
    30     if (_nb_bypass_write > _size_queue)
     30    if ((_bypass_write_scheme == BYPASS_WRITE_FROM_ALU)   and (_nb_bypass_write > _size_queue))
    3131      test.error("The write_queue can't have more bypass_write than entry in the queue.\n");
     32    if ((_bypass_write_scheme == BYPASS_WRITE_FROM_QUEUE) and (_nb_bypass_write > _size_queue-1))
     33      test.error("The write_queue can't have more bypass_write than entry in the queue -1 (the write_queue[0] is unnecessary).\n");
    3234
    3335    log_printf(FUNC,Write_queue,FUNCTION,"End");
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/src/Write_queue.cpp

    r115 r118  
    9292        if (_param->_queue_scheme == WRITE_QUEUE_SCHEME_MEALY)
    9393          {
    94         log_printf(INFO,Write_queue,FUNCTION,"Method - genMealy");
     94        log_printf(INFO,Write_queue,FUNCTION,"Method - genMealy_write");
    9595
    96         SC_METHOD (genMealy);
     96        SC_METHOD (genMealy_write);
    9797        dont_initialize ();
    9898        sensitive << (*(in_CLOCK)).neg(); // need internal register
     
    106106# endif   
    107107          }
     108
     109        if ((_param->_bypass_write_scheme == BYPASS_WRITE_FROM_ALU) and
     110            (_param->_nb_bypass_write > 0))
     111          {
     112        log_printf(INFO,Write_queue,FUNCTION,"Method - genMealy_bypass");
     113
     114        SC_METHOD (genMealy_bypass);
     115        dont_initialize ();
     116//      sensitive << (*(in_CLOCK)).neg(); // don't need internal register
     117        sensitive << (*(in_WRITE_QUEUE_IN_VAL          ))
     118                  << (*(in_WRITE_QUEUE_IN_WRITE_RD     ))
     119                  << (*(in_WRITE_QUEUE_IN_NUM_REG_RD   ))
     120                  << (*(in_WRITE_QUEUE_IN_DATA_RD      ))
     121                  << (*(in_WRITE_QUEUE_IN_WRITE_RE     ))
     122                  << (*(in_WRITE_QUEUE_IN_NUM_REG_RE   ))
     123                  << (*(in_WRITE_QUEUE_IN_DATA_RE      ));
     124        if (_param->_have_port_ooo_engine_id)
     125        sensitive << (*(in_WRITE_QUEUE_IN_OOO_ENGINE_ID));
     126
     127
     128# ifdef SYSTEMCASS_SPECIFIC
     129        // List dependency information
     130# endif   
     131          }
    108132
    109133#endif
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/src/Write_queue_genMealy_write.cpp

    r116 r118  
    2020
    2121#undef  FUNCTION
    22 #define FUNCTION "Write_queue::genMealy"
    23   void Write_queue::genMealy (void)
     22#define FUNCTION "Write_queue::genMealy_write"
     23  void Write_queue::genMealy_write (void)
    2424  {
    2525    log_begin(Write_queue,FUNCTION);
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/src/Write_queue_genMoore.cpp

    r117 r118  
    2929    {
    3030      std::list<write_queue_entry_t *>::iterator it = _queue->begin();
    31       for (uint32_t i=0; i<_param->_nb_bypass_write; i++)
     31
     32      // first bypass is the write_queue_in
     33      uint32_t first_index = ((_param->_bypass_write_scheme == BYPASS_WRITE_FROM_ALU)?1:0);
     34      for (uint32_t i=first_index; i<_param->_nb_bypass_write; i++)
    3235        {
    33           bool val     = i < _queue->size();
    34          
     36          // before because first slot is on {GPR|SPR}_WRITE. Also, take next
     37          if (it != _queue->end())
     38            it++;
     39
     40          uint32_t index = i;
     41//        bool val = (i+1) < _queue->size();
     42          bool val = (it != _queue->end());
     43
    3544          if (val)
    3645            {
    3746              if (_param->_have_port_ooo_engine_id)
    38               PORT_WRITE(out_BYPASS_WRITE_OOO_ENGINE_ID [i], (*it)->_ooo_engine_id);
    39               PORT_WRITE(out_BYPASS_WRITE_GPR_NUM_REG   [i], (*it)->_num_reg_rd);
    40               PORT_WRITE(out_BYPASS_WRITE_GPR_DATA      [i], (*it)->_data_rd   );
    41               PORT_WRITE(out_BYPASS_WRITE_SPR_NUM_REG   [i], (*it)->_num_reg_re);
    42               PORT_WRITE(out_BYPASS_WRITE_SPR_DATA      [i], (*it)->_data_re   );
     47              PORT_WRITE(out_BYPASS_WRITE_OOO_ENGINE_ID [index], (*it)->_ooo_engine_id);
     48              PORT_WRITE(out_BYPASS_WRITE_GPR_NUM_REG   [index], (*it)->_num_reg_rd);
     49              PORT_WRITE(out_BYPASS_WRITE_GPR_DATA      [index], (*it)->_data_rd   );
     50              PORT_WRITE(out_BYPASS_WRITE_SPR_NUM_REG   [index], (*it)->_num_reg_re);
     51              PORT_WRITE(out_BYPASS_WRITE_SPR_DATA      [index], (*it)->_data_re   );
    4352            }
    4453#ifdef SYSTEMC_VHDL_COMPATIBILITY
     
    4655            {
    4756              if (_param->_have_port_ooo_engine_id)
    48               PORT_WRITE(out_BYPASS_WRITE_OOO_ENGINE_ID [i], 0);
    49               PORT_WRITE(out_BYPASS_WRITE_GPR_NUM_REG   [i], 0);
    50               PORT_WRITE(out_BYPASS_WRITE_GPR_DATA      [i], 0);
    51               PORT_WRITE(out_BYPASS_WRITE_SPR_NUM_REG   [i], 0);
    52               PORT_WRITE(out_BYPASS_WRITE_SPR_DATA      [i], 0);
     57              PORT_WRITE(out_BYPASS_WRITE_OOO_ENGINE_ID [index], 0);
     58              PORT_WRITE(out_BYPASS_WRITE_GPR_NUM_REG   [index], 0);
     59              PORT_WRITE(out_BYPASS_WRITE_GPR_DATA      [index], 0);
     60              PORT_WRITE(out_BYPASS_WRITE_SPR_NUM_REG   [index], 0);
     61              PORT_WRITE(out_BYPASS_WRITE_SPR_DATA      [index], 0);
    5362            }
    5463#endif
    5564
    56           PORT_WRITE(out_BYPASS_WRITE_GPR_VAL       [i], val and (*it)->_write_rd  );
    57           PORT_WRITE(out_BYPASS_WRITE_SPR_VAL       [i], val and (*it)->_write_re  );
    58          
    59           if (it != _queue->end())
    60             it++;
     65          PORT_WRITE(out_BYPASS_WRITE_GPR_VAL       [index], val and (*it)->_write_rd  );
     66          PORT_WRITE(out_BYPASS_WRITE_SPR_VAL       [index], val and (*it)->_write_re  );
    6167        }
    6268    }
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod_queue/src/Decod_queue_allocation.cpp

    r112 r118  
    138138      ALLOC1_INTERFACE_BEGIN("nb_inst",OUT,NORTH,_("Instruction's number"), _param->_nb_context);
    139139
    140       ALLOC1_SIGNAL_OUT(out_NB_INST_ALL    ,"all"      ,Tcontext_t         ,_param->_size_nb_inst_decod);
     140      ALLOC1_SIGNAL_OUT(out_NB_INST_ALL    ,"all"      ,Tcounter_t         ,_param->_size_nb_inst_decod);
    141141
    142142      ALLOC1_INTERFACE_END(_param->_nb_context);
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/include/Decod_unit.h

    r110 r118  
    137137  public    : SC_IN (Tcontrol_t         )   *  in_CONTEXT_EVENT_ACK                  ;
    138138  public    : SC_OUT(Tcontext_t         )   * out_CONTEXT_EVENT_CONTEXT_ID           ;
    139   public    : SC_OUT(Tcontext_t         )   * out_CONTEXT_EVENT_DEPTH                ;
     139  public    : SC_OUT(Tdepth_t           )   * out_CONTEXT_EVENT_DEPTH                ;
    140140  public    : SC_OUT(Tevent_type_t      )   * out_CONTEXT_EVENT_TYPE                 ;
    141141  public    : SC_OUT(Tcontrol_t         )   * out_CONTEXT_EVENT_IS_DELAY_SLOT        ;
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/src/Decod_unit_allocation.cpp

    r112 r118  
    149149      ALLOC1_INTERFACE_BEGIN("nb_inst",OUT,NORTH,_("Instruction's number"), _param->_nb_context);
    150150
    151       ALLOC1_SIGNAL_OUT(out_NB_INST_DECOD_ALL  ,"decod_all"   ,Tcontext_t         ,_param->_size_nb_inst_decod);
     151      ALLOC1_SIGNAL_OUT(out_NB_INST_DECOD_ALL  ,"decod_all"   ,Tcounter_t         ,_param->_size_nb_inst_decod);
    152152
    153153      ALLOC1_INTERFACE_END(_param->_nb_context);
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Return_Address_Stack/src/Return_Address_Stack_genMealy_decod.cpp

    r100 r118  
    2525    log_function(Return_Address_Stack,FUNCTION,_name.c_str());
    2626
     27    if (PORT_READ(in_NRESET) == 1)
     28      {
    2729#ifdef DEBUG_TEST
    2830    // just to test if have many transaction on a same context
     
    6365        PORT_WRITE(out_DECOD_INDEX       [i], top);
    6466      }
    65 
     67      }
    6668    log_end(Return_Address_Stack,FUNCTION);
    6769  };
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Return_Address_Stack/src/Return_Address_Stack_genMealy_predict.cpp

    r100 r118  
    2525    log_function(Return_Address_Stack,FUNCTION,_name.c_str());
    2626
     27    if (PORT_READ(in_NRESET) == 1)
     28      {
    2729#ifdef DEBUG_TEST
    2830    // just to test if have many transaction on a same context
     
    6365
    6466        PORT_WRITE(out_PREDICT_ADDRESS_POP [i], reg_stack[context][top]._address);
     67
    6568        PORT_WRITE(out_PREDICT_INDEX       [i], top);
     69      }
    6670      }
    6771
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_allocation.cpp

    r117 r118  
    342342      if (_param->_have_thread [i])
    343343        {
    344           std::string filename = MORPHEO_LOG+"/"+toString(getpid())+"-Instruction_flow-thread_"+toString(i)+"-"+toString(getpid())+".log";
     344          std::string filename = MORPHEO_LOG+"/"+toString(getpid())+"-Instruction_flow-thread_"+toString(i)+".log";
    345345         
    346346          instruction_log_file [i] .open(filename.c_str() ,std::ios::out | std::ios::trunc);
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_genMoore.cpp

    r105 r118  
    2828    // ===================================================================
    2929    {
     30      log_printf(TRACE,Commit_unit,FUNCTION,"  * REEXECUTE [0]");
     31
    3032      // Store instruction comming Out Of Order in Load Store Unit.
    3133      // Must be executed in no speculative mode. Also, send a signal when an Store is in head of ROB
    3234
    33       Tcontrol_t val = false;
    34 
    35       if (not _rob[reg_NUM_BANK_HEAD].empty())
    36         {
    37           entry_t    * entry = _rob [reg_NUM_BANK_HEAD].front();
     35      Tcontrol_t val      = false;
     36      uint32_t   num_bank = reg_NUM_BANK_HEAD;
     37
     38      if (not _rob[num_bank].empty())
     39        {
     40          log_printf(TRACE,Commit_unit,FUNCTION,"    * ROB is not empty");
     41          log_printf(TRACE,Commit_unit,FUNCTION,"    * num_bank      : %d",num_bank);
     42
     43          entry_t    * entry = _rob [num_bank].front();
    3844          rob_state_t  state = entry->state;
    3945
     
    4147          val   = ((state == ROB_STORE_HEAD_OK) or
    4248                   (state == ROB_STORE_HEAD_KO));
    43          
     49
     50          log_printf(TRACE,Commit_unit,FUNCTION,"    * val           : %d",val);
    4451          if (val)
    4552            {
     53              Tpacket_t packet_id = ((entry->ptr << _param->_shift_num_slot) | num_bank);
     54
     55              log_printf(TRACE,Commit_unit,FUNCTION,"    * packet_id     : %d",packet_id);
     56         
    4657              // Reexecute store
    4758              if (_param->_have_port_context_id)
     
    5061              PORT_WRITE(out_REEXECUTE_FRONT_END_ID          [0], entry->front_end_id         );
    5162              if (_param->_have_port_rob_ptr  )
    52               PORT_WRITE(out_REEXECUTE_PACKET_ID             [0], entry->ptr                  );
     63              PORT_WRITE(out_REEXECUTE_PACKET_ID             [0], packet_id                   );
    5364              PORT_WRITE(out_REEXECUTE_TYPE                  [0], entry->type                 );
    5465              PORT_WRITE(out_REEXECUTE_STORE_QUEUE_PTR_WRITE [0], entry->store_queue_ptr_write);
     
    5869 
    5970      internal_REEXECUTE_VAL      [0] = val;
    60       internal_REEXECUTE_NUM_BANK [0] = reg_NUM_BANK_HEAD;
     71      internal_REEXECUTE_NUM_BANK [0] = num_bank;
    6172     
    6273      PORT_WRITE(out_REEXECUTE_VAL[0], internal_REEXECUTE_VAL [0]);
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Reexecute_unit/src/Reexecute_unit_genMealy_reexecute.cpp

    r98 r118  
    3434        Tcontrol_t ack;
    3535
     36        log_printf(TRACE,Reexecute_unit,FUNCTION,"  * REEXECUTE[%d]",i);
     37
    3638        if (not _reexecute_queue [i].empty() and (_reexecute_queue [i].front()->state == STATE_REEXECUTE))
    3739          {
     
    4042
    4143            entry_t * entry = _reexecute_queue [i].front();
     44            Tpacket_t packet_id = (_param->_have_port_rob_ptr)?entry->packet_id:0;
     45
     46            log_printf(TRACE,Reexecute_unit,FUNCTION,"    * From Reexecute_queue");
     47            log_printf(TRACE,Reexecute_unit,FUNCTION,"    * packet_id : %d",packet_id);
    4248
    4349            if (_param->_have_port_context_id)
     
    4652            PORT_WRITE(out_REEXECUTE_FRONT_END_ID          [i],entry->front_end_id  );
    4753            if (_param->_have_port_rob_ptr  )
    48             PORT_WRITE(out_REEXECUTE_PACKET_ID             [i],entry->packet_id     );
     54            PORT_WRITE(out_REEXECUTE_PACKET_ID             [i],       packet_id     );
    4955            PORT_WRITE(out_REEXECUTE_OPERATION             [i],entry->operation     );
    5056            PORT_WRITE(out_REEXECUTE_TYPE                  [i],entry->type          );
     
    6066            ack = PORT_READ(in_REEXECUTE_ACK     [i]);
    6167
     68            Tpacket_t packet_id = (_param->_have_port_rob_ptr)?PORT_READ(in_REEXECUTE_ROB_PACKET_ID [i]):0;
     69
     70            log_printf(TRACE,Reexecute_unit,FUNCTION,"    * From ROB");
     71            log_printf(TRACE,Reexecute_unit,FUNCTION,"    * val & ack : %d",val and ack);
     72            log_printf(TRACE,Reexecute_unit,FUNCTION,"    * have ??   : %d",_param->_have_port_rob_ptr);
     73            log_printf(TRACE,Reexecute_unit,FUNCTION,"    * packet_id : %d",packet_id);
     74
    6275            if (_param->_have_port_context_id)
    6376            PORT_WRITE(out_REEXECUTE_CONTEXT_ID            [i], PORT_READ(in_REEXECUTE_ROB_CONTEXT_ID              [i]));
     
    6578            PORT_WRITE(out_REEXECUTE_FRONT_END_ID          [i], PORT_READ(in_REEXECUTE_ROB_FRONT_END_ID            [i]));
    6679            if (_param->_have_port_rob_ptr  )
    67             PORT_WRITE(out_REEXECUTE_PACKET_ID             [i], PORT_READ(in_REEXECUTE_ROB_PACKET_ID               [i]));
     80            PORT_WRITE(out_REEXECUTE_PACKET_ID             [i],                            packet_id                   );
    6881            PORT_WRITE(out_REEXECUTE_OPERATION             [i], PORT_READ(in_REEXECUTE_ROB_OPERATION               [i]));
    6982            PORT_WRITE(out_REEXECUTE_TYPE                  [i], PORT_READ(in_REEXECUTE_ROB_TYPE                    [i]));
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Stat_List_unit/include/Stat_List_unit.h

    r117 r118  
    121121  private   : Tcontrol_t                    * internal_PUSH_GPR_VAL     ;//[nb_reg_free]
    122122  private   : uint32_t                      * internal_PUSH_GPR_NUM_BANK;//[nb_reg_free]
     123  private   : uint32_t                      * internal_PUSH_GPR_NUM_REG ;//[nb_reg_free]
    123124  private   : Tcontrol_t                    * internal_PUSH_SPR_VAL     ;//[nb_reg_free]
    124125  private   : uint32_t                      * internal_PUSH_SPR_NUM_BANK;//[nb_reg_free]
     126  private   : uint32_t                      * internal_PUSH_SPR_NUM_REG ;//[nb_reg_free]
    125127#endif
    126128
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Stat_List_unit/src/Stat_List_unit_allocation.cpp

    r117 r118  
    134134     ALLOC1(internal_PUSH_GPR_VAL     ,Tcontrol_t,_param->_nb_reg_free);
    135135     ALLOC1(internal_PUSH_GPR_NUM_BANK,uint32_t  ,_param->_nb_reg_free);
     136     ALLOC1(internal_PUSH_GPR_NUM_REG ,uint32_t  ,_param->_nb_reg_free);
    136137     ALLOC1(internal_PUSH_SPR_VAL     ,Tcontrol_t,_param->_nb_reg_free);
    137138     ALLOC1(internal_PUSH_SPR_NUM_BANK,uint32_t  ,_param->_nb_reg_free);
     139     ALLOC1(internal_PUSH_SPR_NUM_REG ,uint32_t  ,_param->_nb_reg_free);
    138140      }
    139141
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Stat_List_unit/src/Stat_List_unit_deallocation.cpp

    r117 r118  
    7777        DELETE1(internal_PUSH_GPR_VAL     ,_param->_nb_reg_free);
    7878        DELETE1(internal_PUSH_GPR_NUM_BANK,_param->_nb_reg_free);
     79        DELETE1(internal_PUSH_GPR_NUM_REG ,_param->_nb_reg_free);
    7980        DELETE1(internal_PUSH_SPR_VAL     ,_param->_nb_reg_free);
    8081        DELETE1(internal_PUSH_SPR_NUM_BANK,_param->_nb_reg_free);
     82        DELETE1(internal_PUSH_SPR_NUM_REG ,_param->_nb_reg_free);
    8183      }
    8284
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Stat_List_unit/src/Stat_List_unit_genMoore.cpp

    r112 r118  
    88
    99#include "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Stat_List_unit/include/Stat_List_unit.h"
     10#include <set>
    1011
    1112namespace morpheo                    {
     
    1819namespace stat_list_unit {
    1920
     21#define STAT_LIST_SCAN_ALL
    2022
    2123#undef  FUNCTION
     
    2628    log_function(Stat_List_unit,FUNCTION,_name.c_str());
    2729
    28     uint32_t gpr_ptr = reg_GPR_PTR_FREE;
    29     uint32_t spr_ptr = reg_SPR_PTR_FREE;
     30    uint32_t  gpr_ptr = reg_GPR_PTR_FREE;
     31    uint32_t  spr_ptr = reg_SPR_PTR_FREE;
     32#ifdef STAT_LIST_SCAN_ALL
     33    std::set<Tgeneral_address_t> list_gpr_free;
     34    std::set<Tspecial_address_t> list_spr_free;
     35#endif
    3036
    3137    for (uint32_t i=0; i<_param->_nb_reg_free; i++)
    3238      {
     39        log_printf(TRACE,Stat_List_unit,FUNCTION,"  * PUSH [%d]",i);
     40         
    3341        uint32_t offset  = i*_param->_nb_bank_by_port_free;
    3442
    3543        // PUSH_GPR
    3644        {
    37           uint32_t bank_gpr;
    38          
    39           for (bank_gpr=offset; bank_gpr<offset+_param->_nb_bank_by_port_free; bank_gpr++)
    40             if (gpr_stat_list[bank_gpr][gpr_ptr].can_free())
    41               break;
    42          
    43           bool val = (bank_gpr != offset+_param->_nb_bank_by_port_free);
    44          
     45          bool     val      = false;
     46          uint32_t bank_gpr = offset;
     47
     48#ifdef STAT_LIST_SCAN_ALL
     49          for (uint32_t _gpr_ptr=0;  _gpr_ptr<_param->_nb_general_register_by_bank; ++_gpr_ptr)
     50            {
     51              gpr_ptr = (gpr_ptr+1)%_param->_nb_general_register_by_bank;
     52#endif   
     53              for (bank_gpr = offset; bank_gpr<offset+_param->_nb_bank_by_port_free; bank_gpr++)
     54                if (gpr_stat_list[bank_gpr][gpr_ptr].can_free())
     55                  {
     56#ifdef STAT_LIST_SCAN_ALL
     57                    Tgeneral_address_t num_reg = ((bank_gpr<<_param->_shift_gpr) | gpr_ptr);
     58                    if (list_gpr_free.find(num_reg) == list_gpr_free.end())
     59                      {
     60                        list_gpr_free.insert(num_reg);
     61#endif
     62                        val = true;
     63                        break;
     64#ifdef STAT_LIST_SCAN_ALL
     65                      }
     66#endif
     67                  }
     68#ifdef STAT_LIST_SCAN_ALL
     69              if (val)
     70                break;
     71            }
     72#endif   
     73
     74          log_printf(TRACE,Stat_List_unit,FUNCTION,"    * val      : %d",val);
     75          log_printf(TRACE,Stat_List_unit,FUNCTION,"    * bank_gpr : %d",bank_gpr);
     76          log_printf(TRACE,Stat_List_unit,FUNCTION,"    * gpr_ptr  : %d",gpr_ptr);
     77          log_printf(TRACE,Stat_List_unit,FUNCTION,"    * num_reg  : %d",((bank_gpr<<_param->_shift_gpr) | gpr_ptr));
     78
    4579          internal_PUSH_GPR_VAL      [i] = val;
    4680          internal_PUSH_GPR_NUM_BANK [i] = bank_gpr;
     81          internal_PUSH_GPR_NUM_REG  [i] = gpr_ptr ;
    4782
    4883          PORT_WRITE(out_PUSH_GPR_VAL [i], val);
     
    5388        // PUSH_SPR
    5489        {
    55           uint32_t bank_spr;
    56          
    57           for (bank_spr=offset; bank_spr<offset+_param->_nb_bank_by_port_free; bank_spr++)
    58             if (spr_stat_list[bank_spr][spr_ptr].can_free())
    59               break;
     90          bool     val      = false;
     91          uint32_t bank_spr = offset;
    6092
    61           bool val = (bank_spr != (offset+_param->_nb_bank_by_port_free));
    62          
     93#ifdef STAT_LIST_SCAN_ALL
     94          for (uint32_t _spr_ptr=0;  _spr_ptr<_param->_nb_special_register_by_bank; ++_spr_ptr)
     95            {
     96              spr_ptr = (spr_ptr+1)%_param->_nb_special_register_by_bank;
     97#endif   
     98              for (bank_spr = offset; bank_spr<offset+_param->_nb_bank_by_port_free; bank_spr++)
     99                if (spr_stat_list[bank_spr][spr_ptr].can_free())
     100                  {
     101#ifdef STAT_LIST_SCAN_ALL
     102                    Tspecial_address_t num_reg = ((bank_spr<<_param->_shift_spr) | spr_ptr);
     103                    if (list_spr_free.find(num_reg) == list_spr_free.end())
     104                      {
     105                        list_spr_free.insert(num_reg);
     106#endif
     107                        val = true;
     108                        break;
     109#ifdef STAT_LIST_SCAN_ALL
     110                      }
     111#endif
     112                  }
     113#ifdef STAT_LIST_SCAN_ALL
     114              if (val)
     115                break;
     116            }
     117#endif   
     118
     119          log_printf(TRACE,Stat_List_unit,FUNCTION,"    * val      : %d",val);
     120          log_printf(TRACE,Stat_List_unit,FUNCTION,"    * bank_spr : %d",bank_spr);
     121          log_printf(TRACE,Stat_List_unit,FUNCTION,"    * spr_ptr  : %d",spr_ptr);
     122          log_printf(TRACE,Stat_List_unit,FUNCTION,"    * num_reg  : %d",((bank_spr<<_param->_shift_spr) | spr_ptr));
     123
    63124          internal_PUSH_SPR_VAL      [i] = val;
    64125          internal_PUSH_SPR_NUM_BANK [i] = bank_spr;
     126          internal_PUSH_SPR_NUM_REG  [i] = spr_ptr ;
    65127
    66128          PORT_WRITE(out_PUSH_SPR_VAL [i], val);
     
    68130            PORT_WRITE(out_PUSH_SPR_NUM_REG[i], ((bank_spr<<_param->_shift_spr) | spr_ptr));
    69131        }
     132
     133
    70134      }
    71135   
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Stat_List_unit/src/Stat_List_unit_transition.cpp

    r117 r118  
    233233            // =====================================================
    234234            if (internal_PUSH_GPR_VAL [i] and PORT_READ(in_PUSH_GPR_ACK [i]))
    235               gpr_stat_list[internal_PUSH_GPR_NUM_BANK [i]][reg_GPR_PTR_FREE].free();
     235              gpr_stat_list[internal_PUSH_GPR_NUM_BANK [i]][internal_PUSH_GPR_NUM_REG [i]].free();
    236236           
    237237            // =====================================================
     
    239239            // =====================================================
    240240            if (internal_PUSH_SPR_VAL [i] and PORT_READ(in_PUSH_SPR_ACK [i]))
    241               spr_stat_list[internal_PUSH_SPR_NUM_BANK [i]][reg_SPR_PTR_FREE].free();
     241              spr_stat_list[internal_PUSH_SPR_NUM_BANK [i]][internal_PUSH_SPR_NUM_REG [i]].free();
    242242          }
    243243
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Special_Register_unit/src/Special_Register_unit_transition.cpp

    r100 r118  
    133133                }
    134134            }
     135
     136#if (DEBUG >= DEBUG_TRACE) and (DEBUG_Special_Register_unit == true)
     137        {
     138          log_printf(TRACE,Special_Register_unit,FUNCTION,"  * Dump SPR");
     139
     140          for (uint32_t i=0; i<_param->_nb_front_end; i++)
     141            for (uint32_t j=0; j<_param->_nb_context[i]; j++)
     142              {
     143                log_printf(TRACE,Special_Register_unit,FUNCTION,"    * SR        [%d][%d] : %.8x",i,j,_spr [i][j][GROUP_SYSTEM_AND_CONTROL][SPR_SR          ]->read());
     144                log_printf(TRACE,Special_Register_unit,FUNCTION,"    * CID       [%d][%d] : %.8x",i,j,_spr [i][j][GROUP_SYSTEM_AND_CONTROL][SPR_CID         ]->read());
     145                log_printf(TRACE,Special_Register_unit,FUNCTION,"    * TID       [%d][%d] : %.8x",i,j,_spr [i][j][GROUP_SYSTEM_AND_CONTROL][SPR_TID         ]->read());
     146                log_printf(TRACE,Special_Register_unit,FUNCTION,"    * TSR       [%d][%d] : %.8x",i,j,_spr [i][j][GROUP_SYSTEM_AND_CONTROL][SPR_TSR         ]->read());
     147//                 log_printf(TRACE,Special_Register_unit,FUNCTION,"    * MACLO     [%d][%d] : %.8x",i,j,_spr [i][j][GROUP_MAC               ][SPR_MACLO      ]->read());
     148//                 log_printf(TRACE,Special_Register_unit,FUNCTION,"    * MACHI     [%d][%d] : %.8x",i,j,_spr [i][j][GROUP_MAC               ][SPR_MACHI      ]->read());
     149              }
     150        }
     151#endif
    135152      }
    136153
Note: See TracChangeset for help on using the changeset viewer.