Ignore:
Timestamp:
Jun 17, 2009, 2:11:25 PM (15 years ago)
Author:
rosiere
Message:

1) Add test and configuration
2) Fix Bug
3) Add log file in load store unit
4) Fix Bug in environment

Location:
trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit
Files:
9 edited

Legend:

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

    r123 r124  
    6363  public    : counter_t                     ** _stat_nb_inst_type                 ;//[nb_type]
    6464  public    : counter_t                     ** _stat_bank_nb_inst                 ;//[nb_bank]
     65
     66  public    : counter_t                     ** _stat_nb_cycle_state_no_event      ;//[nb_thread]     
     67  public    : counter_t                     ** _stat_nb_cycle_state_not_yet_event ;//[nb_thread]
     68  public    : counter_t                     ** _stat_nb_cycle_state_event         ;//[nb_thread]
     69  public    : counter_t                     ** _stat_nb_cycle_state_wait_end      ;//[nb_thread]
    6570#endif
    6671
     
    254259//private   : bool                         ** reg_EVENT_CAN_RESTART                ;//[nb_front_end][nb_context]
    255260  private   : uint32_t                     ** reg_EVENT_PACKET                     ;//[nb_front_end][nb_context]
     261  private   : uint32_t                     ** reg_EVENT_NB_INST                    ;//[nb_front_end][nb_context]
    256262  private   : bool                         ** reg_EVENT_LAST                       ;//[nb_front_end][nb_context]
    257263  private   : uint32_t                     ** reg_EVENT_LAST_NUM_BANK              ;//[nb_front_end][nb_context]
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/include/Types.h

    r123 r124  
    6767//    COMMIT_EVENT_STATE_WAIT_DECOD   ,
    6868      COMMIT_EVENT_STATE_WAIT_END     ,
    69       COMMIT_EVENT_STATE_END     
     69//    COMMIT_EVENT_STATE_END          
    7070    } Tcommit_event_state_t;
    7171
    72 #define commit_event_state_to_event_state(x) ((x==COMMIT_EVENT_STATE_EVENT)?EVENT_STATE_EVENT:((x==COMMIT_EVENT_STATE_WAIT_END)?EVENT_STATE_WAITEND:((x==COMMIT_EVENT_STATE_END)?EVENT_STATE_END:EVENT_STATE_NO_EVENT)))
     72#define commit_event_state_to_event_state(x) ((x==COMMIT_EVENT_STATE_EVENT)?EVENT_STATE_EVENT:((x==COMMIT_EVENT_STATE_WAIT_END)?EVENT_STATE_WAITEND:EVENT_STATE_NO_EVENT))
     73
     74// #define commit_event_state_to_event_state(x) ((x==COMMIT_EVENT_STATE_EVENT)?EVENT_STATE_EVENT:((x==COMMIT_EVENT_STATE_WAIT_END)?EVENT_STATE_WAITEND:((x==COMMIT_EVENT_STATE_END)?EVENT_STATE_END:EVENT_STATE_NO_EVENT)))
    7375// #define commit_event_state_to_event_state(x) ((x==COMMIT_EVENT_STATE_EVENT)?EVENT_STATE_EVENT:((x==COMMIT_EVENT_STATE_WAIT_DECOD)?EVENT_STATE_WAITEND:((x==COMMIT_EVENT_STATE_WAIT_END)?EVENT_STATE_WAITEND:((x==COMMIT_EVENT_STATE_END)?EVENT_STATE_END:EVENT_STATE_NO_EVENT))))
    7476
     
    116118  public  : Tspecial_data_t    flags                   ;
    117119  public  : Tcontrol_t         no_sequence             ;
    118   public  : Tcontrol_t         speculative             ;
     120//public  : Tcontrol_t         speculative             ;
    119121//public  : Tgeneral_data_t    data_commit             ; // branch's destination
    120122#ifdef DEBUG
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_allocation.cpp

    r123 r124  
    332332//  ALLOC2(reg_EVENT_CAN_RESTART    ,bool                 ,_param->_nb_front_end,_param->_nb_context [it1]);
    333333    ALLOC2(reg_EVENT_PACKET         ,uint32_t             ,_param->_nb_front_end,_param->_nb_context [it1]);
     334    ALLOC2(reg_EVENT_NB_INST        ,uint32_t             ,_param->_nb_front_end,_param->_nb_context [it1]);
    334335    ALLOC2(reg_EVENT_LAST           ,bool                 ,_param->_nb_front_end,_param->_nb_context [it1]);
    335336    ALLOC2(reg_EVENT_LAST_NUM_BANK  ,uint32_t             ,_param->_nb_front_end,_param->_nb_context [it1]);
     
    371372                                                   "",
    372373                                                   "log",
    373                                                    false,
    374                                                    log_with_pid,
     374                                                   _simulation_file_with_date,
     375                                                   _simulation_file_with_pid ,
    375376                                                   true);
    376 
    377           log_printf(TRACE,Commit_unit,FUNCTION,"KANE : %s",filename.c_str());
    378377         
    379378          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_deallocation.cpp

    r123 r124  
    213213        DELETE2(reg_EVENT_NUM_BANK       ,_param->_nb_front_end,_param->_nb_context [it1]);
    214214        DELETE2(reg_EVENT_NUM_PTR        ,_param->_nb_front_end,_param->_nb_context [it1]);
    215 //         DELETE2(reg_EVENT_CAN_RESTART    ,_param->_nb_front_end,_param->_nb_context [it1]);
     215//      DELETE2(reg_EVENT_CAN_RESTART    ,_param->_nb_front_end,_param->_nb_context [it1]);
    216216        DELETE2(reg_EVENT_PACKET         ,_param->_nb_front_end,_param->_nb_context [it1]);
     217        DELETE2(reg_EVENT_NB_INST        ,_param->_nb_front_end,_param->_nb_context [it1]);
    217218        DELETE2(reg_EVENT_LAST           ,_param->_nb_front_end,_param->_nb_context [it1]);
    218219        DELETE2(reg_EVENT_LAST_NUM_BANK  ,_param->_nb_front_end,_param->_nb_context [it1]);
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_genMealy_insert.cpp

    r123 r124  
    9595                  {
    9696                    log_printf(TRACE,Commit_unit,FUNCTION,"      * have instruction");
     97                    log_printf(TRACE,Commit_unit,FUNCTION,"      * num_bank  : %d",num_bank);
    9798                    log_printf(TRACE,Commit_unit,FUNCTION,"      * bank_full : %d",bank_full [num_bank]);
    9899                   
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_genMoore.cpp

    r123 r124  
    3232      uint32_t nb_scan_bank = 0; // last scan bank
    3333      bool     can_continue = true;
     34
     35      uint32_t event_nb_inst  [_param->_nb_front_end][_param->_max_nb_context];
     36      for (uint32_t i=0; i<_param->_nb_front_end; i++)
     37        for (uint32_t j=0; j<_param->_nb_context [i]; j++)
     38          event_nb_inst [i][j] = 0;
    3439
    3540      // for each reexecute_port
     
    5964                  // Read state
    6065                  entry_t    * entry = _rob [num_bank].front();
     66                  uint32_t     num_packet   = ((entry->ptr << _param->_shift_num_slot) | num_bank);
     67                  Tcontext_t   front_end_id = entry->front_end_id;
     68                  Tcontext_t   context_id   = entry->context_id  ;
     69
    6170                  rob_state_t  state = entry->state;
    6271                 
     
    7382                            );
    7483                 
    75                   can_continue &= ((state == ROB_STORE_OK          ) or
    76                                    (state == ROB_STORE_OK_WAIT_END ) or
    77                                    (state == ROB_END_OK_SPECULATIVE) or
    78                                    (state == ROB_END_OK            ) or
    79                                    (state == ROB_END               )
     84                  can_continue &= (((state == ROB_STORE_OK          ) or
     85                                    (state == ROB_STORE_OK_WAIT_END ) or
     86                                    (state == ROB_END_OK_SPECULATIVE) or
     87                                    (state == ROB_END_OK            ) or
     88                                    (state == ROB_END               )) and
     89                                   not ((reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_NOT_YET_EVENT) and
     90                                        (reg_EVENT_PACKET[front_end_id][context_id] == num_packet)) and
     91                                   not ((reg_EVENT_NB_INST [front_end_id][context_id] > 0) and
     92                                        ((++event_nb_inst [front_end_id][context_id]) >= reg_EVENT_NB_INST [front_end_id][context_id]))
    8093                                   );
    8194
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_statistics_allocation.cpp

    r111 r124  
    2727                      param_statistics);
    2828
    29     _stat_nb_inst_insert                = new counter_t * [_param->_nb_rename_unit];
    30     _stat_nb_inst_retire                = new counter_t * [_param->_nb_rename_unit];
    31     _stat_nb_inst_retire_ok             = new counter_t * [_param->_nb_thread];
    32     _stat_nb_inst_retire_ko             = new counter_t * [_param->_nb_thread];
    33     _stat_nb_inst_type                  = new counter_t * [_param->_nb_type];
    34     _stat_bank_nb_inst                  = new counter_t * [_param->_nb_bank];
     29    _stat_nb_cycle_state_no_event      = new counter_t * [_param->_nb_thread];
     30    _stat_nb_cycle_state_not_yet_event = new counter_t * [_param->_nb_thread];
     31    _stat_nb_cycle_state_event         = new counter_t * [_param->_nb_thread];
     32    _stat_nb_cycle_state_wait_end      = new counter_t * [_param->_nb_thread];
     33
     34    {
     35      for (uint32_t i=0; i<_param->_nb_thread; i++)
     36        if (_param->_have_thread [i])
     37          {
     38            _stat_nb_cycle_state_no_event      [i] = _stat->create_variable("nb_cycle_state_no_event_"     +toString(i));
     39            _stat_nb_cycle_state_not_yet_event [i] = _stat->create_variable("nb_cycle_state_not_yet_event_"+toString(i));
     40            _stat_nb_cycle_state_event         [i] = _stat->create_variable("nb_cycle_state_event_"        +toString(i));
     41            _stat_nb_cycle_state_wait_end      [i] = _stat->create_variable("nb_cycle_state_wait_end_"     +toString(i));
     42           
     43            _stat->create_expr_percent("percent_state_no_event_"      +toString(i),"nb_cycle_state_no_event_"      +toString(i),"cycle",toString(_("Percent of cycle in state no_event        (context %d)"),i));
     44            _stat->create_expr_percent("percent_state_not_yet_event_" +toString(i),"nb_cycle_state_not_yet_event_" +toString(i),"cycle",toString(_("Percent of cycle in state not_yet_event   (context %d)"),i));
     45            _stat->create_expr_percent("percent_state_event_"         +toString(i),"nb_cycle_state_event_"         +toString(i),"cycle",toString(_("Percent of cycle in state event           (context %d)"),i));
     46            _stat->create_expr_percent("percent_state_wait_end_"      +toString(i),"nb_cycle_state_wait_end_"      +toString(i),"cycle",toString(_("Percent of cycle in state wait_end        (context %d)"),i));
     47          }
     48    }
     49
     50    _stat_nb_inst_insert         = new counter_t * [_param->_nb_rename_unit];
     51    _stat_nb_inst_retire         = new counter_t * [_param->_nb_rename_unit];
     52    _stat_nb_inst_retire_ok      = new counter_t * [_param->_nb_thread];
     53    _stat_nb_inst_retire_ko      = new counter_t * [_param->_nb_thread];
     54    _stat_nb_inst_type           = new counter_t * [_param->_nb_type];
     55    _stat_bank_nb_inst           = new counter_t * [_param->_nb_bank];
    3556   
    3657    {
     
    124145    }
    125146
    126 
    127147    _stat_nb_inst_commit = _stat->create_variable("nb_inst_commit");
    128148    _stat->create_expr_average_by_cycle("average_use_interface_commit","nb_inst_commit", "", _("Average instruction by cycle on commit interface"));
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_statistics_deallocation.cpp

    r110 r124  
    3333    delete [] _stat_nb_inst_type;
    3434    delete [] _stat_bank_nb_inst;
     35
     36    delete [] _stat_nb_cycle_state_no_event      ;
     37    delete [] _stat_nb_cycle_state_not_yet_event ;
     38    delete [] _stat_nb_cycle_state_event         ;
     39    delete [] _stat_nb_cycle_state_wait_end      ;
     40
    3541   
    3642    log_end(Commit_unit,FUNCTION);
  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_transition.cpp

    r123 r124  
    5454//            reg_EVENT_FLUSH           [i][j] = false;
    5555//            reg_EVENT_STOP            [i][j] = false;
     56              reg_EVENT_NB_INST         [i][j] = 0;
    5657              reg_EVENT_LAST            [i][j] = false;
    5758
     
    126127//                     break;
    127128//                   }
     129
     130//                 case COMMIT_EVENT_STATE_WAIT_END :
     131//                   {
     132//                     // Wait the flush of Re Order Buffer.
     133//                     // Test if the last element is retire
     134//                     if (reg_EVENT_LAST [i][j])
     135//                       reg_EVENT_STATE [i][j] = COMMIT_EVENT_STATE_END ;
     136                   
     137//                     break;
     138//                   }
     139//                 case COMMIT_EVENT_STATE_END      :
     140//                   {
     141//                     // Just one cycle
     142                   
     143//                     // flush of re order buffer is finish
     144//                     reg_EVENT_LAST  [i][j] = false;
     145
     146//                     if (not reg_EVENT_NEXT_STOP [i][j])
     147//                       reg_EVENT_STATE [i][j] = COMMIT_EVENT_STATE_NO_EVENT;
     148//                     else
     149//                       {
     150//                         reg_EVENT_NEXT_STOP [i][j] = false;
     151//                         reg_EVENT_PACKET [i][j] = reg_EVENT_NEXT_PACKET [i][j];
     152//                         reg_EVENT_STATE         [i][j] = COMMIT_EVENT_STATE_NOT_YET_EVENT;
     153// //                      reg_EVENT_STOP          [i][j] = true;
     154//                         reg_EVENT_LAST_NUM_BANK [i][j] = ((reg_NUM_BANK_TAIL==0)?_param->_nb_bank:reg_NUM_BANK_TAIL)-1;
     155//                         reg_EVENT_LAST_NUM_PTR  [i][j] = reg_NUM_PTR_TAIL;
     156//                       }
     157
     158//                     break;
     159//                   }
     160
     161
    128162                case COMMIT_EVENT_STATE_WAIT_END :
    129163                  {
     
    131165                    // Test if the last element is retire
    132166                    if (reg_EVENT_LAST [i][j])
    133                       reg_EVENT_STATE [i][j] = COMMIT_EVENT_STATE_END ;
    134                    
     167                      {
     168                        // flush of re order buffer is finish
     169                        reg_EVENT_LAST  [i][j] = false;
     170                       
     171                        if (not reg_EVENT_NEXT_STOP [i][j])
     172                          reg_EVENT_STATE [i][j] = COMMIT_EVENT_STATE_NO_EVENT;
     173                        else
     174                          {
     175                            reg_EVENT_STATE         [i][j] = COMMIT_EVENT_STATE_NOT_YET_EVENT;
     176
     177                            reg_EVENT_NEXT_STOP     [i][j] = false;
     178                            reg_EVENT_PACKET        [i][j] = reg_EVENT_NEXT_PACKET [i][j];
     179                            reg_EVENT_NB_INST       [i][j] = reg_NB_INST_COMMIT_ALL [i][j];
     180                          //reg_EVENT_STOP          [i][j] = true;
     181                            reg_EVENT_LAST_NUM_BANK [i][j] = ((reg_NUM_BANK_TAIL==0)?_param->_nb_bank:reg_NUM_BANK_TAIL)-1;
     182                            reg_EVENT_LAST_NUM_PTR  [i][j] = reg_NUM_PTR_TAIL;
     183                          }
     184                      }
    135185                    break;
    136186                  }
    137                 case COMMIT_EVENT_STATE_END      :
    138                   {
    139                     // Just one cycle
    140                    
    141                     // flush of re order buffer is finish
    142                     reg_EVENT_LAST  [i][j] = false;
    143 
    144                     if (not reg_EVENT_NEXT_STOP [i][j])
    145                       reg_EVENT_STATE [i][j] = COMMIT_EVENT_STATE_NO_EVENT;
    146                     else
    147                       {
    148                         reg_EVENT_NEXT_STOP [i][j] = false;
    149                         reg_EVENT_PACKET [i][j] = reg_EVENT_NEXT_PACKET [i][j];
    150                         reg_EVENT_STATE         [i][j] = COMMIT_EVENT_STATE_NOT_YET_EVENT;
    151 //                      reg_EVENT_STOP          [i][j] = true;
    152                         reg_EVENT_LAST_NUM_BANK [i][j] = ((reg_NUM_BANK_TAIL==0)?_param->_nb_bank:reg_NUM_BANK_TAIL)-1;
    153                         reg_EVENT_LAST_NUM_PTR  [i][j] = reg_NUM_PTR_TAIL;
    154                       }
    155 
    156                     break;
    157                   }
     187
    158188                  //case COMMIT_EVENT_STATE_NO_EVENT :
    159189                  //case COMMIT_EVENT_STATE_NOT_YET_EVENT :
     
    166196        // ===================================================================
    167197        {
     198//           for (uint32_t i=0; i<_param->_nb_rename_unit; i++)
     199//             for (uint32_t j=0; j<_param->_nb_inst_insert[i]; j++)
     200//               log_printf(TRACE,Commit_unit,FUNCTION,"  * INSERT_VAL        [%d][%d] : %d",i,j,PORT_READ(in_INSERT_VAL [i][j]));
     201             
    168202          // variable to count instruction insert
    169203          uint32_t nb_insert = 0;
    170 
     204         
    171205          for (uint32_t i=0; i<_param->_nb_bank; i++)
    172206            {
     
    241275                      entry->num_reg_re_phy_new      = PORT_READ(in_INSERT_NUM_REG_RE_PHY_NEW    [x][y]);
    242276                      entry->no_sequence             = type == TYPE_BRANCH;
    243                       entry->speculative             = true;
     277//                    entry->speculative             = true;
    244278#ifdef DEBUG       
    245279                      entry->address                 = PORT_READ(in_INSERT_ADDRESS               [x][y]);
     
    371405#endif
    372406
    373                     log_printf(TRACE,Commit_unit,FUNCTION,"    * num_bank   : %d",i);
     407                    log_printf(TRACE,Commit_unit,FUNCTION,"    * num_bank              : %d",i);
    374408
    375409                    // find the good entry !!!
    376410                    entry_t *       entry        = internal_BANK_COMMIT_ENTRY [i][j];
    377411
    378                     log_printf(TRACE,Commit_unit,FUNCTION,"    * ptr        : %d",entry->ptr);
     412                    log_printf(TRACE,Commit_unit,FUNCTION,"    * ptr                   : %d",entry->ptr);
    379413                                                 
    380414                  //Toperation_t    operation    = PORT_READ(in_COMMIT_OPERATION   [x]);
     
    437471                          }
    438472                      }
     473
     474                    log_printf(TRACE,Commit_unit,FUNCTION,"    * have_exception        : %d",have_exception       );
     475                    log_printf(TRACE,Commit_unit,FUNCTION,"    * have_miss_speculation : %d",have_miss_speculation);
     476
    439477                   
    440478                    // Next state depends of previous state
     
    509547                        bool flush = ((reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_EVENT) or
    510548//                                    (reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_WAIT_DECOD) or
    511                                       (reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_WAIT_END) or
    512                                       (reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_END)
     549                                      (reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_WAIT_END)// or
     550//                                       (reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_END)
    513551                                      );
    514552                       
    515553                        uint32_t packet = ((entry->ptr << _param->_shift_num_slot) | i);
    516554                        uint32_t _top   = ((_rob[ reg_NUM_BANK_HEAD].front()->ptr << _param->_shift_num_slot) | reg_NUM_BANK_HEAD);
     555
     556                        log_printf(TRACE,Commit_unit,FUNCTION,"    * flush                 : %d",flush);
     557                        log_printf(TRACE,Commit_unit,FUNCTION,"    * packet                : %d",packet);
    517558                           
    518559                        if (not flush)
     
    539580                                // have an error, stop issue instruction
    540581                                reg_EVENT_STATE         [front_end_id][context_id] = COMMIT_EVENT_STATE_NOT_YET_EVENT;
    541                                 //                      reg_EVENT_STOP          [front_end_id][context_id] = true;
     582
     583                                reg_EVENT_NB_INST       [front_end_id][context_id] = reg_NB_INST_COMMIT_ALL [front_end_id][context_id];
     584
     585                              //reg_EVENT_STOP          [front_end_id][context_id] = true;
    542586                               
    543587                                reg_EVENT_LAST_NUM_BANK [front_end_id][context_id] = ((reg_NUM_BANK_TAIL==0)?_param->_nb_bank:reg_NUM_BANK_TAIL)-1;
     
    549593                            bool find = true;
    550594
     595                            log_printf(TRACE,Commit_unit,FUNCTION,"    * reg_EVENT_NEXT_STOP   : %d",reg_EVENT_NEXT_STOP  [front_end_id][context_id]);
     596                            log_printf(TRACE,Commit_unit,FUNCTION,"    * reg_EVENT_NEXT_PACKET : %d",reg_EVENT_NEXT_PACKET[front_end_id][context_id]);
     597
    551598                            // already manage an event.
    552599                            if (reg_EVENT_NEXT_STOP [front_end_id][context_id])
     
    555602                                uint32_t _old = reg_EVENT_NEXT_PACKET [front_end_id][context_id];
    556603                                uint32_t _new = packet;
     604
     605                                log_printf(TRACE,Commit_unit,FUNCTION,"    * _top                  : %d",_top );
     606                                log_printf(TRACE,Commit_unit,FUNCTION,"    * _old (before)         : %d",_old );
     607                                log_printf(TRACE,Commit_unit,FUNCTION,"    * _new (before)         : %d",_new );
     608
    557609                                if (_old < _top) _old = _old+_param->_size_queue;
    558610                                if (_new < _top) _new = _new+_param->_size_queue;
    559611                                if (_new > _old) reg_EVENT_NEXT_PACKET [front_end_id][context_id] = packet;
    560                                 find = false;
     612                                else find = false;
     613
     614                                log_printf(TRACE,Commit_unit,FUNCTION,"    * _old (after)          : %d",_old );
     615                                log_printf(TRACE,Commit_unit,FUNCTION,"    * _new (after)          : %d",_new );
    561616                              }
    562617                            else
     
    565620                                uint32_t _old = ((reg_EVENT_LAST_NUM_PTR [front_end_id][context_id] << _param->_shift_num_slot) | reg_EVENT_LAST_NUM_BANK [front_end_id][context_id]);
    566621                                uint32_t _new = packet;
     622
     623                                log_printf(TRACE,Commit_unit,FUNCTION,"    * _top                  : %d",_top );
     624                                log_printf(TRACE,Commit_unit,FUNCTION,"    * _old (before)         : %d",_old );
     625                                log_printf(TRACE,Commit_unit,FUNCTION,"    * _new (before)         : %d",_new );
     626
    567627                                if (_old < _top) _old = _old+_param->_size_queue;
    568628                                if (_new < _top) _new = _new+_param->_size_queue;
    569629                                if (_new > _old) reg_EVENT_NEXT_PACKET [front_end_id][context_id] = packet;
    570                                 find = false;
     630                                else find = false;
     631
     632                                log_printf(TRACE,Commit_unit,FUNCTION,"    * _old (after)          : %d",_old );
     633                                log_printf(TRACE,Commit_unit,FUNCTION,"    * _new (after)          : %d",_new );
    571634                              }
     635
     636                            log_printf(TRACE,Commit_unit,FUNCTION,"    * find                  : %d",find);
    572637
    573638                            if (find)
     
    710775                    //   * need event
    711776                    //   * packet id = last packet id
    712                     if (((reg_EVENT_STATE         [front_end_id][context_id] != COMMIT_EVENT_STATE_NO_EVENT     ) and
    713                          (reg_EVENT_STATE         [front_end_id][context_id] != COMMIT_EVENT_STATE_NOT_YET_EVENT)) and
    714                         (reg_EVENT_LAST_NUM_BANK [front_end_id][context_id] == num_bank            ) and
    715                         (reg_EVENT_LAST_NUM_PTR  [front_end_id][context_id] == entry->ptr          ))
    716                       reg_EVENT_LAST [front_end_id][context_id] = true;
    717                    
     777//                     for (uint32_t x=0; x<_param->_nb_front_end; x++)
     778//                       for (uint32_t y=0; y<_param->_nb_context [x]; y++)
     779//                         if (((reg_EVENT_STATE         [x][y] != COMMIT_EVENT_STATE_NO_EVENT     ) and
     780//                              (reg_EVENT_STATE         [x][y] != COMMIT_EVENT_STATE_NOT_YET_EVENT)) and
     781//                             (reg_EVENT_LAST_NUM_BANK [x][y] == num_bank            ) and
     782//                             (reg_EVENT_LAST_NUM_PTR  [x][y] == entry->ptr          ))
     783//                           reg_EVENT_LAST [x][y] = true;
     784
     785
     786                    if (reg_EVENT_NB_INST [front_end_id][context_id] > 0)
     787                      {
     788                        reg_EVENT_NB_INST [front_end_id][context_id] --;
     789                        if (reg_EVENT_NB_INST [front_end_id][context_id] == 0)
     790                          reg_EVENT_LAST [front_end_id][context_id] = true;
     791                      }
     792
    718793                    // Update nb_inst
    719794                    reg_NB_INST_COMMIT_ALL [front_end_id][context_id] --;
     
    853928                      // In all case, stop instruction flow
    854929                      reg_EVENT_STATE         [entry->front_end_id][entry->context_id] = COMMIT_EVENT_STATE_NOT_YET_EVENT;
     930                      reg_EVENT_NB_INST       [entry->front_end_id][entry->context_id] = reg_NB_INST_COMMIT_ALL [entry->front_end_id][entry->context_id];
     931                               
    855932//                    reg_EVENT_STOP          [entry->front_end_id][entry->context_id] = true;
    856933
     
    918995
    919996        {
    920           bool EVENT_LAST [_param->_nb_front_end][_param->_max_nb_context];
     997          bool     can_continue   [_param->_nb_front_end][_param->_max_nb_context];
     998          uint32_t event_nb_inst  [_param->_nb_front_end][_param->_max_nb_context];
     999          bool     is_speculative [_param->_nb_front_end][_param->_max_nb_context];
    9211000          for (uint32_t i=0; i<_param->_nb_front_end; i++)
    9221001            for (uint32_t j=0; j<_param->_nb_context [i]; j++)
    923               EVENT_LAST [i][j] = reg_EVENT_LAST [i][j];
     1002              {
     1003                event_nb_inst [i][j] = 0;
     1004                is_speculative[i][j] = false;
     1005                can_continue  [i][j] = (((reg_EVENT_NB_INST [i][j] == 0) or
     1006                                         (    event_nb_inst [i][j] < reg_EVENT_NB_INST [i][j])) and
     1007                                        not reg_EVENT_LAST [i][j]);
     1008              }
    9241009
    9251010          // Read all instruction of all top bank
     
    9331018                  // Scan all instruction in windows and test if instruction is speculative
    9341019                  entry_t    * entry        = _rob [num_bank].front();
    935                  
     1020
     1021                  uint32_t     num_packet   = ((entry->ptr << _param->_shift_num_slot) | num_bank);
    9361022                  Tcontext_t   front_end_id = entry->front_end_id;
    9371023                  Tcontext_t   context_id   = entry->context_id  ;
     1024
     1025                  log_printf(TRACE,Commit_unit,FUNCTION,"  * HEAD              [%d] - %d",num_bank,num_packet);
     1026                  log_printf(TRACE,Commit_unit,FUNCTION,"    * front_end_id    : %d",front_end_id);
     1027                  log_printf(TRACE,Commit_unit,FUNCTION,"    * context_id      : %d",context_id);
     1028                  log_printf(TRACE,Commit_unit,FUNCTION,"    * EVENT_LAST      : %d",reg_EVENT_LAST    [front_end_id][context_id]);
     1029                  log_printf(TRACE,Commit_unit,FUNCTION,"    * EVENT_NB_INST   : %d",reg_EVENT_NB_INST [front_end_id][context_id]);
     1030                  log_printf(TRACE,Commit_unit,FUNCTION,"    * event_nb_inst   : %d",    event_nb_inst [front_end_id][context_id]);
    9381031                 
    9391032                  // scan while last event instruction is not retire
    940                   if (EVENT_LAST [front_end_id][context_id] == false)
     1033                  if (can_continue  [front_end_id][context_id])
    9411034                    {
    9421035                      // Read information
     
    9651058//                                                  (reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_WAIT_DECOD) or
    9661059                                                    (reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_WAIT_END));
    967                       bool         speculative   = entry->speculative and not (depth == depth_min);
    968                       Tcontrol_t   is_valid      = ((not speculative or
    969                                                      (speculative and (depth_full or // all is valid
    970                                                                        ((depth_min <= depth_max)? // test if depth is overflow
    971                                                                         ((depth >= depth_min) and (depth <=depth_max)):
    972                                                                         ((depth >= depth_min) or  (depth <=depth_max))))))
    973                                                     and not flush); // no event
    974                      
     1060                      bool         speculative   = is_speculative [front_end_id][context_id];
     1061
     1062//                       bool         speculative   = entry->speculative and not (depth == depth_min);
     1063//                       Tcontrol_t   is_valid      = ((not speculative or
     1064//                                                      (speculative and (depth_full or // all is valid
     1065//                                                                        ((depth_min <= depth_max)? // test if depth is overflow
     1066//                                                                         ((depth >= depth_min) and (depth <=depth_max)):
     1067//                                                                         ((depth >= depth_min) or  (depth <=depth_max))))))
     1068//                                                     and not flush); // no event
     1069
     1070                      Tcontrol_t   is_valid      = not flush;
     1071
     1072
    9751073                      //Tcontrol_t   is_valid      = ((depth == depth_min) and not flush);
    9761074                     
    977                       log_printf(TRACE,Commit_unit,FUNCTION,"  * HEAD              [%d] - %d",num_bank,((entry->ptr << _param->_shift_num_slot) | num_bank));
    9781075                     
    9791076                      log_printf(TRACE,Commit_unit,FUNCTION,"    * is_valid        : %d ((depth == depth_min) and not flush)",is_valid);
     
    9841081                      log_printf(TRACE,Commit_unit,FUNCTION,"    * speculative     : %d",speculative);
    9851082                      log_printf(TRACE,Commit_unit,FUNCTION,"    * flush           : %d",flush);
     1083                      log_printf(TRACE,Commit_unit,FUNCTION,"    * state (before)  : %s",toString(state).c_str());
     1084
     1085//                       //------------------------------------------------------
     1086//                       // Event ?
     1087//                       //------------------------------------------------------
     1088
     1089//                       if ((reg_EVENT_STATE  [front_end_id][context_id] == COMMIT_EVENT_STATE_NOT_YET_EVENT) and
     1090//                           (reg_EVENT_PACKET [front_end_id][context_id] == num_packet))
     1091//                         {
     1092//                           switch (state)
     1093//                             {
     1094//                             case ROB_END_BRANCH_MISS_SPECULATIVE : {state = ROB_END_BRANCH_MISS        ; break;}
     1095//                             case ROB_END_LOAD_MISS_SPECULATIVE   : {state = ROB_END_LOAD_MISS_UPDATE   ; break;}
     1096//                             case ROB_END_BRANCH_MISS             :
     1097//                             case ROB_END_LOAD_MISS               :
     1098//                             case ROB_END                         :
     1099//                               {break;}
     1100//                             default :
     1101//                               {
     1102//                                 throw ERRORMORPHEO(FUNCTION,toString(_("Head [%d] : invalid state (%s)"),num_packet,toString(state).c_str()));
     1103//                                 break;
     1104//                               }
     1105//                             }
     1106//                         }
    9861107                   
    9871108                      //------------------------------------------------------
     
    9971118                            case ROB_END_BRANCH_MISS             :
    9981119                            case ROB_END_BRANCH_MISS_SPECULATIVE : {state = ROB_END_MISS      ; break;}
     1120                            case ROB_END_LOAD_MISS               :
    9991121                            case ROB_END_LOAD_MISS_UPDATE        :
    1000                             case ROB_END_LOAD_MISS               :
    10011122                            case ROB_END_LOAD_MISS_SPECULATIVE   : {state = ROB_END_MISS      ; break;}
    10021123                            case ROB_STORE_OK                    : {state = ROB_STORE_KO      ; break;}
     
    10291150                            }
    10301151                        }
     1152
     1153                      //------------------------------------------------------
     1154                      // test if instruction is branch not finish
     1155                      //------------------------------------------------------
     1156                      switch (state)
     1157                        {
     1158                        case ROB_BRANCH_WAIT_END :
     1159                        case ROB_BRANCH_COMPLETE :
     1160                          {
     1161                            is_speculative [front_end_id][context_id] = true;
     1162                            break;
     1163                          }
     1164                        default : break;
     1165                        }
    10311166                     
    10321167                      //------------------------------------------------------
    10331168                      // test if instruction is not speculative
    10341169                      //------------------------------------------------------
    1035                       entry->speculative = speculative;
     1170//                       entry->speculative = speculative;
    10361171//                    if (entry->depth == depth_min)
    10371172                      // test if instruction is speculative (depth != depth_min)
     
    10641199                      // Write new state
    10651200                      entry->state = state;
    1066                      
    1067                       // Test if this instruction is the last of event
    1068                       if (((reg_EVENT_STATE         [front_end_id][context_id] != COMMIT_EVENT_STATE_NO_EVENT) and
    1069                            (reg_EVENT_STATE         [front_end_id][context_id] != COMMIT_EVENT_STATE_NOT_YET_EVENT)) and
    1070                           (reg_EVENT_LAST_NUM_BANK [front_end_id][context_id] == num_bank            ) and
    1071                           (reg_EVENT_LAST_NUM_PTR  [front_end_id][context_id] == entry->ptr          ))
    1072                         {
    1073                           log_printf(TRACE,Commit_unit,FUNCTION,"  * Stop Scan !!!");
     1201
     1202                      log_printf(TRACE,Commit_unit,FUNCTION,"    * state (after )  : %s",toString(state).c_str());
     1203                     
     1204//                    log_printf(TRACE,Commit_unit,FUNCTION,"  * Stop Scan !!!");
    10741205                         
    1075                           EVENT_LAST [front_end_id][context_id] = true;
    1076                         }
     1206                      event_nb_inst [front_end_id][context_id] ++;
     1207
     1208                      // stop if :
     1209                      //  * begin event
     1210                      //  * end event
     1211                      if (((reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_NOT_YET_EVENT) and
     1212                           (reg_EVENT_PACKET[front_end_id][context_id] == num_packet)) or
     1213                          ((reg_EVENT_NB_INST [front_end_id][context_id] > 0) and
     1214                           (    event_nb_inst [front_end_id][context_id] >= reg_EVENT_NB_INST [front_end_id][context_id])))
     1215                        can_continue [front_end_id][context_id] = false;
    10771216                    }
    10781217                }
     
    10831222
    10841223#ifdef STATISTICS
    1085     for (uint32_t i=0; i<_param->_nb_bank; i++)
    1086       if (usage_is_set(_usage,USE_STATISTICS))
    1087         *(_stat_bank_nb_inst [i]) += _rob[i].size();
     1224    if (usage_is_set(_usage,USE_STATISTICS))
     1225      {
     1226        for (uint32_t i=0; i<_param->_nb_bank; i++)
     1227          *(_stat_bank_nb_inst [i]) += _rob[i].size();
     1228
     1229        for (uint32_t i=0; i<_param->_nb_front_end; i++)
     1230          for (uint32_t j=0; j<_param->_nb_context [i]; j++)
     1231            {
     1232              uint32_t num_thread = _param->_translate_num_context_to_num_thread [i][j];
     1233             
     1234              switch (reg_EVENT_STATE [i][j])
     1235                {
     1236                case COMMIT_EVENT_STATE_NO_EVENT      : (*_stat_nb_cycle_state_no_event      [num_thread])++; break;
     1237                case COMMIT_EVENT_STATE_NOT_YET_EVENT : (*_stat_nb_cycle_state_not_yet_event [num_thread])++; break;
     1238                case COMMIT_EVENT_STATE_EVENT         : (*_stat_nb_cycle_state_event         [num_thread])++; break;
     1239                case COMMIT_EVENT_STATE_WAIT_END      : (*_stat_nb_cycle_state_wait_end      [num_thread])++; break;
     1240                }
     1241            }
     1242      }
    10881243#endif
    10891244      }
     
    11091264//          log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT             : %d (bank %d, ptr %d)",((reg_EVENT_NUM_PTR [i][j] << _param->_shift_num_slot) | reg_EVENT_NUM_BANK [i][j]), reg_EVENT_NUM_BANK [i][j],reg_EVENT_NUM_PTR [i][j]);
    11101265//          log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_CAN_RESTART : %d",reg_EVENT_CAN_RESTART [i][j]);
    1111             log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_PACKET      : %d",reg_EVENT_PACKET[i][j]);
    1112             log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_LAST        : %d",reg_EVENT_LAST [i][j]);
    1113             log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_LAST        : %d (bank %d, ptr %d)",((reg_EVENT_LAST_NUM_PTR [i][j] << _param->_shift_num_slot) | reg_EVENT_LAST_NUM_BANK [i][j]), reg_EVENT_LAST_NUM_BANK [i][j],reg_EVENT_LAST_NUM_PTR [i][j]);
    1114             log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_NEXT_STOP   : %d",reg_EVENT_NEXT_STOP  [i][j]);
    1115             log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_NEXT_PACKET : %d",reg_EVENT_NEXT_PACKET[i][j]);
    1116             log_printf(TRACE,Commit_unit,FUNCTION,"      * NB_INST_ALL       : %d",reg_NB_INST_COMMIT_ALL[i][j]);
    1117             log_printf(TRACE,Commit_unit,FUNCTION,"      * NB_INST_MEM       : %d",reg_NB_INST_COMMIT_MEM[i][j]);
    1118             log_printf(TRACE,Commit_unit,FUNCTION,"      * PC_CURRENT        : %.8x (%.8x) - %d %d",reg_PC_CURRENT [i][j],reg_PC_CURRENT [i][j]<<2, reg_PC_CURRENT_IS_DS [i][j], reg_PC_CURRENT_IS_DS_TAKE [i][j]);
    1119             log_printf(TRACE,Commit_unit,FUNCTION,"      * PC_NEXT           : %.8x (%.8x)",reg_PC_NEXT [i][j],reg_PC_NEXT [i][j]<<2);
     1266            log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_LAST        : %d - packet %d - ptr %d (bank %d, ptr %d)",reg_EVENT_LAST [i][j],reg_EVENT_PACKET[i][j],((reg_EVENT_LAST_NUM_PTR [i][j] << _param->_shift_num_slot) | reg_EVENT_LAST_NUM_BANK [i][j]), reg_EVENT_LAST_NUM_BANK [i][j],reg_EVENT_LAST_NUM_PTR [i][j]);
     1267            log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_NEXT        : stop : %d - packet : %d",reg_EVENT_NEXT_STOP  [i][j],reg_EVENT_NEXT_PACKET[i][j]);
     1268            log_printf(TRACE,Commit_unit,FUNCTION,"      * NB_INST_ALL       : all : %d - mem : %d - event : %d",reg_NB_INST_COMMIT_ALL[i][j], reg_NB_INST_COMMIT_MEM[i][j],reg_EVENT_NB_INST[i][j]);
     1269            log_printf(TRACE,Commit_unit,FUNCTION,"      * PC                : %.8x (%.8x) - %d %d - %.8x (%.8x)",reg_PC_CURRENT [i][j],reg_PC_CURRENT [i][j]<<2, reg_PC_CURRENT_IS_DS [i][j], reg_PC_CURRENT_IS_DS_TAKE [i][j],reg_PC_NEXT [i][j],reg_PC_NEXT [i][j]<<2);
    11201270          }
    11211271
     
    11491299                  nb_write_re += ((*it)->write_re)?1:0;
    11501300
    1151                   log_printf(TRACE,Commit_unit,FUNCTION,"        [%.4d][%.4d] (%.4d) %.4d %.4d %.4d %.4d, %.3d %.3d, %.1d, %.1d %.4d, %.1d %.4d, %s",
     1301                  log_printf(TRACE,Commit_unit,FUNCTION,"        [%.4d][%.4d] %.4d %.4d %.4d %.4d, %.3d %.3d, %.1d, %.1d %.4d, %.1d %.4d, %s",
    11521302                             num_bank                       ,
    11531303                             (*it)->ptr                     ,
    1154                              (((*it)->ptr << _param->_shift_num_slot) | num_bank),
    11551304                             (*it)->front_end_id            ,
    11561305                             (*it)->context_id              ,
     
    11651314                             (*it)->load_queue_ptr_write    ,
    11661315                             toString((*it)->state).c_str() );
    1167                   log_printf(TRACE,Commit_unit,FUNCTION,"                     %.1d %.2d %.6d, %.1d %.2d %.6d, %.1d %.1d %.6d, %.1d %.2d %.6d %.6d, %.1d %.1d %.6d %.6d ",
     1316                  log_printf(TRACE,Commit_unit,FUNCTION,"              (%.4d) %.1d %.2d %.6d, %.1d %.2d %.6d, %.1d %.1d %.6d, %.1d %.2d %.6d %.6d, %.1d %.1d %.6d %.6d ",
     1317                             (((*it)->ptr << _param->_shift_num_slot) | num_bank),
    11681318                             (*it)->read_ra                 ,
    11691319                             (*it)->num_reg_ra_log          ,
     
    11841334                             (*it)->num_reg_re_phy_new      );
    11851335                 
    1186                   log_printf(TRACE,Commit_unit,FUNCTION,"                     %.2d %.2d %.1d %.1d %.1d - %.8x (%.8x) %.8x (%.8x)",
     1336                  log_printf(TRACE,Commit_unit,FUNCTION,"                     %.2d %.2d %.1d %.1d - %.8x (%.8x) %.8x (%.8x)",
    11871337                             (*it)->exception_use ,
    11881338                             (*it)->exception     ,
    11891339                             (*it)->flags         ,
    11901340                             (*it)->no_sequence   ,
    1191                              (*it)->speculative   ,
     1341//                              (*it)->speculative   ,
    11921342                             (*it)->address       ,
    11931343                             (*it)->address<<2    ,
     
    12451395        }
    12461396    }
     1397    {
     1398      uint32_t NB_INST [_param->_nb_front_end][_param->_max_nb_context];
     1399      for (uint32_t i=0; i<_param->_nb_front_end; i++)
     1400        for (uint32_t j=0; j<_param->_nb_context [i]; j++)
     1401          NB_INST [i][j] = 0; //reg_EVENT_NB_INST [i][j];
     1402
     1403      for (uint32_t i=0; i<_param->_nb_bank; ++i)
     1404        for (std::list<entry_t*>::iterator it=_rob[i].begin();
     1405             it!=_rob [i].end();
     1406             ++it)
     1407          NB_INST [(*it)->front_end_id][(*it)->context_id] ++;
     1408
     1409      for (uint32_t i=0; i<_param->_nb_front_end; i++)
     1410        for (uint32_t j=0; j<_param->_nb_context [i]; j++)
     1411          if (NB_INST [i][j] != reg_NB_INST_COMMIT_ALL [i][j])
     1412            throw ERRORMORPHEO(FUNCTION,toString(_("Context [%d][%d] have not the good nb_inst (%d in rob, %d in register).\n"),i,j,NB_INST[i][j], reg_NB_INST_COMMIT_ALL [i][j]));
     1413    }
    12471414#endif
    12481415
Note: See TracChangeset for help on using the changeset viewer.