Ignore:
Timestamp:
Jun 8, 2009, 10:43:30 PM (15 years ago)
Author:
rosiere
Message:

1) Fix performance
2) add auto generation to SPECINT2000
3) add reset in genMoore and genMealy

Location:
trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine
Files:
1 added
77 edited

Legend:

Unmodified
Added
Removed

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

    r122 r123  
    8585  public    : SC_IN (Toperation_t       ) ***  in_INSERT_OPERATION                 ;//[nb_rename_unit][nb_inst_insert]
    8686  public    : SC_IN (Tcontrol_t         ) ***  in_INSERT_NO_EXECUTE                ;//[nb_rename_unit][nb_inst_insert]
     87  public    : SC_IN (Tcontrol_t         ) ***  in_INSERT_LAST_EVENT                ;//[nb_rename_unit][nb_inst_insert]
    8788  public    : SC_IN (Tcontrol_t         ) ***  in_INSERT_IS_DELAY_SLOT             ;//[nb_rename_unit][nb_inst_insert]
    8889#ifdef DEBUG
    … …  
    143144  public    : SC_IN (Tcontrol_t         ) ***  in_RETIRE_EVENT_ACK                 ;//[nb_front_end][nb_context]
    144145  public    : SC_OUT(Tevent_state_t     ) *** out_RETIRE_EVENT_STATE               ;//[nb_front_end][nb_context]
    145   public    : SC_OUT(Tcontrol_t         ) *** out_RETIRE_EVENT_FLUSH               ;//[nb_front_end][nb_context]
     146//public    : SC_OUT(Tcontrol_t         ) *** out_RETIRE_EVENT_FLUSH               ;//[nb_front_end][nb_context]
    146147  public    : SC_OUT(Tcontrol_t         ) *** out_RETIRE_EVENT_STOP                ;//[nb_front_end][nb_context]
    147148                                                                                   
    … …  
    225226  public    : SC_OUT(Tcontrol_t         ) *** out_SPR_WRITE_SR_OV                  ;//[nb_front_end][nb_context]
    226227
     228    // ~~~~~[ interface : "info" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     229#ifdef DEBUG_TEST
     230  public    : SC_OUT(bool               )   * out_INFO_ROB_EMPTY                   ;
     231#endif
     232
    227233    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~         
    228234  private   : generic::priority::Priority   * _priority_insert                     ;
    … …  
    243249  private   : Tcommit_event_state_t        ** reg_EVENT_STATE                      ;//[nb_front_end][nb_context]
    244250//private   : bool                         ** reg_EVENT_FLUSH                      ;//[nb_front_end][nb_context]
    245   private   : bool                         ** reg_EVENT_STOP                       ;//[nb_front_end][nb_context]
     251//private   : bool                         ** reg_EVENT_STOP                       ;//[nb_front_end][nb_context]
    246252  private   : uint32_t                     ** reg_EVENT_NUM_BANK                   ;//[nb_front_end][nb_context]
    247253  private   : uint32_t                     ** reg_EVENT_NUM_PTR                    ;//[nb_front_end][nb_context]
    248   private   : bool                         ** reg_EVENT_CAN_RESTART                ;//[nb_front_end][nb_context]
     254//private   : bool                         ** reg_EVENT_CAN_RESTART                ;//[nb_front_end][nb_context]
    249255  private   : uint32_t                     ** reg_EVENT_PACKET                     ;//[nb_front_end][nb_context]
    250256  private   : bool                         ** reg_EVENT_LAST                       ;//[nb_front_end][nb_context]
    251257  private   : uint32_t                     ** reg_EVENT_LAST_NUM_BANK              ;//[nb_front_end][nb_context]
    252258  private   : uint32_t                     ** reg_EVENT_LAST_NUM_PTR               ;//[nb_front_end][nb_context]
     259
     260  private   : bool                         ** reg_EVENT_NEXT_STOP                  ;//[nb_front_end][nb_context]
     261  private   : uint32_t                     ** reg_EVENT_NEXT_PACKET                ;//[nb_front_end][nb_context]
    253262
    254263//private   : Taddress_t                   ** reg_PC_PREVIOUS                      ;//[nb_front_end][nb_context]

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/include/Types.h

    r122 r123  
    6262  typedef enum
    6363    {
    64       COMMIT_EVENT_STATE_NO_EVENT  ,
    65       COMMIT_EVENT_STATE_EVENT     ,
    66       COMMIT_EVENT_STATE_WAIT_DECOD,
    67       COMMIT_EVENT_STATE_WAIT_END  ,
     64      COMMIT_EVENT_STATE_NO_EVENT     ,
     65      COMMIT_EVENT_STATE_NOT_YET_EVENT,
     66      COMMIT_EVENT_STATE_EVENT        ,
     67//    COMMIT_EVENT_STATE_WAIT_DECOD   ,
     68      COMMIT_EVENT_STATE_WAIT_END     ,
    6869      COMMIT_EVENT_STATE_END     
    6970    } Tcommit_event_state_t;
    7071
    71 #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))))
     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)))
     73// #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))))
    7274
    7375
    … …  
    147149      case morpheo::behavioural::core::multi_ooo_engine::ooo_engine::commit_unit::ROB_STORE_OK_WAIT_END          : return "ROB_STORE_OK_WAIT_END"           ; break;
    148150      case morpheo::behavioural::core::multi_ooo_engine::ooo_engine::commit_unit::ROB_STORE_KO_WAIT_END          : return "ROB_STORE_KO_WAIT_END"           ; break;
     151      case morpheo::behavioural::core::multi_ooo_engine::ooo_engine::commit_unit::ROB_STORE_EVENT                : return "ROB_STORE_EVENT"                 ; break;
    149152      case morpheo::behavioural::core::multi_ooo_engine::ooo_engine::commit_unit::ROB_OTHER_WAIT_END             : return "ROB_OTHER_WAIT_END"              ; break;
    150153      case morpheo::behavioural::core::multi_ooo_engine::ooo_engine::commit_unit::ROB_EVENT_WAIT_END             : return "ROB_EVENT_WAIT_END"              ; break;

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

    r121 r123  
    4040    usage_environment(_usage);
    4141
    42 #if DEBUG_Commit_unit == true
    43     log_printf(TRACE,Commit_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
    44 
    45     std::cout << *param << std::endl;
    46 #endif
     42// #if DEBUG_Commit_unit == true
     43//     log_printf(TRACE,Commit_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
     44
     45//     std::cout << *param << std::endl;
     46// #endif
    4747
    4848    log_printf(INFO,Commit_unit,FUNCTION,_("<%s> Allocation"),_name.c_str());

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

    r122 r123  
    7171      _ALLOC2_SIGNAL_IN ( in_INSERT_OPERATION               ,"operation"            ,Toperation_t      ,_param->_size_operation             ,_param->_nb_rename_unit,_param->_nb_inst_insert[it1]);
    7272      _ALLOC2_SIGNAL_IN ( in_INSERT_NO_EXECUTE              ,"no_execute"           ,Tcontrol_t        ,1                                   ,_param->_nb_rename_unit,_param->_nb_inst_insert[it1]);
     73      _ALLOC2_SIGNAL_IN ( in_INSERT_LAST_EVENT              ,"last_event"           ,Tcontrol_t        ,1                                   ,_param->_nb_rename_unit,_param->_nb_inst_insert[it1]);
    7374      _ALLOC2_SIGNAL_IN ( in_INSERT_IS_DELAY_SLOT           ,"is_delay_slot"        ,Tcontrol_t        ,1                                   ,_param->_nb_rename_unit,_param->_nb_inst_insert[it1]);
    7475#ifdef DEBUG
    … …  
    141142      _ALLOC2_VALACK_IN ( in_RETIRE_EVENT_ACK               ,ACK,_param->_nb_front_end,_param->_nb_context[it1]);
    142143      _ALLOC2_SIGNAL_OUT(out_RETIRE_EVENT_STATE             ,"state"                ,Tevent_state_t    ,_param->_size_event_state           ,_param->_nb_front_end,_param->_nb_context[it1]);
    143       _ALLOC2_SIGNAL_OUT(out_RETIRE_EVENT_FLUSH             ,"flush"                ,Tcontrol_t        ,1                                   ,_param->_nb_front_end,_param->_nb_context[it1]);
     144//    _ALLOC2_SIGNAL_OUT(out_RETIRE_EVENT_FLUSH             ,"flush"                ,Tcontrol_t        ,1                                   ,_param->_nb_front_end,_param->_nb_context[it1]);
    144145      _ALLOC2_SIGNAL_OUT(out_RETIRE_EVENT_STOP              ,"stop"                 ,Tcontrol_t        ,1                                   ,_param->_nb_front_end,_param->_nb_context[it1]);
    145146
    … …  
    282283    }
    283284
     285#ifdef DEBUG_TEST
     286    {
     287      ALLOC0_INTERFACE_BEGIN("info",OUT,EAST,_("Information."));
     288      ALLOC0_SIGNAL_OUT(out_INFO_ROB_EMPTY                   ,"rob_empty"   ,bool               ,1);
     289      ALLOC0_INTERFACE_END();
     290    }
     291#endif
     292
    284293    if (usage_is_set(_usage,USE_SYSTEMC))
    285294      {
    … …  
    318327    ALLOC2(reg_EVENT_STATE          ,Tcommit_event_state_t,_param->_nb_front_end,_param->_nb_context [it1]);
    319328//  ALLOC2(reg_EVENT_FLUSH          ,bool                 ,_param->_nb_front_end,_param->_nb_context [it1]);
    320     ALLOC2(reg_EVENT_STOP           ,bool                 ,_param->_nb_front_end,_param->_nb_context [it1]);
     329//  ALLOC2(reg_EVENT_STOP           ,bool                 ,_param->_nb_front_end,_param->_nb_context [it1]);
    321330    ALLOC2(reg_EVENT_NUM_BANK       ,uint32_t             ,_param->_nb_front_end,_param->_nb_context [it1]);
    322331    ALLOC2(reg_EVENT_NUM_PTR        ,uint32_t             ,_param->_nb_front_end,_param->_nb_context [it1]);
    323     ALLOC2(reg_EVENT_CAN_RESTART    ,bool                 ,_param->_nb_front_end,_param->_nb_context [it1]);
     332//  ALLOC2(reg_EVENT_CAN_RESTART    ,bool                 ,_param->_nb_front_end,_param->_nb_context [it1]);
    324333    ALLOC2(reg_EVENT_PACKET         ,uint32_t             ,_param->_nb_front_end,_param->_nb_context [it1]);
    325334    ALLOC2(reg_EVENT_LAST           ,bool                 ,_param->_nb_front_end,_param->_nb_context [it1]);
    326335    ALLOC2(reg_EVENT_LAST_NUM_BANK  ,uint32_t             ,_param->_nb_front_end,_param->_nb_context [it1]);
    327336    ALLOC2(reg_EVENT_LAST_NUM_PTR   ,uint32_t             ,_param->_nb_front_end,_param->_nb_context [it1]);
     337
     338    ALLOC2(reg_EVENT_NEXT_STOP      ,bool                 ,_param->_nb_front_end,_param->_nb_context [it1]);
     339    ALLOC2(reg_EVENT_NEXT_PACKET    ,uint32_t             ,_param->_nb_front_end,_param->_nb_context [it1]);
    328340                                                         
    329341//  ALLOC2(reg_PC_PREVIOUS          ,Taddress_t           ,_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_deallocation.cpp

    r122 r123  
    3838        DELETE2_SIGNAL( in_INSERT_OPERATION               ,_param->_nb_rename_unit,_param->_nb_inst_insert[it1],_param->_size_operation             );
    3939        DELETE2_SIGNAL( in_INSERT_NO_EXECUTE              ,_param->_nb_rename_unit,_param->_nb_inst_insert[it1],1                                   );
     40        DELETE2_SIGNAL( in_INSERT_LAST_EVENT              ,_param->_nb_rename_unit,_param->_nb_inst_insert[it1],1                                   );
    4041        DELETE2_SIGNAL( in_INSERT_IS_DELAY_SLOT           ,_param->_nb_rename_unit,_param->_nb_inst_insert[it1],1                                   );
    4142#ifdef DEBUG
    … …  
    9495        DELETE2_SIGNAL( in_RETIRE_EVENT_ACK               ,_param->_nb_front_end,_param->_nb_context[it1],1);
    9596        DELETE2_SIGNAL(out_RETIRE_EVENT_STATE             ,_param->_nb_front_end,_param->_nb_context[it1],_param->_size_event_state);
    96         DELETE2_SIGNAL(out_RETIRE_EVENT_FLUSH             ,_param->_nb_front_end,_param->_nb_context[it1],1);
     97//      DELETE2_SIGNAL(out_RETIRE_EVENT_FLUSH             ,_param->_nb_front_end,_param->_nb_context[it1],1);
    9798        DELETE2_SIGNAL(out_RETIRE_EVENT_STOP              ,_param->_nb_front_end,_param->_nb_context[it1],1);
    9899
    … …  
    167168        DELETE2_SIGNAL(out_SPR_WRITE_SR_OV                ,_param->_nb_front_end, _param->_nb_context[it1],1);
    168169
     170        DELETE0_SIGNAL(out_INFO_ROB_EMPTY                 ,1);
     171
    169172        // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~     
    170173        DELETE1(internal_BANK_INSERT_VAL             ,_param->_nb_bank);
    … …  
    207210        DELETE2(reg_EVENT_STATE          ,_param->_nb_front_end,_param->_nb_context [it1]);
    208211//      DELETE2(reg_EVENT_FLUSH          ,_param->_nb_front_end,_param->_nb_context [it1]);
    209         DELETE2(reg_EVENT_STOP           ,_param->_nb_front_end,_param->_nb_context [it1]);
     212//      DELETE2(reg_EVENT_STOP           ,_param->_nb_front_end,_param->_nb_context [it1]);
    210213        DELETE2(reg_EVENT_NUM_BANK       ,_param->_nb_front_end,_param->_nb_context [it1]);
    211214        DELETE2(reg_EVENT_NUM_PTR        ,_param->_nb_front_end,_param->_nb_context [it1]);
    212         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]);
    213216        DELETE2(reg_EVENT_PACKET         ,_param->_nb_front_end,_param->_nb_context [it1]);
    214217        DELETE2(reg_EVENT_LAST           ,_param->_nb_front_end,_param->_nb_context [it1]);
    215218        DELETE2(reg_EVENT_LAST_NUM_BANK  ,_param->_nb_front_end,_param->_nb_context [it1]);
    216219        DELETE2(reg_EVENT_LAST_NUM_PTR   ,_param->_nb_front_end,_param->_nb_context [it1]);
     220
     221        DELETE2(reg_EVENT_NEXT_STOP      ,_param->_nb_front_end,_param->_nb_context [it1]);
     222        DELETE2(reg_EVENT_NEXT_PACKET    ,_param->_nb_front_end,_param->_nb_context [it1]);
    217223
    218224//      DELETE2(reg_PC_PREVIOUS          ,_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_commit.cpp

    r119 r123  
    2323    log_begin(Commit_unit,FUNCTION);
    2424    log_function(Commit_unit,FUNCTION,_name.c_str());
     25
     26    if (PORT_READ(in_NRESET))
     27      {
    2528
    2629#ifdef STATISTICS
    … …  
    9699    for (uint32_t i=0; i<_param->_nb_inst_commit; i++)
    97100      PORT_WRITE(out_COMMIT_ACK [i],commit_ack [i]);
     101      }
     102    else
     103      {
     104        for (uint32_t i=0; i<_param->_nb_inst_commit; i++)
     105          PORT_WRITE(out_COMMIT_ACK [i],0);
     106      }
    98107   
    99108    log_end(Commit_unit,FUNCTION);

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

    r122 r123  
    2424    log_function(Commit_unit,FUNCTION,_name.c_str());
    2525
     26    if (PORT_READ(in_NRESET))
     27      {
    2628    Tcontrol_t bank_full         [_param->_nb_bank];
    2729    Tcontrol_t insert_ack        [_param->_nb_rename_unit][_param->_max_nb_inst_insert];
    … …  
    136138#endif
    137139        }
    138    
     140      }   
     141    else
     142      {
     143        for (uint32_t i=0; i<_param->_nb_bank; i++)
     144          internal_BANK_INSERT_VAL  [i] = false;
     145        for (uint32_t i=0; i<_param->_nb_rename_unit; i++)
     146          for (uint32_t j=0; j<_param->_nb_inst_insert[i]; j++)
     147            PORT_WRITE(out_INSERT_ACK       [i][j],0);
     148
     149      }
     150
    139151    log_end(Commit_unit,FUNCTION);
    140152  };

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

    r122 r123  
    2424    log_function(Commit_unit,FUNCTION,_name.c_str());
    2525
     26    if (PORT_READ(in_NRESET))
     27      {
    2628    Tcontrol_t retire_val          [_param->_nb_rename_unit][_param->_max_nb_inst_retire];
    2729    uint32_t   num_inst_retire     [_param->_nb_rename_unit];
    … …  
    186188
    187189                  // if future event, don't update after this event
    188                   if (reg_EVENT_STOP [front_end_id][context_id] and
    189                       (reg_EVENT_PACKET [entry->front_end_id][entry->context_id]  == packet))
     190                  if ((reg_EVENT_STATE  [entry->front_end_id][entry->context_id] == COMMIT_EVENT_STATE_NOT_YET_EVENT) and
     191                      (reg_EVENT_PACKET [entry->front_end_id][entry->context_id] == packet))
    190192                    bypass = false;
    191193              }
    … …  
    211213          PORT_WRITE(out_SPR_WRITE_SR_OV     [i][j], spr_write_sr_ov     [i][j]);
    212214        }
     215      }
     216    else
     217      {
     218        for (uint32_t i=0; i<_param->_nb_rename_unit; i++)
     219          for (uint32_t j=0; j<_param->_nb_inst_retire[i]; j++)
     220            PORT_WRITE(out_RETIRE_VAL [i][j],0);
     221      }
    213222
    214223    log_end(Commit_unit,FUNCTION);

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

    r122 r123  
    2424    log_function(Commit_unit,FUNCTION,_name.c_str());
    2525
     26    if (PORT_READ(in_NRESET))
     27      {
    2628    // ===================================================================
    2729    // =====[ REEXECUTE ]=================================================
    … …  
    105107
    106108          internal_REEXECUTE_VAL      [i] = val;
    107           PORT_WRITE(out_REEXECUTE_VAL[i], internal_REEXECUTE_VAL [i]);
    108109        }
    109110    }
    … …  
    148149
    149150                  // don't complete a branch when rob manage an present event
    150                   if ((reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_NO_EVENT) and
     151                  if (((reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_NO_EVENT) or
     152                       (reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_NOT_YET_EVENT)) and
    151153                      (state == ROB_BRANCH_COMPLETE))
    152154                    {
    … …  
    154156
    155157                      // test if have a future event (stop is set)
    156                       log_printf(TRACE,Commit_unit,FUNCTION,"      * reg_EVENT_STOP   : %d",reg_EVENT_STOP [front_end_id][context_id]);
    157 
    158                       if (reg_EVENT_STOP [front_end_id][context_id])
     158//                       log_printf(TRACE,Commit_unit,FUNCTION,"      * reg_EVENT_STOP   : %d",reg_EVENT_STOP [front_end_id][context_id]);
     159
     160                      if (reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_NOT_YET_EVENT)
    159161                        {
    160162                          // Have future event, can complete the branch if the event is most speculative than this branchement
    … …  
    204206
    205207          internal_BRANCH_COMPLETE_VAL [i] = val;
    206           PORT_WRITE(out_BRANCH_COMPLETE_VAL [i], internal_BRANCH_COMPLETE_VAL [i]);
    207208        }
    208209    }
    … …  
    275276        }
    276277     
    277       PORT_WRITE(out_UPDATE_VAL, internal_UPDATE_VAL);
    278 
    279278      log_printf(TRACE,Commit_unit,FUNCTION,"  * UPDATE (end)");
    280279    }
    … …  
    283282    // =====[ NB_INST ]===================================================
    284283    // ===================================================================
    285     for (uint32_t i=0; i<_param->_nb_front_end; i++)
    286       for (uint32_t j=0; j<_param->_nb_context [i]; j++)
    287         {
    288           PORT_WRITE(out_NB_INST_COMMIT_ALL [i][j], reg_NB_INST_COMMIT_ALL [i][j]);
    289           PORT_WRITE(out_NB_INST_COMMIT_MEM [i][j], reg_NB_INST_COMMIT_MEM [i][j]);
    290         }
     284    {
     285#ifdef DEBUG_TEST
     286      bool empty = true;
     287#endif
     288      for (uint32_t i=0; i<_param->_nb_front_end; i++)
     289        for (uint32_t j=0; j<_param->_nb_context [i]; j++)
     290          {
     291#ifdef DEBUG_TEST
     292            empty &= (reg_NB_INST_COMMIT_ALL [i][j] == 0);
     293#endif
     294            PORT_WRITE(out_NB_INST_COMMIT_ALL [i][j], reg_NB_INST_COMMIT_ALL [i][j]);
     295            PORT_WRITE(out_NB_INST_COMMIT_MEM [i][j], reg_NB_INST_COMMIT_MEM [i][j]);
     296          }
     297#ifdef DEBUG_TEST
     298      PORT_WRITE(out_INFO_ROB_EMPTY,empty);
     299#endif
     300    }
     301
    291302
    292303    // ===================================================================
    … …  
    296307      for (uint32_t j=0; j<_param->_nb_context [i]; j++)
    297308        {
    298 //        bool flush = reg_EVENT_FLUSH [i][j];
    299           bool flush = (((reg_EVENT_STATE [i][j] == COMMIT_EVENT_STATE_EVENT) or
    300                          (reg_EVENT_STATE [i][j] == COMMIT_EVENT_STATE_WAIT_DECOD)) and
    301                         not reg_EVENT_CAN_RESTART[i][j]);
     309//           bool flush = (((reg_EVENT_STATE [i][j] == COMMIT_EVENT_STATE_EVENT) or
     310//                          (reg_EVENT_STATE [i][j] == COMMIT_EVENT_STATE_WAIT_DECOD)) and
     311//                         not reg_EVENT_CAN_RESTART[i][j]);
    302312
    303313          PORT_WRITE(out_RETIRE_EVENT_STATE [i][j], commit_event_state_to_event_state(reg_EVENT_STATE[i][j]));
    304           PORT_WRITE(out_RETIRE_EVENT_FLUSH [i][j], flush);
    305           PORT_WRITE(out_RETIRE_EVENT_STOP  [i][j], reg_EVENT_STOP [i][j]);
     314//        PORT_WRITE(out_RETIRE_EVENT_FLUSH [i][j], flush);
     315//        PORT_WRITE(out_RETIRE_EVENT_STOP  [i][j], reg_EVENT_STOP [i][j]);
     316          PORT_WRITE(out_RETIRE_EVENT_STOP  [i][j], ((reg_EVENT_STATE [i][j] == COMMIT_EVENT_STATE_NOT_YET_EVENT) or
     317                                                     reg_EVENT_NEXT_STOP [i][j]));
    306318        }
    307 
     319      }
     320    else
     321      {
     322        for (uint32_t i=0; i<_param->_nb_inst_reexecute; ++i)
     323          {
     324            internal_REEXECUTE_VAL      [i] = 0;
     325//             internal_REEXECUTE_NUM_BANK [i] = num_bank;
     326          }
     327
     328        for (uint32_t i=0; i<_param->_nb_inst_branch_complete; i++)
     329          {
     330            internal_BRANCH_COMPLETE_VAL [i] = 0;
     331//             internal_BRANCH_COMPLETE_NUM_BANK           [i] = num_bank;
     332          }
     333
     334        internal_UPDATE_VAL = 0;
     335//       internal_UPDATE_NUM_BANK = reg_NUM_BANK_HEAD;
     336
     337
     338        for (uint32_t i=0; i<_param->_nb_front_end; i++)
     339          for (uint32_t j=0; j<_param->_nb_context [i]; j++)
     340            {
     341              PORT_WRITE(out_RETIRE_EVENT_STATE [i][j], commit_event_state_to_event_state(COMMIT_EVENT_STATE_NO_EVENT));
     342//            PORT_WRITE(out_RETIRE_EVENT_FLUSH [i][j], flush);
     343//            PORT_WRITE(out_RETIRE_EVENT_STOP  [i][j], reg_EVENT_STOP [i][j]);
     344              PORT_WRITE(out_RETIRE_EVENT_STOP  [i][j], true);
     345            }
     346      }
     347
     348      for (uint32_t i=0; i<_param->_nb_inst_reexecute; ++i)
     349        PORT_WRITE(out_REEXECUTE_VAL[i], internal_REEXECUTE_VAL [i]);
     350      for (uint32_t i=0; i<_param->_nb_inst_branch_complete; i++)
     351        PORT_WRITE(out_BRANCH_COMPLETE_VAL [i], internal_BRANCH_COMPLETE_VAL [i]);
     352      PORT_WRITE(out_UPDATE_VAL, internal_UPDATE_VAL);
     353       
    308354    log_end(Commit_unit,FUNCTION);
    309355  };

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

    r122 r123  
    5353              reg_EVENT_STATE           [i][j] = COMMIT_EVENT_STATE_NO_EVENT;
    5454//            reg_EVENT_FLUSH           [i][j] = false;
    55               reg_EVENT_STOP            [i][j] = false;
     55//            reg_EVENT_STOP            [i][j] = false;
    5656              reg_EVENT_LAST            [i][j] = false;
     57
     58              reg_EVENT_NEXT_STOP       [i][j] = false;
    5759
    5860//            reg_PC_PREVIOUS           [i][j] = (0x100-4)>>2;
    … …  
    8688              //   * and decod_queue is empty
    8789              //   * and have an event or have a futur event
    88               if (not reg_EVENT_CAN_RESTART [i][j] and
    89                    (PORT_READ(in_NB_INST_DECOD_ALL [i][j]) == 0) and
    90                    (reg_EVENT_STOP [i][j] or (reg_EVENT_STATE [i][j] != COMMIT_EVENT_STATE_NO_EVENT)))
    91                 reg_EVENT_CAN_RESTART [i][j] = true;
     90//               if (not reg_EVENT_CAN_RESTART [i][j] and
     91//                    (PORT_READ(in_NB_INST_DECOD_ALL [i][j]) == 0) and
     92//                    (reg_EVENT_STOP [i][j] or (reg_EVENT_STATE [i][j] != COMMIT_EVENT_STATE_NO_EVENT)))
     93//                 reg_EVENT_CAN_RESTART [i][j] = true;
    9294
    9395              // Test event state
    … …  
    100102                      {
    101103                        // A minor optimisation : test if wait_decod is previously empty.
    102                         if (not reg_EVENT_CAN_RESTART [i][j])
    103                           reg_EVENT_STATE [i][j] = COMMIT_EVENT_STATE_WAIT_DECOD;
    104                         else
     104//                         if (not reg_EVENT_CAN_RESTART [i][j])
     105//                           reg_EVENT_STATE [i][j] = COMMIT_EVENT_STATE_WAIT_DECOD;
     106//                         else
    105107                          reg_EVENT_STATE [i][j] = COMMIT_EVENT_STATE_WAIT_END;
    106108                      }
    … …  
    108110                    break;
    109111                  }
    110                 case COMMIT_EVENT_STATE_WAIT_DECOD :
    111                   {
    112                     // Wait flush of decod_queue.
    113                     // Test if can restart now
    114                     if (reg_EVENT_CAN_RESTART [i][j])
    115                       {
    116                         //reg_EVENT_FLUSH [i][j] = false;
    117 
    118                         // A minor optimisation : test if the last element is already retire
    119                         if (not reg_EVENT_LAST [i][j])
    120                           reg_EVENT_STATE [i][j] = COMMIT_EVENT_STATE_WAIT_END;
    121                         else
    122                           reg_EVENT_STATE [i][j] = COMMIT_EVENT_STATE_END;
    123                       }
    124                     break;
    125                   }
     112//                 case COMMIT_EVENT_STATE_WAIT_DECOD :
     113//                   {
     114//                     // Wait flush of decod_queue.
     115//                     // Test if can restart now
     116//                     if (reg_EVENT_CAN_RESTART [i][j])
     117//                       {
     118//                         //reg_EVENT_FLUSH [i][j] = false;
     119
     120//                         // A minor optimisation : test if the last element is already retire
     121//                         if (not reg_EVENT_LAST [i][j])
     122//                           reg_EVENT_STATE [i][j] = COMMIT_EVENT_STATE_WAIT_END;
     123//                         else
     124//                           reg_EVENT_STATE [i][j] = COMMIT_EVENT_STATE_END;
     125//                       }
     126//                     break;
     127//                   }
    126128                case COMMIT_EVENT_STATE_WAIT_END :
    127129                  {
    … …  
    138140                   
    139141                    // flush of re order buffer is finish
    140                     reg_EVENT_STATE [i][j] = COMMIT_EVENT_STATE_NO_EVENT;
    141142                    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
    142156                    break;
    143157                  }
    144158                  //case COMMIT_EVENT_STATE_NO_EVENT :
     159                  //case COMMIT_EVENT_STATE_NOT_YET_EVENT :
    145160                default : break;
    146161                }
    … …  
    296311                      //     * or present_event
    297312                      //   * and not can_restart (previous empty decod queue), because between the event_stop (branch_complete) and the state event (miss in head), many cycle is occured.
    298                       bool flush = ((// present event
    299                                      ((reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_EVENT) or
    300                                       (reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_WAIT_DECOD)) or
    301                                      // futur event
    302                                      reg_EVENT_STOP [front_end_id][context_id])
    303                                     // can't restart
    304                                     and not reg_EVENT_CAN_RESTART[front_end_id][context_id]
    305                                     );
    306 
    307                       if (flush)
    308                         {
    309                           // A new invalid instruction is push in rob -> new last instruction
    310                           reg_EVENT_LAST          [front_end_id][context_id] = false;
    311                           reg_EVENT_LAST_NUM_BANK [front_end_id][context_id] = num_bank;
    312                           reg_EVENT_LAST_NUM_PTR  [front_end_id][context_id] = ptr;
    313                         }
     313//                       bool flush = ((// present event
     314//                                      ((reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_EVENT) or
     315//                                       (reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_WAIT_DECOD)
     316//                                       ) or
     317//                                      futur event
     318//                                      reg_EVENT_STOP [front_end_id][context_id])
     319//                                     // can't restart
     320//                                     and not reg_EVENT_CAN_RESTART[front_end_id][context_id]
     321//                                     );
     322
     323//                       if (flush)
     324//                         {
     325//                           // A new invalid instruction is push in rob -> new last instruction
     326//                           reg_EVENT_LAST          [front_end_id][context_id] = false;
     327//                           reg_EVENT_LAST_NUM_BANK [front_end_id][context_id] = num_bank;
     328//                           reg_EVENT_LAST_NUM_PTR  [front_end_id][context_id] = ptr;
     329//                         }
    314330                     
    315331                      // Update pointer
    … …  
    359375                    // find the good entry !!!
    360376                    entry_t *       entry        = internal_BANK_COMMIT_ENTRY [i][j];
     377
     378                    log_printf(TRACE,Commit_unit,FUNCTION,"    * ptr        : %d",entry->ptr);
    361379                                                 
    362380                  //Toperation_t    operation    = PORT_READ(in_COMMIT_OPERATION   [x]);
    … …  
    480498
    481499                    // Commit an instruction ...
    482                     // Test if have an event (miss_speculation or exception) and not manage a previous event
    483                     // if yes, this instruction would modify state machine. Also stop Re Order Buffer
    484 
    485 //                  bool flush = reg_EVENT_FLUSH [entry->front_end_id][entry->context_id];
    486                     bool flush = ((reg_EVENT_STATE [entry->front_end_id][entry->context_id] == COMMIT_EVENT_STATE_EVENT) or
    487                                   (reg_EVENT_STATE [entry->front_end_id][entry->context_id] == COMMIT_EVENT_STATE_WAIT_DECOD) or
    488                                   (reg_EVENT_STATE [entry->front_end_id][entry->context_id] == COMMIT_EVENT_STATE_WAIT_END));
    489                    
    490                     if ((have_exception or have_miss_speculation) and (not flush))
     500                    // Test if have an event (miss_speculation or exception)
     501
     502                    if (have_exception or have_miss_speculation)
    491503                      {
     504                        // Two case :
     505                        // if no previous manage event -> generate an event
     506                        // if    previous manage event -> next generate an event
     507
     508//                      bool flush = reg_EVENT_FLUSH [front_end_id][context_id];
     509                        bool flush = ((reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_EVENT) or
     510//                                    (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)
     513                                      );
     514                       
    492515                        uint32_t packet = ((entry->ptr << _param->_shift_num_slot) | i);
    493                        
    494                         // test have a previous event detected (event_stop = 1)
    495                         // if yes, test if the actual event if "before (in order)" that the previous event
    496                         if (reg_EVENT_STOP [entry->front_end_id][entry->context_id])
     516                        uint32_t _top   = ((_rob[ reg_NUM_BANK_HEAD].front()->ptr << _param->_shift_num_slot) | reg_NUM_BANK_HEAD);
     517                           
     518                        if (not flush)
    497519                          {
    498                             // Compare packet_id (by construction instruction is insert in order by increase packet_id)
    499 
    500                             uint32_t _top = ((_rob[ reg_NUM_BANK_HEAD].front()->ptr << _param->_shift_num_slot) | reg_NUM_BANK_HEAD);
    501                             uint32_t _old = reg_EVENT_PACKET [entry->front_end_id][entry->context_id];
    502                             uint32_t _new = packet;
    503                             if (_old < _top) _old = _old+_param->_size_queue;
    504                             if (_new < _top) _new = _new+_param->_size_queue;
    505                             if (_new < _old) reg_EVENT_PACKET [entry->front_end_id][entry->context_id] = packet;
     520                            bool     can    = true;
     521                            // test have a previous event detected (event_stop = 1)
     522                            // if yes, test if the actual event if "before (in order)" that the previous event
     523                            if (reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_NOT_YET_EVENT)
     524                              {
     525                                // Compare packet_id (by construction instruction is insert in order by increase packet_id)
     526                               
     527                                uint32_t _old = reg_EVENT_PACKET [front_end_id][context_id];
     528                                uint32_t _new = packet;
     529                                if (_old < _top) _old = _old+_param->_size_queue;
     530                                if (_new < _top) _new = _new+_param->_size_queue;
     531                                if (_new < _old) reg_EVENT_PACKET [front_end_id][context_id] = packet;
     532                                else can = false;
     533                              }
     534                            else
     535                              reg_EVENT_PACKET [front_end_id][context_id] = packet;
     536                           
     537                            if (can)
     538                              {
     539                                // have an error, stop issue instruction
     540                                reg_EVENT_STATE         [front_end_id][context_id] = COMMIT_EVENT_STATE_NOT_YET_EVENT;
     541                                //                      reg_EVENT_STOP          [front_end_id][context_id] = true;
     542                               
     543                                reg_EVENT_LAST_NUM_BANK [front_end_id][context_id] = ((reg_NUM_BANK_TAIL==0)?_param->_nb_bank:reg_NUM_BANK_TAIL)-1;
     544                                reg_EVENT_LAST_NUM_PTR  [front_end_id][context_id] = reg_NUM_PTR_TAIL;
     545                              }
    506546                          }
    507547                        else
    508                           reg_EVENT_PACKET [entry->front_end_id][entry->context_id] = packet;
    509                        
    510                         // have an error, stop issue instruction
    511                         reg_EVENT_STOP          [entry->front_end_id][entry->context_id] = true;
    512 //                         reg_EVENT_NUM_BANK      [entry->front_end_id][entry->context_id] = i;
    513 //                         reg_EVENT_NUM_PTR       [entry->front_end_id][entry->context_id] = entry->ptr;
    514 
    515 //                      reg_EVENT_CAN_RESTART   [entry->front_end_id][entry->context_id] = false;
    516                         reg_EVENT_LAST_NUM_BANK [entry->front_end_id][entry->context_id] = ((reg_NUM_BANK_TAIL==0)?_param->_nb_bank:reg_NUM_BANK_TAIL)-1;
    517                         reg_EVENT_LAST_NUM_PTR  [entry->front_end_id][entry->context_id] = reg_NUM_PTR_TAIL;
     548                          {
     549                            bool find = true;
     550
     551                            // already manage an event.
     552                            if (reg_EVENT_NEXT_STOP [front_end_id][context_id])
     553                              {
     554                                // after last ?
     555                                uint32_t _old = reg_EVENT_NEXT_PACKET [front_end_id][context_id];
     556                                uint32_t _new = packet;
     557                                if (_old < _top) _old = _old+_param->_size_queue;
     558                                if (_new < _top) _new = _new+_param->_size_queue;
     559                                if (_new > _old) reg_EVENT_NEXT_PACKET [front_end_id][context_id] = packet;
     560                                find = false;
     561                              }
     562                            else
     563                              {
     564                                // after last ?
     565                                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]);
     566                                uint32_t _new = packet;
     567                                if (_old < _top) _old = _old+_param->_size_queue;
     568                                if (_new < _top) _new = _new+_param->_size_queue;
     569                                if (_new > _old) reg_EVENT_NEXT_PACKET [front_end_id][context_id] = packet;
     570                                find = false;
     571                              }
     572
     573                            if (find)
     574                            reg_EVENT_NEXT_STOP [front_end_id][context_id] = true; // in all case : need stop
     575                          }
    518576                      }
    519                    
     577
    520578                    // Update Re Order Buffer
    521579                    entry->state        = state;
    … …  
    633691                      {
    634692                          reg_EVENT_STATE         [front_end_id][context_id] = COMMIT_EVENT_STATE_EVENT;
    635 //                        reg_EVENT_FLUSH         [front_end_id][context_id] = true;
    636                           reg_EVENT_STOP          [front_end_id][context_id] = false; // instruction flow can continue
    637 //                        reg_EVENT_CAN_RESTART   [front_end_id][context_id] = false;
     693//                        reg_EVENT_STOP          [front_end_id][context_id] = false; // instruction flow can continue
    638694                          reg_EVENT_LAST          [front_end_id][context_id] = false;
    639695                          // it the head !
    640696                          reg_EVENT_PACKET        [front_end_id][context_id] = packet_id;
    641697                   
    642                           // If event is an load_miss, many instruction can be inserted.
    643                           // -> new last instruction
    644                           if (state == ROB_END_LOAD_MISS)
    645                             {
    646                             reg_EVENT_CAN_RESTART   [front_end_id][context_id] = false;
     698//                           // If event is an load_miss, many instruction can be inserted.
     699//                           // -> new last instruction
     700//                           if (state == ROB_END_LOAD_MISS)
     701//                             {
     702// //                             reg_EVENT_CAN_RESTART   [front_end_id][context_id] = false;
    647703                           
    648                             reg_EVENT_LAST_NUM_BANK [front_end_id][context_id] = ((reg_NUM_BANK_TAIL==0)?_param->_nb_bank:reg_NUM_BANK_TAIL)-1;
    649                             reg_EVENT_LAST_NUM_PTR  [front_end_id][context_id] = reg_NUM_PTR_TAIL;
    650                             }
     704//                             reg_EVENT_LAST_NUM_BANK [front_end_id][context_id] = ((reg_NUM_BANK_TAIL==0)?_param->_nb_bank:reg_NUM_BANK_TAIL)-1;
     705//                             reg_EVENT_LAST_NUM_PTR  [front_end_id][context_id] = reg_NUM_PTR_TAIL;
     706//                             }
    651707                        }
    652708                   
    … …  
    654710                    //   * need event
    655711                    //   * packet id = last packet id
    656                     if ((reg_EVENT_STATE         [front_end_id][context_id] != COMMIT_EVENT_STATE_NO_EVENT) and
     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
    657714                        (reg_EVENT_LAST_NUM_BANK [front_end_id][context_id] == num_bank            ) and
    658715                        (reg_EVENT_LAST_NUM_PTR  [front_end_id][context_id] == entry->ptr          ))
    … …  
    666723                    // Update pointer
    667724                    reg_NUM_BANK_HEAD = (num_bank+1)%_param->_nb_bank;
    668                    
    669                     // Remove entry
    670                     delete entry;
    671                     _rob [num_bank].pop_front();
    672725                   
    673726                    // Reset watch dog timer because have transaction on retire interface
    … …  
    708761                    }
    709762#endif     
     763
     764                    // Remove entry
     765                    delete entry;
     766                    _rob [num_bank].pop_front();
    710767                  }
    711768              }
    … …  
    775832              if (miss)
    776833                {
     834                  bool     can    = true;
    777835                  uint32_t packet = ((entry->ptr << _param->_shift_num_slot) | num_bank);
    778836                     
    779837                  // test if this packet is before previous event
    780                   if (reg_EVENT_STOP [entry->front_end_id][entry->context_id])
     838                  if (reg_EVENT_STATE [entry->front_end_id][entry->context_id] == COMMIT_EVENT_STATE_NOT_YET_EVENT)
    781839                    {
    782840                      uint32_t _top = ((_rob[ reg_NUM_BANK_HEAD].front()->ptr << _param->_shift_num_slot) | reg_NUM_BANK_HEAD);
    … …  
    786844                      if (_new < _top) _new = _new+_param->_size_queue;
    787845                      if (_new < _old) reg_EVENT_PACKET [entry->front_end_id][entry->context_id] = packet;
     846                      else can = false;
    788847                    }
    789848                  else
    790849                    reg_EVENT_PACKET [entry->front_end_id][entry->context_id] = packet;
    791850
    792                   // In all case, stop instruction flow
    793                   reg_EVENT_STOP          [entry->front_end_id][entry->context_id] = true;
    794 //                   reg_EVENT_NUM_BANK      [entry->front_end_id][entry->context_id] = num_bank;
    795 //                   reg_EVENT_NUM_PTR       [entry->front_end_id][entry->context_id] = entry->ptr;
    796 
    797                   reg_EVENT_CAN_RESTART   [entry->front_end_id][entry->context_id] = false;
    798 
    799                   reg_EVENT_LAST_NUM_BANK [entry->front_end_id][entry->context_id] = ((reg_NUM_BANK_TAIL==0)?_param->_nb_bank:reg_NUM_BANK_TAIL)-1;
    800                   reg_EVENT_LAST_NUM_PTR  [entry->front_end_id][entry->context_id] = reg_NUM_PTR_TAIL;
     851                  if (can)
     852                    {
     853                      // In all case, stop instruction flow
     854                      reg_EVENT_STATE         [entry->front_end_id][entry->context_id] = COMMIT_EVENT_STATE_NOT_YET_EVENT;
     855//                    reg_EVENT_STOP          [entry->front_end_id][entry->context_id] = true;
     856
     857//                    reg_EVENT_CAN_RESTART   [entry->front_end_id][entry->context_id] = false;
     858
     859                      reg_EVENT_LAST_NUM_BANK [entry->front_end_id][entry->context_id] = ((reg_NUM_BANK_TAIL==0)?_param->_nb_bank:reg_NUM_BANK_TAIL)-1;
     860                      reg_EVENT_LAST_NUM_PTR  [entry->front_end_id][entry->context_id] = reg_NUM_PTR_TAIL;
     861                    }
    801862                }
    802863            }
    … …  
    902963                     
    903964                      bool         flush         = ((reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_EVENT) or
    904                                                     (reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_WAIT_DECOD) or
     965//                                                  (reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_WAIT_DECOD) or
    905966                                                    (reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_WAIT_END));
    906967                      bool         speculative   = entry->speculative and not (depth == depth_min);
    … …  
    10051066                     
    10061067                      // Test if this instruction is the last of event
    1007                       if ((reg_EVENT_STATE         [front_end_id][context_id] != COMMIT_EVENT_STATE_NO_EVENT) and
     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
    10081070                          (reg_EVENT_LAST_NUM_BANK [front_end_id][context_id] == num_bank            ) and
    10091071                          (reg_EVENT_LAST_NUM_PTR  [front_end_id][context_id] == entry->ptr          ))
    … …  
    10441106            log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_STATE       : %s - %s",toString(reg_EVENT_STATE [i][j]).c_str(),toString(commit_event_state_to_event_state(reg_EVENT_STATE [i][j])).c_str());
    10451107//          log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_FLUSH       : %d",reg_EVENT_FLUSH [i][j]);
    1046             log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_STOP        : %d",reg_EVENT_STOP  [i][j]);
    1047 //             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]);
    1048             log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_CAN_RESTART : %d",reg_EVENT_CAN_RESTART [i][j]);
     1108//          log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_STOP        : %d",reg_EVENT_STOP  [i][j]);
     1109//          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]);
     1110//          log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_CAN_RESTART : %d",reg_EVENT_CAN_RESTART [i][j]);
    10491111            log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_PACKET      : %d",reg_EVENT_PACKET[i][j]);
    10501112            log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_LAST        : %d",reg_EVENT_LAST [i][j]);
    10511113            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]);
    10521116            log_printf(TRACE,Commit_unit,FUNCTION,"      * NB_INST_ALL       : %d",reg_NB_INST_COMMIT_ALL[i][j]);
    10531117            log_printf(TRACE,Commit_unit,FUNCTION,"      * NB_INST_MEM       : %d",reg_NB_INST_COMMIT_MEM[i][j]);
    … …  
    10651129        }
    10661130
    1067       bool all_empty = false;
     1131      bool     all_empty   = false;
     1132      uint32_t nb_write_rd = 0;
     1133      uint32_t nb_write_re = 0;
     1134
    10681135      while (not all_empty)
    10691136        {
    … …  
    10781145                {
    10791146                  all_empty = false;
     1147
     1148                  nb_write_rd += ((*it)->write_rd)?1:0;
     1149                  nb_write_re += ((*it)->write_re)?1:0;
    10801150
    10811151                  log_printf(TRACE,Commit_unit,FUNCTION,"        [%.4d][%.4d] (%.4d) %.4d %.4d %.4d %.4d, %.3d %.3d, %.1d, %.1d %.4d, %.1d %.4d, %s",
    … …  
    11301200            }
    11311201        }
     1202
     1203      log_printf(TRACE,Commit_unit,FUNCTION,"    * nb_write_rd   : %d",nb_write_rd);
     1204      log_printf(TRACE,Commit_unit,FUNCTION,"    * nb_write_re   : %d",nb_write_re);
    11321205    }
    11331206#endif

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

    r111 r123  
    3939    usage_environment(_usage);
    4040
    41 #if DEBUG_Issue_queue == true
    42     log_printf(INFO,Issue_queue,FUNCTION,_("<%s> Parameters"),_name.c_str());
     41// #if DEBUG_Issue_queue == true
     42//     log_printf(INFO,Issue_queue,FUNCTION,_("<%s> Parameters"),_name.c_str());
    4343
    44     std::cout << *param << std::endl;
    45 #endif   
     44//     std::cout << *param << std::endl;
     45// #endif   
    4646
    4747    log_printf(INFO,Issue_queue,FUNCTION,_("<%s> : Allocation"),_name.c_str());

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

    r122 r123  
    2424    log_function(Issue_queue,FUNCTION,_name.c_str());
    2525
     26    if (PORT_READ(in_NRESET))
    2627    // ===================================================================
    2728    // =====[ ISSUE_OUT ]=================================================
    2829    // ===================================================================
    29     {
     30      {
    3031      Tcontrol_t val [_param->_nb_inst_issue];
    3132
    … …  
    175176        }
    176177    }
     178    else
     179      {
     180      for (uint32_t i=0; i<_param->_nb_inst_issue; i++)
     181        internal_ISSUE_OUT_VAL [i] = 0;
     182      }
     183
     184    for (uint32_t i=0; i<_param->_nb_inst_issue; i++)
     185      PORT_WRITE(out_ISSUE_OUT_VAL [i], internal_ISSUE_OUT_VAL [i]);
    177186
    178187    log_end(Issue_queue,FUNCTION);

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

    r111 r123  
    3838          internal_ISSUE_IN_ACK [i][j] = false;
    3939
     40      if (PORT_READ(in_NRESET))
     41        {
    4042      std::list<generic::priority::select_t> * select_in = _priority_in ->select(); // same select for all issue
    4143      std::list<generic::priority::select_t>::iterator it=select_in ->begin();
    … …  
    6264          nb_insert ++;
    6365        }
    64      
     66        }
     67
    6568      for (uint32_t i=0; i<_param->_nb_rename_unit; i++)
    6669        for (uint32_t j=0; j<_param->_nb_inst_rename[i]; j++)

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

    r122 r123  
    2424    log_function(Issue_queue,FUNCTION,_name.c_str());
    2525
     26    if (PORT_READ(in_NRESET))
     27      {
    2628    // ===================================================================
    2729    // =====[ REEXECUTE_UNIT ]============================================
    … …  
    217219        {
    218220          internal_ISSUE_OUT_VAL [i] = val [i];
     221        }
     222    }
     223      }
     224    else
     225      {
     226        // Reset
     227        for (uint32_t i=0; i<_param->_nb_bank; i++)
     228          {
     229            internal_BANK_IN_ACK  [i] = 0;
     230//             internal_BANK_IN_NUM_RENAME_UNIT [num_bank] = num_rename_unit;
     231//             internal_BANK_IN_NUM_INST        [num_bank] = num_inst_rename;
     232          }
     233        for (uint32_t i=0; i<_param->_nb_rename_unit; i++)
     234          for (uint32_t j=0; j<_param->_nb_inst_rename[i]; j++)
     235            PORT_WRITE(out_ISSUE_IN_ACK [i][j],0);
     236
     237          for (uint32_t i=0; i<_param->_nb_inst_issue; i++)
     238            {
     239              internal_ISSUE_OUT_VAL [i] = 0;
     240//            internal_ISSUE_OUT_FROM_REEXECUTE [i] = true;
     241//            internal_ISSUE_OUT_NUM_BANK       [i] = num_bank;
     242//            internal_ISSUE_OUT_ENTRY          [i] = entry;
     243            }
     244      }
     245
     246    // Write output
     247      for (uint32_t i=0; i<_param->_nb_inst_issue; i++)
     248        {
    219249          PORT_WRITE(out_ISSUE_OUT_VAL [i], internal_ISSUE_OUT_VAL [i]);
    220250        }
    221     }
    222251
    223252    log_end(Issue_queue,FUNCTION);

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

    r111 r123  
    2424    log_function(Issue_queue,FUNCTION,_name.c_str());
    2525
     26    if (PORT_READ(in_NRESET))
     27      {
    2628    // ===================================================================
    2729    // =====[ REEXECUTE_UNIT ]============================================
    … …  
    3537
    3638        log_printf(TRACE,Issue_queue,FUNCTION,"    * ACK : %d",internal_REEXECUTE_ACK [i]);
     39      }
    3740
    38         PORT_WRITE(out_REEXECUTE_ACK [i], internal_REEXECUTE_ACK [i]);
    3941      }
     42    else
     43      {
     44        // Reset
     45        for (uint32_t i=0; i<_param->_nb_inst_reexecute; ++i)
     46          internal_REEXECUTE_ACK [i] = 0;
     47      }
     48
     49    // Write Output
     50    for (uint32_t i=0; i<_param->_nb_inst_reexecute; ++i)
     51      PORT_WRITE(out_REEXECUTE_ACK [i], internal_REEXECUTE_ACK [i]);
    4052
    4153    (this->*function_genMoore) ();

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

    r122 r123  
    3939    usage_environment(_usage);
    4040
    41 #if DEBUG_OOO_Engine_Glue == true
    42     log_printf(INFO,OOO_Engine_Glue,FUNCTION,_("<%s> Parameters"),_name.c_str());
    43 
    44     std::cout << *param << std::endl;
    45 #endif   
     41// #if DEBUG_OOO_Engine_Glue == true
     42//     log_printf(INFO,OOO_Engine_Glue,FUNCTION,_("<%s> Parameters"),_name.c_str());
     43
     44//     std::cout << *param << std::endl;
     45// #endif   
    4646
    4747    log_printf(INFO,OOO_Engine_Glue,FUNCTION,_("<%s> : Allocation"),_name.c_str());

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

    r122 r123  
    2424    log_function(OOO_Engine_Glue,FUNCTION,_name.c_str());
    2525
     26    if (PORT_READ(in_NRESET))
     27      {
    2628    uint32_t x=0;
    2729    for (uint32_t i=0; i<_param->_nb_rename_unit; ++i)
    … …  
    112114          x ++;
    113115        }
     116      }
     117//     else
     118//       {
     119//       }
    114120
    115121    log_end(OOO_Engine_Glue,FUNCTION);

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

    r110 r123  
    2424    log_function(OOO_Engine_Glue,FUNCTION,_name.c_str());
    2525
     26    if (PORT_READ(in_NRESET))
     27      {
    2628    uint32_t x=0;
    2729    for (uint32_t i=0; i<_param->_nb_rename_unit; ++i)
    … …  
    7981          }
    8082      }
     83      }
     84    else
     85      {
     86        uint32_t x=0;
     87        for (uint32_t i=0; i<_param->_nb_rename_unit; ++i)
     88          for (uint32_t j=0; j<_param->_nb_inst_insert[i]; ++j)
     89            {
     90              PORT_WRITE(out_INSERT_VAL             [x]   ,0);
     91              PORT_WRITE(out_INSERT_RENAME_UNIT_ACK [i][j],0);
     92              PORT_WRITE(out_INSERT_COMMIT_UNIT_VAL [i][j],0);
     93              PORT_WRITE(out_INSERT_ISSUE_QUEUE_VAL [i][j],0);
     94              x ++;
     95            }
     96      }
    8197   
    8298    log_end(OOO_Engine_Glue,FUNCTION);

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

    r120 r123  
    2424    log_function(OOO_Engine_Glue,FUNCTION,_name.c_str());
    2525
     26    if (PORT_READ(in_NRESET))
     27      {
    2628    for (uint32_t i=0; i<_param->_nb_front_end; ++i)
    2729      for (uint32_t j=0; j<_param->_nb_inst_decod[i]; ++j)
    … …  
    3032          PORT_WRITE(out_RENAME_RENAME_UNIT_FRONT_END_ID [i][j],_param->_translate_front_end_id_to_rename_unit [PORT_READ(in_RENAME_FRONT_END_ID [i][j])]);
    3133        }
     34      }
    3235
    3336    log_end(OOO_Engine_Glue,FUNCTION);

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

    r88 r123  
    2424    log_function(OOO_Engine_Glue,FUNCTION,_name.c_str());
    2525
     26    if (PORT_READ(in_NRESET))
     27      {
    2628    uint32_t x=0;
    2729    for (uint32_t i=0; i<_param->_nb_rename_unit; ++i)
    … …  
    6163          x ++;
    6264        }
    63 
     65}
    6466    log_end(OOO_Engine_Glue,FUNCTION);
    6567  };

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

    r88 r123  
    2424    log_function(OOO_Engine_Glue,FUNCTION,_name.c_str());
    2525
     26    if (PORT_READ(in_NRESET))
     27      {
    2628    uint32_t x=0;
    2729    for (uint32_t i=0; i<_param->_nb_rename_unit; ++i)
    … …  
    4749          x ++;
    4850        }
    49    
     51}   
    5052    log_end(OOO_Engine_Glue,FUNCTION);
    5153  };

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

    r88 r123  
    2424    log_begin(OOO_Engine_Glue,FUNCTION);
    2525
     26//     if (PORT_READ(in_NRESET))
     27      {
    2628    for (uint32_t i=0; i<_param->_nb_front_end; ++i)
    2729      for (uint32_t j=0; j<_param->_nb_context[i]; ++j)
    … …  
    3840          delete sr;
    3941        }
     42      }
    4043
    4144    log_end(OOO_Engine_Glue,FUNCTION);

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

    r88 r123  
    3939    usage_environment(_usage);
    4040
    41 #if DEBUG_Reexecute_unit == true
    42     log_printf(INFO,Reexecute_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
     41// #if DEBUG_Reexecute_unit == true
     42//     log_printf(INFO,Reexecute_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
    4343
    44     std::cout << *param << std::endl;
    45 #endif   
     44//     std::cout << *param << std::endl;
     45// #endif   
    4646
    4747    log_printf(INFO,Reexecute_unit,FUNCTION,_("<%s> : Allocation"),_name.c_str());

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

    r117 r123  
    2323    log_function(Reexecute_unit,FUNCTION,_name.c_str());
    2424
     25    if (PORT_READ(in_NRESET))
     26      {
    2527    // Initialisation
    2628    Tcontrol_t execute_loop_ack [_param->_nb_execute_loop][_param->_max_nb_inst_execute];
    … …  
    126128      for (uint32_t j=0; j<_param->_nb_inst_execute [i]; ++j)
    127129        PORT_WRITE(out_EXECUTE_LOOP_ACK [i][j], execute_loop_ack [i][j]);
     130      }
     131    else
     132      {
     133#ifdef STATISTICS
     134        for (uint32_t i=0; i<_param->_nb_inst_commit; ++i)
     135          internal_COMMIT_VAL [i] = 0;
     136#endif
     137        for (uint32_t i=0; i<_param->_nb_execute_loop; ++i)
     138          for (uint32_t j=0; j<_param->_nb_inst_execute [i]; ++j)
     139            PORT_WRITE(out_EXECUTE_LOOP_ACK [i][j], 0);
     140      }
    128141
    129142    log_end(Reexecute_unit,FUNCTION);

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

    r122 r123  
    2424    log_function(Reexecute_unit,FUNCTION,_name.c_str());
    2525
     26    if (PORT_READ(in_NRESET))
     27      {
    2628    // ===================================================================
    2729    // =====[ REEXECUTE ]=================================================
    … …  
    9496        internal_REEXECUTE_VAL     [i] = val;
    9597        internal_REEXECUTE_ROB_ACK [i] = ack;
     98      }
     99      }
     100    else
     101      {
     102        for (uint32_t i=0; i<_param->_nb_inst_reexecute; i++)
     103          {
     104            internal_REEXECUTE_VAL     [i] = 0;
     105            internal_REEXECUTE_ROB_ACK [i] = 0;
     106          }
     107      }
    96108
     109    for (uint32_t i=0; i<_param->_nb_inst_reexecute; i++)
     110      {
    97111        PORT_WRITE(out_REEXECUTE_VAL     [i], internal_REEXECUTE_VAL     [i]);
    98112        PORT_WRITE(out_REEXECUTE_ROB_ACK [i], internal_REEXECUTE_ROB_ACK [i]);
    99113      }
    100 
    101114    log_end(Reexecute_unit,FUNCTION);
    102115  };

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

    r98 r123  
    2424    log_function(Reexecute_unit,FUNCTION,_name.c_str());
    2525
     26    if (PORT_READ(in_NRESET))
     27      {
    2628    // ===================================================================
    2729    // =====[ SPR ]=======================================================
    … …  
    4749
    4850        internal_SPR_VAL [i] = val;
     51      }
     52      }
     53    else
     54      {
     55        //Reset
     56        for (uint32_t i=0; i<_param->_nb_inst_reexecute; i++)
     57          internal_SPR_VAL [i] = 0;
     58      }
     59
     60    // Write output
     61    for (uint32_t i=0; i<_param->_nb_inst_reexecute; i++)
     62      {
    4963        PORT_WRITE(out_SPR_VAL [i], internal_SPR_VAL [i]);
    5064      }

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

    r122 r123  
    3838    log_printf(FUNC,Load_Store_pointer_unit,FUNCTION,"Begin");
    3939
    40 #if DEBUG_Load_Store_pointer_unit == true
    41     log_printf(INFO,Load_Store_pointer_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
    42 
    43     std::cout << *param << std::endl;
    44 #endif   
     40// #if DEBUG_Load_Store_pointer_unit == true
     41//     log_printf(INFO,Load_Store_pointer_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
     42
     43//     std::cout << *param << std::endl;
     44// #endif   
    4545
    4646    log_printf(INFO,Load_Store_pointer_unit,FUNCTION,"Allocation");

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Load_Store_pointer_unit/src/Load_Store_pointer_unit_genMealy_insert.cpp

    r122 r123  
    2525    log_function(Load_Store_pointer_unit,FUNCTION,_name.c_str());
    2626
     27    if (PORT_READ(in_NRESET))
     28      {
    2729    // TODO : limité à nb_inst_memory le nombre d'accès par lsq !!!
    2830
    … …  
    134136        // Write output
    135137        internal_INSERT_ACK [i] = ack;
    136         PORT_WRITE(out_INSERT_ACK                   [i], ack);
    137138      }
     139      }
     140    else
     141      {
     142        for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
     143          internal_INSERT_ACK [i] = 0;
     144
     145      }
     146   
     147    for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
     148      PORT_WRITE(out_INSERT_ACK [i], internal_INSERT_ACK [i]);
    138149
    139150    log_end(Load_Store_pointer_unit,FUNCTION);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Load_Store_pointer_unit/src/Load_Store_pointer_unit_genMealy_retire.cpp

    r110 r123  
    2424    log_printf(FUNC,Load_Store_pointer_unit,FUNCTION,"Begin");
    2525   
     26    if (PORT_READ(in_NRESET))
     27      {
    2628//     bool use_lsq [_param->_nb_load_store_queue];
    2729//     for (uint32_t i=0; i<_param->_nb_load_store_queue; i++)
    … …  
    7779        // Write output
    7880        internal_RETIRE_ACK [i] = ack;
    79         PORT_WRITE(out_RETIRE_ACK                   [i], ack);
    8081      }
     82      }
     83    else
     84      {
     85        for (uint32_t i=0; i<_param->_nb_inst_retire; i++)
     86          internal_RETIRE_ACK [i] = 0;
     87      }
     88
     89    for (uint32_t i=0; i<_param->_nb_inst_retire; i++)
     90      PORT_WRITE(out_RETIRE_ACK [i], internal_RETIRE_ACK [i]);
     91
    8192   
    8293    log_printf(FUNC,Load_Store_pointer_unit,FUNCTION,"End");

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Dependency_checking_unit/src/Dependency_checking_unit.cpp

    r121 r123  
    3939    log_printf(FUNC,Dependency_checking_unit,FUNCTION,"Begin");
    4040
    41 #if DEBUG_Dependency_checking_unit == true
    42     log_printf(INFO,Dependency_checking_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
    43 
    44     std::cout << *param << std::endl;
    45 #endif   
     41// #if DEBUG_Dependency_checking_unit == true
     42//     log_printf(INFO,Dependency_checking_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
     43
     44//     std::cout << *param << std::endl;
     45// #endif   
    4646
    4747    log_printf(INFO,Dependency_checking_unit,FUNCTION,"Allocation");

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Dependency_checking_unit/src/Dependency_checking_unit_genMealy.cpp

    r121 r123  
    2626    log_function(Dependency_checking_unit,FUNCTION,_name.c_str());
    2727
     28    if (PORT_READ(in_NRESET))
     29      {
    2830//     Tcontrol_t         val                [_param->_nb_inst_insert];
    2931//     Tcontrol_t         ack                [_param->_nb_inst_insert];
    … …  
    223225        PORT_WRITE(out_RENAME_OUT_NUM_REG_RE_PHY_NEW [i], num_reg_re_phy_new [i]);
    224226      }
     227      }
    225228
    226229    log_end(Dependency_checking_unit,FUNCTION);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Free_List_unit/include/Free_List_unit.h

    r110 r123  
    9191  public    : SC_IN (Tspecial_address_t)   **  in_PUSH_SPR_NUM_REG;
    9292
     93    // ~~~~~[ interface : "info" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     94#ifdef DEBUG_TEST
     95  public    : SC_OUT(uint32_t  )            * out_INFO_NB_GPR_FREE;
     96  public    : SC_OUT(uint32_t  )            * out_INFO_NB_SPR_FREE;
     97#endif
     98
    9399    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    94100  private   : generic::priority::Priority   * _priority_gpr;
    … …  
    141147#ifdef SYSTEMC                                 
    142148  public  : void        transition                (void);
     149#ifdef DEBUG_TEST
     150  public  : void        genMoore                  (void);
     151#endif
    143152  public  : void        genMealy_pop              (void);
    144153  public  : void        genMealy_push_gpr         (void);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Free_List_unit/src/Free_List_unit.cpp

    r110 r123  
    3939    log_printf(FUNC,Free_List_unit,FUNCTION,"Begin");
    4040
    41 #if DEBUG_Free_List_unit == true
    42     log_printf(INFO,Free_List_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
     41// #if DEBUG_Free_List_unit == true
     42//     log_printf(INFO,Free_List_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
    4343
    44     std::cout << *param << std::endl;
    45 #endif   
     44//     std::cout << *param << std::endl;
     45// #endif   
    4646
    4747    log_printf(INFO,Free_List_unit,FUNCTION,"Allocation");
    … …  
    8585# endif   
    8686
     87#ifdef DEBUG_TEST
     88        log_printf(INFO,Free_List_unit,FUNCTION,"Method - genMoore");
     89
     90        SC_METHOD (genMoore);
     91        dont_initialize ();
     92        sensitive << (*(in_CLOCK)).neg();
     93       
     94# ifdef SYSTEMCASS_SPECIFIC
     95        // List dependency information
     96# endif   
     97#endif
    8798        log_printf(INFO,Free_List_unit,FUNCTION,"Method - genMealy_pop");
    8899

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Free_List_unit/src/Free_List_unit_allocation.cpp

    r112 r123  
    9292     }
    9393
     94    // ~~~~~[ interface : "info" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     95#ifdef DEBUG_TEST
     96     {
     97       ALLOC0_INTERFACE_BEGIN("info",OUT, NORTH, _("Information"));
     98
     99       ALLOC0_SIGNAL_OUT(out_INFO_NB_GPR_FREE,"nb_gpr_free",uint32_t,_param->_size_general_register+1);
     100       ALLOC0_SIGNAL_OUT(out_INFO_NB_SPR_FREE,"nb_spr_free",uint32_t,_param->_size_special_register+1);
     101
     102       ALLOC0_INTERFACE_END();
     103     }
     104#endif
     105
    94106     if (usage_is_set(_usage,USE_SYSTEMC))
    95107       {

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Free_List_unit/src/Free_List_unit_deallocation.cpp

    r112 r123  
    4545        DELETE1_SIGNAL( in_PUSH_SPR_NUM_REG,_param->_nb_push,_param->_size_special_register);
    4646
     47#ifdef DEBUG_TEST
     48        DELETE0_SIGNAL(out_INFO_NB_GPR_FREE,_param->_size_general_register+1);
     49        DELETE0_SIGNAL(out_INFO_NB_SPR_FREE,_param->_size_special_register+1);
     50#endif
     51
    4752        DELETE1(_gpr_list             ,_param->_nb_bank);
    4853        DELETE1(_spr_list             ,_param->_nb_bank);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Free_List_unit/src/Free_List_unit_genMealy_pop.cpp

    r109 r123  
    2626    log_function(Free_List_unit,FUNCTION,_name.c_str());
    2727
     28    if (PORT_READ(in_NRESET))
     29      {
    2830    std::list<generic::priority::select_t> * select_gpr = _priority_gpr->select();
    2931    std::list<generic::priority::select_t>::iterator it_gpr=select_gpr->begin();
    … …  
    3234    std::list<generic::priority::select_t>::iterator it_spr=select_spr->begin();
    3335
    34     for (uint32_t i=0; i<_param->_nb_pop; i++)
     36     for (uint32_t i=0; i<_param->_nb_pop; i++)
    3537      {
    3638        log_printf(TRACE,Free_List_unit,FUNCTION,"  * POP [%d]",i);
    … …  
    104106
    105107        internal_POP_ACK [i] = gpr_ack and spr_ack;
    106         PORT_WRITE(out_POP_ACK [i], internal_POP_ACK [i]);
    107108      }
    108109
    … …  
    177178//      PORT_WRITE(out_POP_ACK [i], internal_POP_ACK [i]);
    178179//       }
    179    
     180      }   
     181    else
     182      {
     183        for (uint32_t i=0; i<_param->_nb_pop; i++)
     184          internal_POP_ACK [i] = 0;
     185      }
     186
     187    for (uint32_t i=0; i<_param->_nb_pop; i++)
     188      PORT_WRITE(out_POP_ACK [i], internal_POP_ACK [i]);
     189
    180190
    181191    log_end(Free_List_unit,FUNCTION);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Free_List_unit/src/Free_List_unit_genMealy_push_gpr.cpp

    r108 r123  
    2626    log_function(Free_List_unit,FUNCTION,_name.c_str());
    2727
     28    if (PORT_READ(in_NRESET))
     29      {
    2830    // bank conflit
    2931    bool bank_use [_param->_nb_bank];
    … …  
    5961
    6062        internal_PUSH_GPR_ACK [i] = gpr_ack;
    61         PORT_WRITE(out_PUSH_GPR_ACK [i], internal_PUSH_GPR_ACK [i]);
    6263      }
     64      }
     65    else
     66      {
     67        for (uint32_t i=0; i<_param->_nb_push; i++)
     68          internal_PUSH_GPR_ACK [i] = 0;
     69      }
     70
     71    for (uint32_t i=0; i<_param->_nb_push; i++)
     72      PORT_WRITE(out_PUSH_GPR_ACK [i], internal_PUSH_GPR_ACK [i]);
    6373   
    6474    log_end(Free_List_unit,FUNCTION);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Free_List_unit/src/Free_List_unit_genMealy_push_spr.cpp

    r108 r123  
    2626    log_function(Free_List_unit,FUNCTION,_name.c_str());
    2727
     28    if (PORT_READ(in_NRESET))
     29      {
    2830    bool bank_use [_param->_nb_bank];
    2931    for (uint32_t i=0; i<_param->_nb_bank; i++)
    … …  
    5153
    5254        internal_PUSH_SPR_ACK [i] = spr_ack;
    53         PORT_WRITE(out_PUSH_SPR_ACK [i], internal_PUSH_SPR_ACK [i]);
    5455      }
    55    
     56      }
     57    else
     58      {
     59        for (uint32_t i=0; i<_param->_nb_push; i++)
     60          internal_PUSH_SPR_ACK [i] = 0;
     61      }
     62
     63    for (uint32_t i=0; i<_param->_nb_push; i++)
     64      PORT_WRITE(out_PUSH_SPR_ACK [i], internal_PUSH_SPR_ACK [i]);
     65
    5666    log_end(Free_List_unit,FUNCTION);
    5767  };

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_Address_Translation_unit/src/Register_Address_Translation_unit.cpp

    r122 r123  
    3939    log_printf(FUNC,Register_Address_Translation_unit,FUNCTION,"Begin");
    4040
    41 #if DEBUG_Register_Address_Translation_unit == true
    42     log_printf(INFO,Register_Address_Translation_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
    43 
    44     std::cout << *param << std::endl;
    45 #endif   
     41// #if DEBUG_Register_Address_Translation_unit == true
     42//     log_printf(INFO,Register_Address_Translation_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
     43
     44//     std::cout << *param << std::endl;
     45// #endif   
    4646
    4747    log_printf(INFO,Register_Address_Translation_unit,FUNCTION,"Allocation");

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_Address_Translation_unit/src/Register_Address_Translation_unit_genMealy_rename.cpp

    r122 r123  
    2929    for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
    3030      if (PORT_READ(in_RENAME_VAL [i])) // not in sensitive list : it's to have valide value to array access
    31       {
     31        {
    3232        log_printf(TRACE,Register_Address_Translation_unit,FUNCTION,"  * RENAME [%d]",i);
    3333

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_Address_Translation_unit/src/Register_Address_Translation_unit_transition.cpp

    r122 r123  
    4040                {
    4141                  rat_gpr_not_speculative    [i][j][k] = gpr++;
    42 //                rat_gpr_speculative        [i][j][k] = gpr++;
    4342                  rat_gpr_speculative_valid  [i][j][k] = false;
    44 //                rat_gpr_update_table       [i][j][k] = false;
     43                  rat_gpr_speculative        [i][j][k] = 0    ; // not necessary
     44                  rat_gpr_update_table       [i][j][k] = false; // not necessary
    4545                }
    4646              for (uint32_t k=0; k<_param->_nb_special_register_logic; k++)
    4747                {
    4848                  rat_spr_not_speculative    [i][j][k] = spr++;
    49 //                rat_spr_speculative        [i][j][k] = spr++;
    5049                  rat_spr_speculative_valid  [i][j][k] = false;
    51 //                rat_spr_update_table       [i][j][k] = false;
     50                  rat_spr_speculative        [i][j][k] = 0    ; // not necessary
     51                  rat_spr_update_table       [i][j][k] = false; // not necessary
    5252                }
    5353            }

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue/src/Register_translation_unit_Glue.cpp

    r110 r123  
    3939    log_printf(FUNC,Register_translation_unit_Glue,FUNCTION,"Begin");
    4040
    41 #if DEBUG_Register_translation_unit_Glue == true
    42     log_printf(INFO,Register_translation_unit_Glue,FUNCTION,_("<%s> Parameters"),_name.c_str());
    43 
    44     std::cout << *param << std::endl;
    45 #endif   
     41// #if DEBUG_Register_translation_unit_Glue == true
     42//     log_printf(INFO,Register_translation_unit_Glue,FUNCTION,_("<%s> Parameters"),_name.c_str());
     43
     44//     std::cout << *param << std::endl;
     45// #endif   
    4646
    4747    log_printf(INFO,Register_translation_unit_Glue,FUNCTION,"Allocation");

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue/src/Register_translation_unit_Glue_genMealy_insert.cpp

    r117 r123  
    2626    log_function(Register_translation_unit_Glue,FUNCTION,_name.c_str());
    2727
     28    if (PORT_READ(in_NRESET))
     29      {
    2830    for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
    2931      {
    … …  
    8486        PORT_WRITE(out_INSERT_NUM_REG_RE_PHY_NEW           [i], NUM_REG_RE_PHY_NEW);
    8587      }
     88      }
     89//     else
     90//       {
     91//       }
    8692
    8793    log_end(Register_translation_unit_Glue,FUNCTION);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue/src/Register_translation_unit_Glue_genMealy_insert_valack.cpp

    r110 r123  
    2525    log_begin(Register_translation_unit_Glue,FUNCTION);
    2626    log_function(Register_translation_unit_Glue,FUNCTION,_name.c_str());
     27
     28    if (PORT_READ(in_NRESET))
     29      {
    2730    for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
    2831      {
    … …  
    8689
    8790      }
     91      }
     92    else
     93      {
     94        for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
     95          {
     96#ifdef STATISTICS
     97            internal_INSERT_RENAME_ACK [i] = 0;
     98#endif
     99           
     100            PORT_WRITE(out_INSERT_RENAME_ACK     [i], 0);
     101            PORT_WRITE(out_INSERT_INSERT_VAL     [i], 0);
     102            PORT_WRITE(out_INSERT_RAT_INSERT_VAL [i], 0);
     103            PORT_WRITE(out_INSERT_FREE_LIST_VAL  [i], 0);
     104            PORT_WRITE(out_INSERT_STAT_LIST_VAL  [i], 0);
     105          }
     106      }
    88107
    89108    log_end(Register_translation_unit_Glue,FUNCTION);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue/src/Register_translation_unit_Glue_genMealy_retire.cpp

    r110 r123  
    2626    log_function(Register_translation_unit_Glue,FUNCTION,_name.c_str());
    2727
     28    if (PORT_READ(in_NRESET))
     29      {
    2830    for (uint32_t i=0; i<_param->_nb_inst_retire; i++)
    2931      {
    … …  
    6062        log_printf(TRACE,Register_translation_unit_Glue,FUNCTION,"    * stat_list_ack  (r): %d",stat_list_ack );
    6163      }
     64      }
     65    else
     66      {
     67        for (uint32_t i=0; i<_param->_nb_inst_retire; i++)
     68          {
     69            PORT_WRITE(out_RETIRE_ACK           [i], 0);
     70            PORT_WRITE(out_RETIRE_RAT_VAL       [i], 0);
     71            PORT_WRITE(out_RETIRE_STAT_LIST_VAL [i], 0);
     72          }
     73      }
    6274
    6375    log_end(Register_translation_unit_Glue,FUNCTION);

  • 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

    r121 r123  
    8282  public    : SC_OUT(Tcontrol_t        )   ** out_RETIRE_ACK               ;//[nb_inst_retire]
    8383  public    : SC_IN (Tcontrol_t        )   **  in_RETIRE_RESTORE           ;//[nb_inst_retire]
    84 //   public    : SC_IN (Tcontrol_t        )   **  in_RETIRE_READ_RA           ;//[nb_inst_retire]
    85 //   public    : SC_IN (Tgeneral_address_t)   **  in_RETIRE_NUM_REG_RA_PHY    ;//[nb_inst_retire]
    86 //   public    : SC_IN (Tcontrol_t        )   **  in_RETIRE_READ_RB           ;//[nb_inst_retire]
    87 //   public    : SC_IN (Tgeneral_address_t)   **  in_RETIRE_NUM_REG_RB_PHY    ;//[nb_inst_retire]
    88 //   public    : SC_IN (Tcontrol_t        )   **  in_RETIRE_READ_RC           ;//[nb_inst_retire]
    89 //   public    : SC_IN (Tspecial_address_t)   **  in_RETIRE_NUM_REG_RC_PHY    ;//[nb_inst_retire]
     84//public    : SC_IN (Tcontrol_t        )   **  in_RETIRE_READ_RA           ;//[nb_inst_retire]
     85//public    : SC_IN (Tgeneral_address_t)   **  in_RETIRE_NUM_REG_RA_PHY    ;//[nb_inst_retire]
     86//public    : SC_IN (Tcontrol_t        )   **  in_RETIRE_READ_RB           ;//[nb_inst_retire]
     87//public    : SC_IN (Tgeneral_address_t)   **  in_RETIRE_NUM_REG_RB_PHY    ;//[nb_inst_retire]
     88//public    : SC_IN (Tcontrol_t        )   **  in_RETIRE_READ_RC           ;//[nb_inst_retire]
     89//public    : SC_IN (Tspecial_address_t)   **  in_RETIRE_NUM_REG_RC_PHY    ;//[nb_inst_retire]
    9090  public    : SC_IN (Tcontrol_t        )   **  in_RETIRE_WRITE_RD          ;//[nb_inst_retire]
    9191  public    : SC_IN (Tcontrol_t        )   **  in_RETIRE_RESTORE_RD_PHY_OLD;//[nb_inst_retire]
    … …  
    106106  public    : SC_IN (Tcontrol_t)           **  in_PUSH_SPR_ACK             ;//[nb_reg_free]
    107107  public    : SC_OUT(Tspecial_address_t)   ** out_PUSH_SPR_NUM_REG         ;//[nb_reg_free]
     108
     109    // ~~~~~[ interface : "info" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     110#ifdef DEBUG_TEST
     111  public    : SC_IN (bool      )            *  in_INFO_ROB_EMPTY  ;
     112  public    : SC_IN (uint32_t  )            *  in_INFO_NB_GPR_FREE;
     113  public    : SC_IN (uint32_t  )            *  in_INFO_NB_SPR_FREE;
     114#endif
    108115
    109116    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Stat_List_unit/include/Types.h

    r117 r123  
    6666      else
    6767        {
    68 //        _is_link = 0; // already unset
     68          _is_link = 0;
    6969          _is_use  = 0;
    7070        }

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Stat_List_unit/src/Stat_List_unit.cpp

    r112 r123  
    3838    log_printf(FUNC,Stat_List_unit,FUNCTION,"Begin");
    3939
    40 #if DEBUG_Stat_List_unit == true
    41     log_printf(INFO,Stat_List_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
     40// #if DEBUG_Stat_List_unit == true
     41//     log_printf(INFO,Stat_List_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
    4242
    43     std::cout << *param << std::endl;
    44 #endif   
     43//     std::cout << *param << std::endl;
     44// #endif   
    4545
    4646    log_printf(INFO,Stat_List_unit,FUNCTION,"Allocation");

  • 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

    r121 r123  
    125125     }
    126126
     127    // ~~~~~[ interface : "info" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     128#ifdef DEBUG_TEST
     129     {
     130       ALLOC0_INTERFACE_BEGIN("info",IN, NORTH, _("Information"));
     131
     132       ALLOC0_SIGNAL_IN ( in_INFO_ROB_EMPTY  ,"rob_empty"  ,bool    ,1);
     133       ALLOC0_SIGNAL_IN ( in_INFO_NB_GPR_FREE,"nb_gpr_free",uint32_t,_param->_size_general_register+1);
     134       ALLOC0_SIGNAL_IN ( in_INFO_NB_SPR_FREE,"nb_spr_free",uint32_t,_param->_size_special_register+1);
     135
     136       ALLOC0_INTERFACE_END();
     137     }
     138#endif
     139
    127140    // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    128141    if (usage_is_set(_usage,USE_SYSTEMC))

  • 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

    r121 r123  
    7171        DELETE1_SIGNAL(out_PUSH_SPR_NUM_REG,_param->_nb_reg_free,_param->_size_special_register);
    7272
     73#ifdef DEBUG_TEST
     74        DELETE0_SIGNAL( in_INFO_ROB_EMPTY  ,1);
     75        DELETE0_SIGNAL( in_INFO_NB_GPR_FREE,_param->_size_general_register+1);
     76        DELETE0_SIGNAL( in_INFO_NB_SPR_FREE,_param->_size_special_register+1);
     77#endif
     78
    7379        DELETE2(gpr_stat_list             ,_param->_nb_bank,_param->_nb_general_register_by_bank);
    7480        DELETE2(spr_stat_list             ,_param->_nb_bank,_param->_nb_special_register_by_bank);

  • 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

    r118 r123  
    2828    log_function(Stat_List_unit,FUNCTION,_name.c_str());
    2929
     30    if (PORT_READ(in_NRESET))
     31      {
    3032    uint32_t  gpr_ptr = reg_GPR_PTR_FREE;
    3133    uint32_t  spr_ptr = reg_SPR_PTR_FREE;
    … …  
    8183          internal_PUSH_GPR_NUM_REG  [i] = gpr_ptr ;
    8284
    83           PORT_WRITE(out_PUSH_GPR_VAL [i], val);
    8485          if (val)
    8586            PORT_WRITE(out_PUSH_GPR_NUM_REG[i], ((bank_gpr<<_param->_shift_gpr) | gpr_ptr));
    … …  
    126127          internal_PUSH_SPR_NUM_REG  [i] = spr_ptr ;
    127128
    128           PORT_WRITE(out_PUSH_SPR_VAL [i], val);
    129129          if (val)
    130130            PORT_WRITE(out_PUSH_SPR_NUM_REG[i], ((bank_spr<<_param->_shift_spr) | spr_ptr));
    … …  
    133133
    134134      }
    135    
     135      }
     136    else
     137      {
     138        for (uint32_t i=0; i<_param->_nb_reg_free; i++)
     139          {
     140            internal_PUSH_GPR_VAL      [i] = 0;
     141//          internal_PUSH_GPR_NUM_BANK [i] = bank_gpr;
     142//          internal_PUSH_GPR_NUM_REG  [i] = gpr_ptr ;
     143            internal_PUSH_SPR_VAL      [i] = 0;
     144//          internal_PUSH_SPR_NUM_BANK [i] = bank_spr;
     145//          internal_PUSH_SPR_NUM_REG  [i] = spr_ptr ;
     146          }
     147      }
     148
     149    for (uint32_t i=0; i<_param->_nb_reg_free; i++)
     150      {
     151        PORT_WRITE(out_PUSH_GPR_VAL [i], internal_PUSH_GPR_VAL      [i]);
     152        PORT_WRITE(out_PUSH_SPR_VAL [i], internal_PUSH_SPR_VAL      [i]);
     153      }
     154 
    136155    log_end(Stat_List_unit,FUNCTION);
    137156  };

  • 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

    r118 r123  
    4343    else
    4444      {
     45#ifdef DEBUG_TEST
     46        {
     47          uint32_t free_list_nb_gpr_free     = PORT_READ(in_INFO_NB_GPR_FREE);
     48          uint32_t free_list_nb_spr_free     = PORT_READ(in_INFO_NB_SPR_FREE);
     49          uint32_t stat_list_nb_gpr_free     = 0;
     50          uint32_t stat_list_nb_spr_free     = 0;
     51          uint32_t stat_list_nb_gpr_can_free = 0;
     52          uint32_t stat_list_nb_spr_can_free = 0;
     53          uint32_t stat_list_nb_gpr_link     = 0;
     54          uint32_t stat_list_nb_spr_link     = 0;
     55          uint32_t stat_list_nb_gpr_use      = 0;
     56          uint32_t stat_list_nb_spr_use      = 0;
     57
     58          for (uint32_t i=0; i<_param->_nb_bank; i++)
     59            {
     60              for (uint32_t j=0; j<_param->_nb_general_register_by_bank; j++)
     61                {
     62                  if (gpr_stat_list [i][j]._is_free)
     63                    stat_list_nb_gpr_free ++;
     64                  if (gpr_stat_list [i][j]._is_link)
     65                    stat_list_nb_gpr_link ++;
     66                  if (gpr_stat_list [i][j]._is_use)
     67                    stat_list_nb_gpr_use ++;
     68                  if (gpr_stat_list [i][j].can_free())
     69                    stat_list_nb_gpr_can_free ++;
     70                }
     71              for (uint32_t j=0; j<_param->_nb_special_register_by_bank; j++)
     72                {
     73                  if (spr_stat_list [i][j]._is_free)
     74                    stat_list_nb_spr_free ++;
     75                  if (spr_stat_list [i][j]._is_link)
     76                    stat_list_nb_spr_link ++;
     77                  if (spr_stat_list [i][j]._is_use)
     78                    stat_list_nb_spr_use ++;
     79                  if (spr_stat_list [i][j].can_free())
     80                    stat_list_nb_spr_can_free ++;
     81                }
     82            }
     83
     84          uint32_t  nb_gpr_free = stat_list_nb_gpr_free+stat_list_nb_gpr_can_free;
     85          uint32_t  nb_spr_free = stat_list_nb_spr_free+stat_list_nb_spr_can_free;
     86          uint32_t _nb_gpr_free = (_param->_nb_general_register - _param->_nb_gpr_use_init);
     87          uint32_t _nb_spr_free = (_param->_nb_special_register - _param->_nb_spr_use_init);
     88          uint32_t  nb_gpr_link = stat_list_nb_gpr_link - _param->_nb_gpr_use_init;
     89          uint32_t  nb_spr_link = stat_list_nb_spr_link - _param->_nb_spr_use_init;
     90          uint32_t  nb_gpr_use  = stat_list_nb_gpr_use - _param->_nb_gpr_use_init;
     91          uint32_t  nb_spr_use  = stat_list_nb_spr_use - _param->_nb_spr_use_init;
     92
     93          log_printf(TRACE,Stat_List_unit,FUNCTION,"  * nb_gpr_free : stat_list %d - free_list %d - free %d, link %d (%d), use %d (%d)",stat_list_nb_gpr_free,free_list_nb_gpr_free,nb_gpr_free,nb_gpr_link,stat_list_nb_gpr_link,nb_gpr_use,stat_list_nb_gpr_use);
     94          log_printf(TRACE,Stat_List_unit,FUNCTION,"  * nb_spr_free : stat_list %d - free_list %d - free %d, link %d (%d), use %d (%d)",stat_list_nb_spr_free,free_list_nb_spr_free,nb_spr_free,nb_spr_link,stat_list_nb_spr_link,nb_spr_use,stat_list_nb_spr_use);
     95
     96          if (free_list_nb_gpr_free != stat_list_nb_gpr_free)
     97            throw ERRORMORPHEO(FUNCTION,toString(_("Number of free general register is not valid. %d in Stat_List and %d in Free_list.\n"),stat_list_nb_gpr_free,free_list_nb_gpr_free));
     98          if (free_list_nb_spr_free != stat_list_nb_spr_free)
     99            throw ERRORMORPHEO(FUNCTION,toString(_("Number of free general register is not valid. %d in Stat_List and %d in Free_list.\n"),stat_list_nb_spr_free,free_list_nb_spr_free));
     100
     101          if (PORT_READ(in_INFO_ROB_EMPTY) and (nb_gpr_free != _nb_gpr_free))
     102            throw ERRORMORPHEO(FUNCTION,toString(_("Rob is empty but they have %d general registers free or can_free and must be %d registers."),nb_gpr_free,_nb_gpr_free));
     103
     104          if (PORT_READ(in_INFO_ROB_EMPTY) and (nb_spr_free != _nb_spr_free))
     105            throw ERRORMORPHEO(FUNCTION,toString(_("Rob is empty but they have %d special registers free or can_free and must be %d registers."),nb_spr_free,_nb_spr_free));
     106        }
     107#endif
     108
    45109        // =====================================================
    46110        // =====[ INSERT ]======================================
    … …  
    256320      for (uint32_t i=0; i<_param->_nb_bank; i++)
    257321        for (uint32_t j=0; j<_param->_nb_general_register_by_bank; j++)
    258           log_printf(TRACE,Stat_List_unit,FUNCTION,"    * GPR[%.4d][%.5d] (%.5d) - free %.1d, link %.1d",
     322          log_printf(TRACE,Stat_List_unit,FUNCTION,"    * GPR[%.4d][%.5d] (%.5d) - free %.1d, link %.1d, use %.1d",
    259323                     i,
    260324                     j,
    261325                     (i<<_param->_shift_gpr)|j,
    262326                     gpr_stat_list[i][j]._is_free,
    263                      gpr_stat_list[i][j]._is_link// ,
     327                     gpr_stat_list[i][j]._is_link,
     328                     gpr_stat_list[i][j]._is_use// ,
    264329//                      gpr_stat_list[i][j]._is_valid,
    265330//                      gpr_stat_list[i][j]._counter
    … …  
    267332      for (uint32_t i=0; i<_param->_nb_bank; i++)
    268333        for (uint32_t j=0; j<_param->_nb_special_register_by_bank; j++)
    269           log_printf(TRACE,Stat_List_unit,FUNCTION,"    * SPR[%.4d][%.5d] (%.5d) - free %.1d, link %.1d",
     334          log_printf(TRACE,Stat_List_unit,FUNCTION,"    * SPR[%.4d][%.5d] (%.5d) - free %.1d, link %.1d, use %.1d",
    270335                     i,
    271336                     j,
    272337                     (i<<_param->_shift_spr)|j,
    273338                     spr_stat_list[i][j]._is_free,
    274                      spr_stat_list[i][j]._is_link// ,
     339                     spr_stat_list[i][j]._is_link,
     340                     spr_stat_list[i][j]._is_use// ,
    275341//                      spr_stat_list[i][j]._is_valid,
    276342//                      spr_stat_list[i][j]._counter

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/include/Register_translation_unit.h

    r121 r123  
    137137  public    : SC_IN (Tevent_state_t    )  ***  in_RETIRE_EVENT_STATE       ;//[nb_front_end][nb_context]
    138138
     139    // ~~~~~[ interface : "info" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     140#ifdef DEBUG_TEST
     141  public    : SC_IN (bool      )            *  in_INFO_ROB_EMPTY  ;
     142#endif
     143
    139144    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    140145  public : morpheo::behavioural::core::multi_ooo_engine::ooo_engine::rename_unit::register_translation_unit::dependency_checking_unit::Dependency_checking_unit                   * _component_dependency_checking_unit;

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

    r88 r123  
    3838    log_printf(FUNC,Register_translation_unit,FUNCTION,"Begin");
    3939
    40 #if DEBUG_Register_translation_unit == true
    41     log_printf(INFO,Register_translation_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
     40// #if DEBUG_Register_translation_unit == true
     41//     log_printf(INFO,Register_translation_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
    4242
    43     std::cout << *param << std::endl;
    44 #endif   
     43//     std::cout << *param << std::endl;
     44// #endif   
    4545
    4646    log_printf(INFO,Register_translation_unit,FUNCTION,"Allocation");

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/src/Register_translation_unit_allocation.cpp

    r122 r123  
    149149      ALLOC2_INTERFACE_END(_param->_nb_front_end, _param->_nb_context[it1]);
    150150    }
     151
     152    // ~~~~~[ interface : "info" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     153#ifdef DEBUG_TEST
     154     {
     155       ALLOC0_INTERFACE_BEGIN("info",IN, NORTH, _("Information"));
     156
     157       ALLOC0_SIGNAL_IN ( in_INFO_ROB_EMPTY  ,"rob_empty"  ,bool    ,1);
     158
     159       ALLOC0_INTERFACE_END();
     160     }
     161#endif
    151162
    152163    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    … …  
    472483                                   dest,"out_PUSH_SPR_"+toString(i)+"_NUM_REG");
    473484        }
     485
     486    // ~~~~~[ interface : "info" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     487#ifdef DEBUG_TEST
     488      {
     489        dest = _name+"_stat_list_unit";
     490#ifdef POSITION
     491        _component->interface_map (src ,"info"
     492                                   dest,"info");
     493#endif
     494       
     495        COMPONENT_MAP(_component,src ,"out_INFO_NB_GPR_FREE",
     496                                 dest, "in_INFO_NB_GPR_FREE");
     497        COMPONENT_MAP(_component,src ,"out_INFO_NB_SPR_FREE",
     498                                 dest, "in_INFO_NB_SPR_FREE");
     499      }
     500#endif
    474501    }
    475 
    476502
    477503    // ===================================================================
    … …  
    726752          //out_PUSH_SPR_NUM_REG - free_list_unit
    727753        }
     754
     755#ifdef DEBUG_TEST
     756      {
     757        dest = _name;
     758#ifdef POSITION
     759        _component->interface_map (src ,"info"
     760                                   dest,"info");
     761#endif
     762       
     763        PORT_MAP(_component,src , "in_INFO_ROB_EMPTY",
     764                            dest, "in_INFO_ROB_EMPTY");
     765      }
     766#endif
     767
    728768    }
    729769

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/src/Register_translation_unit_deallocation.cpp

    r121 r123  
    9494        DELETE2_SIGNAL(out_RETIRE_EVENT_ACK            ,_param->_nb_front_end, _param->_nb_context[it1],1);
    9595        DELETE2_SIGNAL( in_RETIRE_EVENT_STATE          ,_param->_nb_front_end, _param->_nb_context[it1],_param->_size_event_state);
     96
     97#ifdef DEBUG_TEST
     98        DELETE0_SIGNAL( in_INFO_ROB_EMPTY  ,1);
     99#endif
    96100      }
    97101

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_select/include/Rename_select.h

    r122 r123  
    7575  public    : SC_IN (Toperation_t      )  ***  in_RENAME_IN_OPERATION     ;//[nb_front_end][nb_inst_decod]
    7676  public    : SC_IN (Tcontrol_t        )  ***  in_RENAME_IN_NO_EXECUTE    ;//[nb_front_end][nb_inst_decod]
     77//public    : SC_IN (Tcontrol_t        )  ***  in_RENAME_IN_HAVE_EVENT    ;//[nb_front_end][nb_inst_decod]
     78  public    : SC_IN (Tcontrol_t        )  ***  in_RENAME_IN_LAST_EVENT    ;//[nb_front_end][nb_inst_decod]
    7779  public    : SC_IN (Tcontrol_t        )  ***  in_RENAME_IN_IS_DELAY_SLOT ;//[nb_front_end][nb_inst_decod]
    7880#ifdef DEBUG
    … …  
    104106  public    : SC_OUT(Toperation_t      )   ** out_RENAME_OUT_OPERATION    ;//[nb_inst_rename]
    105107  public    : SC_OUT(Tcontrol_t        )   ** out_RENAME_OUT_NO_EXECUTE   ;//[nb_inst_rename]
     108  public    : SC_OUT(Tcontrol_t        )   ** out_RENAME_OUT_LAST_EVENT   ;//[nb_inst_rename]
    106109  public    : SC_OUT(Tcontrol_t        )   ** out_RENAME_OUT_IS_DELAY_SLOT;//[nb_inst_rename]
    107110#ifdef DEBUG
    … …  
    125128
    126129    // ~~~~~[ Interface "retire_event" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    127   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_EVENT_FLUSH      ;//[nb_front_end][nb_context]
     130//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_EVENT_FLUSH      ;//[nb_front_end][nb_context]
    128131  public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_EVENT_STOP       ;//[nb_front_end][nb_context]
    129132

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

    r122 r123  
    3838    log_printf(FUNC,Rename_select,FUNCTION,"Begin");
    3939
    40 #if DEBUG_Core == true
    41     log_printf(INFO,Core,FUNCTION,_("<%s> Parameters"),_name.c_str());
    42 
    43     std::cout << *param << std::endl;
    44 #endif   
     40// #if DEBUG_Core == true
     41//     log_printf(INFO,Core,FUNCTION,_("<%s> Parameters"),_name.c_str());
     42
     43//     std::cout << *param << std::endl;
     44// #endif   
    4545
    4646    log_printf(INFO,Rename_select,FUNCTION,"Allocation");
    … …  
    9696                        << (*(in_RENAME_IN_OPERATION     [i][j]))
    9797                        << (*(in_RENAME_IN_NO_EXECUTE    [i][j]))
     98//                      << (*(in_RENAME_IN_HAVE_EVENT    [i][j]))
     99                        << (*(in_RENAME_IN_LAST_EVENT    [i][j]))
    98100                        << (*(in_RENAME_IN_IS_DELAY_SLOT [i][j]))
    99101#ifdef DEBUG
    … …  
    125127        for (uint32_t i=0; i<_param->_nb_front_end; i++)
    126128          for (uint32_t j=0; j<_param->_nb_context [i]; j++)
    127             sensitive << (*(in_RETIRE_EVENT_FLUSH [i][j]))
     129            sensitive // << (*(in_RETIRE_EVENT_FLUSH [i][j]))
    128130                      << (*(in_RETIRE_EVENT_STOP  [i][j]));
    129131

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_select/src/Rename_select_allocation.cpp

    r122 r123  
    6868      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_OPERATION     ,"operation"    ,Toperation_t      ,_param->_size_operation             , _param->_nb_front_end, _param->_nb_inst_decod[it1]);
    6969      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_NO_EXECUTE    ,"no_execute"   ,Tcontrol_t        ,1                                   , _param->_nb_front_end, _param->_nb_inst_decod[it1]);
     70//    _ALLOC2_SIGNAL_IN ( in_RENAME_IN_HAVE_EVENT    ,"have_event"   ,Tcontrol_t        ,1                                   , _param->_nb_front_end, _param->_nb_inst_decod[it1]);
     71      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_LAST_EVENT    ,"last_event"   ,Tcontrol_t        ,1                                   , _param->_nb_front_end, _param->_nb_inst_decod[it1]);
    7072      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_IS_DELAY_SLOT ,"is_delay_slot",Tcontrol_t        ,1                                   , _param->_nb_front_end, _param->_nb_inst_decod[it1]);
    7173#ifdef DEBUG
    … …  
    103105      ALLOC1_SIGNAL_OUT(out_RENAME_OUT_OPERATION     ,"operation"    ,Toperation_t      ,_param->_size_operation             );
    104106      ALLOC1_SIGNAL_OUT(out_RENAME_OUT_NO_EXECUTE    ,"no_execute"   ,Tcontrol_t        ,1                                   );
     107      ALLOC1_SIGNAL_OUT(out_RENAME_OUT_LAST_EVENT    ,"last_event"   ,Tcontrol_t        ,1                                   );
    105108      ALLOC1_SIGNAL_OUT(out_RENAME_OUT_IS_DELAY_SLOT ,"is_delay_slot",Tcontrol_t        ,1                                   );
    106109#ifdef DEBUG
    … …  
    130133      ALLOC2_INTERFACE_BEGIN("retire_event", IN,NORTH, _("Retire event"), _param->_nb_front_end, _param->_nb_context[it1]);
    131134
    132       _ALLOC2_SIGNAL_IN ( in_RETIRE_EVENT_FLUSH         ,"flush"                ,Tcontrol_t        ,1                        , _param->_nb_front_end, _param->_nb_context[it1]);
     135//       _ALLOC2_SIGNAL_IN ( in_RETIRE_EVENT_FLUSH         ,"flush"                ,Tcontrol_t        ,1                        , _param->_nb_front_end, _param->_nb_context[it1]);
    133136      _ALLOC2_SIGNAL_IN ( in_RETIRE_EVENT_STOP          ,"stop"                 ,Tcontrol_t        ,1                        , _param->_nb_front_end, _param->_nb_context[it1]);
    134137

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_select/src/Rename_select_deallocation.cpp

    r122 r123  
    3737        DELETE2_SIGNAL( in_RENAME_IN_OPERATION     ,_param->_nb_front_end, _param->_nb_inst_decod[it1],_param->_size_operation             );
    3838        DELETE2_SIGNAL( in_RENAME_IN_NO_EXECUTE    ,_param->_nb_front_end, _param->_nb_inst_decod[it1],1                                   );
     39//      DELETE2_SIGNAL( in_RENAME_IN_HAVE_EVENT    ,_param->_nb_front_end, _param->_nb_inst_decod[it1],1                                   );
     40        DELETE2_SIGNAL( in_RENAME_IN_LAST_EVENT    ,_param->_nb_front_end, _param->_nb_inst_decod[it1],1                                   );
    3941        DELETE2_SIGNAL( in_RENAME_IN_IS_DELAY_SLOT ,_param->_nb_front_end, _param->_nb_inst_decod[it1],1                                   );
    4042#ifdef DEBUG
    … …  
    6567        DELETE1_SIGNAL(out_RENAME_OUT_OPERATION     ,_param->_nb_inst_rename,_param->_size_operation             );
    6668        DELETE1_SIGNAL(out_RENAME_OUT_NO_EXECUTE    ,_param->_nb_inst_rename,1                                   );
     69        DELETE1_SIGNAL(out_RENAME_OUT_LAST_EVENT    ,_param->_nb_inst_rename,1                                   );
    6770        DELETE1_SIGNAL(out_RENAME_OUT_IS_DELAY_SLOT ,_param->_nb_inst_rename,1                                   );
    6871#ifdef DEBUG
    … …  
    8588        DELETE1_SIGNAL(out_RENAME_OUT_EXCEPTION     ,_param->_nb_inst_rename,_param->_size_exception             );
    8689
    87         DELETE2_SIGNAL( in_RETIRE_EVENT_FLUSH       ,_param->_nb_front_end, _param->_nb_context[it1],1);
     90//         DELETE2_SIGNAL( in_RETIRE_EVENT_FLUSH       ,_param->_nb_front_end, _param->_nb_context[it1],1);
    8891        DELETE2_SIGNAL( in_RETIRE_EVENT_STOP        ,_param->_nb_front_end, _param->_nb_context[it1],1);
    8992      }

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_select/src/Rename_select_genMealy.cpp

    r122 r123  
    1717namespace rename_select {
    1818
    19 // #define CONTINUE_ON_EVENT_STOP
    20 
    2119#undef  FUNCTION
    2220#define FUNCTION "Rename_select::genMealy"
    … …  
    2826    Tcontrol_t val                  [_param->_nb_inst_rename];
    2927    Tcontrol_t ack                  [_param->_nb_front_end][_param->_max_nb_inst_decod];
    30     Tcontrol_t previous_transaction [_param->_nb_front_end];
    3128
    3229    for (uint32_t i=0; i<_param->_nb_inst_rename; ++i)
    3330      val [i] = false;
    3431    for (uint32_t i=0; i<_param->_nb_front_end; i++)
     32      for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
     33        ack [i][j] = false;
     34   
     35    if (PORT_READ(in_NRESET))
    3536      {
    36         previous_transaction [i] = true;
    37         for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
    38           ack [i][j] = false;
    39       }
     37        Tcontrol_t previous_transaction [_param->_nb_front_end];
     38        for (uint32_t i=0; i<_param->_nb_front_end; i++)
     39          previous_transaction [i] = true;
    4040
    4141    std::list<generic::priority::select_t> * select = _priority->select();
    … …  
    7171               
    7272                // Test if ROB is Flushed
    73 #ifndef CONTINUE_ON_EVENT_STOP
    7473                if (not stop)
    75 #endif
    7674                  {
    7775                    // Find !!!
    … …  
    7977                    ack [x][y] = PORT_READ(in_RENAME_OUT_ACK [i]);
    8078                   
    81                     Tcontrol_t     have_event          = (PORT_READ(in_RETIRE_EVENT_FLUSH [x][context_id])
    82 #ifdef CONTINUE_ON_EVENT_STOP
    83                                                           or stop
    84 #endif
    85                                                           );
    86                     Tcontrol_t     can_register_access = not have_event;
    87                     Tcontrol_t     no_execute          = (PORT_READ(in_RENAME_IN_NO_EXECUTE [x][y]) or have_event);
    88                     Tcontrol_t     read_ra             = (PORT_READ(in_RENAME_IN_READ_RA    [x][y]) and can_register_access);
    89                     Tcontrol_t     read_rb             = (PORT_READ(in_RENAME_IN_READ_RB    [x][y]) and can_register_access);
    90                     Tcontrol_t     read_rc             = (PORT_READ(in_RENAME_IN_READ_RC    [x][y]) and can_register_access);
    91                     Tcontrol_t     write_rd            = (PORT_READ(in_RENAME_IN_WRITE_RD   [x][y]) and can_register_access);
    92                     Tcontrol_t     write_re            = (PORT_READ(in_RENAME_IN_WRITE_RE   [x][y]) and can_register_access);
    93 //                  Tcontrol_t     read_ra             = (PORT_READ(in_RENAME_IN_READ_RA    [x][y]));
    94 //                  Tcontrol_t     read_rb             = (PORT_READ(in_RENAME_IN_READ_RB    [x][y]));
    95 //                  Tcontrol_t     read_rc             = (PORT_READ(in_RENAME_IN_READ_RC    [x][y]));
    96 //                  Tcontrol_t     write_rd            = (PORT_READ(in_RENAME_IN_WRITE_RD   [x][y]));
    97 //                  Tcontrol_t     write_re            = (PORT_READ(in_RENAME_IN_WRITE_RE   [x][y]));
     79//                  Tcontrol_t     have_event          = (PORT_READ(in_RETIRE_EVENT_FLUSH [x][context_id]) // or
     80//                                                           );
     81//                  log_printf(TRACE,Rename_select,FUNCTION,"      * have_event           : %d",have_event);
     82
     83//                  Tcontrol_t     can_register_access = not have_event;
     84//                  Tcontrol_t     no_execute          = (PORT_READ(in_RENAME_IN_NO_EXECUTE [x][y]) or have_event);
     85//                  Tcontrol_t     read_ra             = (PORT_READ(in_RENAME_IN_READ_RA    [x][y]) and can_register_access);
     86//                  Tcontrol_t     read_rb             = (PORT_READ(in_RENAME_IN_READ_RB    [x][y]) and can_register_access);
     87//                  Tcontrol_t     read_rc             = (PORT_READ(in_RENAME_IN_READ_RC    [x][y]) and can_register_access);
     88//                  Tcontrol_t     write_rd            = (PORT_READ(in_RENAME_IN_WRITE_RD   [x][y]) and can_register_access);
     89//                  Tcontrol_t     write_re            = (PORT_READ(in_RENAME_IN_WRITE_RE   [x][y]) and can_register_access);
     90                    Tcontrol_t     no_execute          = (PORT_READ(in_RENAME_IN_NO_EXECUTE [x][y]));
     91                    Tcontrol_t     read_ra             = (PORT_READ(in_RENAME_IN_READ_RA    [x][y]));
     92                    Tcontrol_t     read_rb             = (PORT_READ(in_RENAME_IN_READ_RB    [x][y]));
     93                    Tcontrol_t     read_rc             = (PORT_READ(in_RENAME_IN_READ_RC    [x][y]));
     94                    Tcontrol_t     write_rd            = (PORT_READ(in_RENAME_IN_WRITE_RD   [x][y]));
     95                    Tcontrol_t     write_re            = (PORT_READ(in_RENAME_IN_WRITE_RE   [x][y]));
    9896                   
    99                     log_printf(TRACE,Rename_select,FUNCTION,"      * have_event           : %d",have_event);
    100                     log_printf(TRACE,Rename_select,FUNCTION,"      * no_execute (before)  : %d",PORT_READ(in_RENAME_IN_NO_EXECUTE [x][y]));
    101                     log_printf(TRACE,Rename_select,FUNCTION,"      * no_execute (after)   : %d",no_execute);
     97                    log_printf(TRACE,Rename_select,FUNCTION,"      * no_execute           : %d",no_execute);
    10298                   
    10399                    if (_param->_have_port_front_end_id)
    … …  
    110106                    PORT_WRITE(out_RENAME_OUT_OPERATION    [i],PORT_READ(in_RENAME_IN_OPERATION     [x][y]));
    111107                    PORT_WRITE(out_RENAME_OUT_NO_EXECUTE   [i],no_execute);
     108                    PORT_WRITE(out_RENAME_OUT_LAST_EVENT   [i],PORT_READ(in_RENAME_IN_LAST_EVENT    [x][y]));
    112109                    PORT_WRITE(out_RENAME_OUT_IS_DELAY_SLOT[i],PORT_READ(in_RENAME_IN_IS_DELAY_SLOT [x][y]));
    113110#ifdef DEBUG       
    … …  
    140137      }
    141138
     139      }
     140//     else
     141//       {
     142//       }
     143
    142144    for (uint32_t i=0; i<_param->_nb_inst_rename; ++i)
    143145      PORT_WRITE(out_RENAME_OUT_VAL [i], val [i]);
    … …  
    146148      for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
    147149        PORT_WRITE(out_RENAME_IN_ACK [i][j], ack [i][j]);
     150
    148151
    149152    log_end(Rename_select,FUNCTION);

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

    r122 r123  
    4040    usage_environment(_usage);
    4141
    42 #if DEBUG_Rename_unit_Glue == true
    43     log_printf(INFO,Rename_unit_Glue,FUNCTION,_("<%s> Parameters"),_name.c_str());
    44 
    45     std::cout << *param << std::endl;
    46 #endif   
     42// #if DEBUG_Rename_unit_Glue == true
     43//     log_printf(INFO,Rename_unit_Glue,FUNCTION,_("<%s> Parameters"),_name.c_str());
     44
     45//     std::cout << *param << std::endl;
     46// #endif   
    4747
    4848    log_printf(INFO,Rename_unit_Glue,FUNCTION,_("<%s> : Allocation"),_name.c_str());

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_unit_Glue/src/Rename_unit_Glue_genMealy_insert.cpp

    r88 r123  
    2525    log_function(Rename_unit_Glue,FUNCTION,_name.c_str());
    2626
     27    if (PORT_READ(in_NRESET))
     28      {
    2729    for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
    2830      {
    … …  
    104106        PORT_WRITE(out_INSERT_LOAD_STORE_QUEUE_POINTER_OPERATION    [i],OPERATION         );
    105107      }
     108      }
    106109
    107110    log_end(Rename_unit_Glue,FUNCTION);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_unit_Glue/src/Rename_unit_Glue_genMealy_insert_valack.cpp

    r115 r123  
    2525    log_function(Rename_unit_Glue,FUNCTION,_name.c_str());
    2626
     27    if (PORT_READ(in_NRESET))
     28      {
    2729//     // Transaction must be in-order - made in rename_select
    2830//     Tcontrol_t previous_transaction = true;
    … …  
    7577//      previous_transaction = RENAME_SELECT_VAL and RENAME_SELECT_ACK;
    7678      }
     79      }
     80    else
     81      {
     82        for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
     83          {
     84//      PORT_WRITE(out_INSERT_VAL                          [i], 0);
     85        PORT_WRITE(out_INSERT_RENAME_SELECT_ACK            [i], 0);
     86        PORT_WRITE(out_INSERT_REGISTER_TRANSLATION_VAL     [i], 0);
     87        PORT_WRITE(out_INSERT_LOAD_STORE_QUEUE_POINTER_VAL [i], 0);
     88          }
     89      }
    7790
    7891    log_end(Rename_unit_Glue,FUNCTION);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_unit_Glue/src/Rename_unit_Glue_genMealy_retire_event_valack.cpp

    r122 r123  
    2525    log_function(Rename_unit_Glue,FUNCTION,_name.c_str());
    2626
     27    if (PORT_READ(in_NRESET))
     28      {
    2729    for (uint32_t i=0; i<_param->_nb_front_end; i++)
    2830      for (uint32_t j=0; j<_param->_nb_context[i]; j++)
    … …  
    5961          log_printf(TRACE,Rename_unit_Glue,FUNCTION,"    * load_store_queue_pointer_ack (r) : %d",LOAD_STORE_QUEUE_POINTER_ACK);
    6062        }
    61    
     63      }
     64    else
     65      {
     66        for (uint32_t i=0; i<_param->_nb_front_end; i++)
     67          for (uint32_t j=0; j<_param->_nb_context[i]; j++)
     68            {
     69              PORT_WRITE(out_RETIRE_EVENT_ACK                          [i][j], 0);
     70              PORT_WRITE(out_RETIRE_EVENT_LOAD_STORE_QUEUE_POINTER_VAL [i][j], 0);
     71              PORT_WRITE(out_RETIRE_EVENT_REGISTER_TRANSLATION_VAL     [i][j], 0);
     72            }
     73      }
     74
    6275    log_end(Rename_unit_Glue,FUNCTION);
    6376  };

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_unit_Glue/src/Rename_unit_Glue_genMealy_retire_valack.cpp

    r110 r123  
    2525    log_function(Rename_unit_Glue,FUNCTION,_name.c_str());
    2626
     27    if (PORT_READ(in_NRESET))
     28      {
    2729    // Transaction must be in-order - made in commit_unit
    2830//     Tcontrol_t previous_transaction = true;
    … …  
    5860        log_printf(TRACE,Rename_unit_Glue,FUNCTION,"    * load_store_queue_pointer_ack (r) : %d",LOAD_STORE_QUEUE_POINTER_ACK);
    5961      }
    60 
     62      }
     63    else
     64      {
     65        for (uint32_t i=0; i<_param->_nb_inst_retire; i++)
     66          {
     67        PORT_WRITE(out_RETIRE_ACK                          [i], 0);
     68        PORT_WRITE(out_RETIRE_LOAD_STORE_QUEUE_POINTER_VAL [i], 0);
     69        PORT_WRITE(out_RETIRE_REGISTER_TRANSLATION_VAL     [i], 0);
     70          }
     71      }
    6172    log_end(Rename_unit_Glue,FUNCTION);
    6273  };

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/include/Rename_unit.h

    r122 r123  
    7777  public    : SC_IN (Toperation_t      )  ***  in_RENAME_IN_OPERATION         ;//[nb_front_end][nb_inst_decod]
    7878  public    : SC_IN (Tcontrol_t        )  ***  in_RENAME_IN_NO_EXECUTE        ;//[nb_front_end][nb_inst_decod]
     79//public    : SC_IN (Tcontrol_t        )  ***  in_RENAME_IN_HAVE_EVENT        ;//[nb_front_end][nb_inst_decod]
     80  public    : SC_IN (Tcontrol_t        )  ***  in_RENAME_IN_LAST_EVENT        ;//[nb_front_end][nb_inst_decod]
    7981  public    : SC_IN (Tcontrol_t        )  ***  in_RENAME_IN_IS_DELAY_SLOT     ;//[nb_front_end][nb_inst_decod]
    8082#ifdef DEBUG
    … …  
    106108  public    : SC_OUT(Toperation_t      )   ** out_INSERT_OPERATION            ;//[nb_inst_insert]
    107109  public    : SC_OUT(Tcontrol_t        )   ** out_INSERT_NO_EXECUTE           ;//[nb_inst_insert]
     110  public    : SC_OUT(Tcontrol_t        )   ** out_INSERT_LAST_EVENT           ;//[nb_inst_insert]
    108111  public    : SC_OUT(Tcontrol_t        )   ** out_INSERT_IS_DELAY_SLOT        ;//[nb_inst_insert]
    109112#ifdef DEBUG
    … …  
    173176  public    : SC_OUT(Tcontrol_t        )  *** out_RETIRE_EVENT_ACK            ;//[nb_front_end][nb_context]
    174177  public    : SC_IN (Tevent_state_t    )  ***  in_RETIRE_EVENT_STATE          ;//[nb_front_end][nb_context]
    175   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_EVENT_FLUSH          ;//[nb_front_end][nb_context]
     178//public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_EVENT_FLUSH          ;//[nb_front_end][nb_context]
    176179  public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_EVENT_STOP           ;//[nb_front_end][nb_context]
    177180
    178181    // ~~~~~[ Interface : "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    179182  public    : SC_IN (Tspr_t            )  ***  in_SPR_READ_SR                 ;//[nb_front_end][nb_context]
     183
     184    // ~~~~~[ interface : "info" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     185#ifdef DEBUG_TEST
     186  public    : SC_IN (bool      )            *  in_INFO_ROB_EMPTY  ;
     187#endif
    180188
    181189    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

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

    r88 r123  
    3939    usage_environment(_usage);
    4040
    41 #if DEBUG_Rename_unit == true
    42     log_printf(INFO,Rename_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
     41// #if DEBUG_Rename_unit == true
     42//     log_printf(INFO,Rename_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
    4343
    44     std::cout << *param << std::endl;
    45 #endif   
     44//     std::cout << *param << std::endl;
     45// #endif   
    4646
    4747    log_printf(INFO,Rename_unit,FUNCTION,_("<%s> : Allocation"),_name.c_str());

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

    r122 r123  
    6868      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_OPERATION     ,"operation"    ,Toperation_t      ,_param->_size_operation             , _param->_nb_front_end, _param->_nb_inst_decod[it1]);
    6969      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_NO_EXECUTE    ,"no_execute"   ,Tcontrol_t        ,1                                   , _param->_nb_front_end, _param->_nb_inst_decod[it1]);
     70//    _ALLOC2_SIGNAL_IN ( in_RENAME_IN_HAVE_EVENT    ,"have_event"   ,Tcontrol_t        ,1                                   , _param->_nb_front_end, _param->_nb_inst_decod[it1]);
     71      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_LAST_EVENT    ,"last_event"   ,Tcontrol_t        ,1                                   , _param->_nb_front_end, _param->_nb_inst_decod[it1]);
    7072      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_IS_DELAY_SLOT ,"is_delay_slot",Tcontrol_t        ,1                                   , _param->_nb_front_end, _param->_nb_inst_decod[it1]);
    7173#ifdef DEBUG
    … …  
    103105      ALLOC1_SIGNAL_OUT(out_INSERT_OPERATION            ,"operation"            ,Toperation_t      ,_param->_size_operation             );
    104106      ALLOC1_SIGNAL_OUT(out_INSERT_NO_EXECUTE           ,"no_execute"           ,Tcontrol_t        ,1                                   );
     107      ALLOC1_SIGNAL_OUT(out_INSERT_LAST_EVENT           ,"last_event"           ,Tcontrol_t        ,1                                   );
    105108      ALLOC1_SIGNAL_OUT(out_INSERT_IS_DELAY_SLOT        ,"is_delay_slot"        ,Tcontrol_t        ,1                                   );
    106109#ifdef DEBUG
    … …  
    182185      _ALLOC2_VALACK_OUT(out_RETIRE_EVENT_ACK           ,ACK,_param->_nb_front_end, _param->_nb_context[it1]);
    183186      _ALLOC2_SIGNAL_IN ( in_RETIRE_EVENT_STATE         ,"state"                ,Tevent_state_t    ,_param->_size_event_state, _param->_nb_front_end, _param->_nb_context[it1]);
    184       _ALLOC2_SIGNAL_IN ( in_RETIRE_EVENT_FLUSH         ,"flush"                ,Tcontrol_t        ,1                        , _param->_nb_front_end, _param->_nb_context[it1]);
     187//       _ALLOC2_SIGNAL_IN ( in_RETIRE_EVENT_FLUSH         ,"flush"                ,Tcontrol_t        ,1                        , _param->_nb_front_end, _param->_nb_context[it1]);
    185188      _ALLOC2_SIGNAL_IN ( in_RETIRE_EVENT_STOP          ,"stop"                 ,Tcontrol_t        ,1                        , _param->_nb_front_end, _param->_nb_context[it1]);
    186189
    … …  
    196199      ALLOC2_INTERFACE_END(_param->_nb_front_end, _param->_nb_context[it1]);
    197200    }
     201
     202    // ~~~~~[ interface : "info" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     203#ifdef DEBUG_TEST
     204     {
     205       ALLOC0_INTERFACE_BEGIN("info",IN, NORTH, _("Information"));
     206
     207       ALLOC0_SIGNAL_IN ( in_INFO_ROB_EMPTY  ,"rob_empty"  ,bool    ,1);
     208
     209       ALLOC0_INTERFACE_END();
     210     }
     211#endif
    198212
    199213    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    … …  
    325339            PORT_MAP(_component,src , "in_RENAME_IN_"+toString(i)+"_"+toString(j)+"_NO_EXECUTE"   ,
    326340                                dest, "in_RENAME_IN_"+toString(i)+"_"+toString(j)+"_NO_EXECUTE"   );
     341//          PORT_MAP(_component,src , "in_RENAME_IN_"+toString(i)+"_"+toString(j)+"_HAVE_EVENT"   ,
     342//                              dest, "in_RENAME_IN_"+toString(i)+"_"+toString(j)+"_HAVE_EVENT"   );
     343            PORT_MAP(_component,src , "in_RENAME_IN_"+toString(i)+"_"+toString(j)+"_LAST_EVENT"   ,
     344                                dest, "in_RENAME_IN_"+toString(i)+"_"+toString(j)+"_LAST_EVENT"   );
    327345            PORT_MAP(_component,src , "in_RENAME_IN_"+toString(i)+"_"+toString(j)+"_IS_DELAY_SLOT",
    328346                                dest, "in_RENAME_IN_"+toString(i)+"_"+toString(j)+"_IS_DELAY_SLOT");
    … …  
    387405          PORT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_EXCEPTION_USE",
    388406                              dest,"out_INSERT_"    +toString(i)+"_EXCEPTION_USE");
     407          PORT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_LAST_EVENT",
     408                              dest,"out_INSERT_"    +toString(i)+"_LAST_EVENT");
    389409
    390410          dest = _name+"_register_translation_unit";
    … …  
    456476                                       dest,"retire_event_"+toString(i)+"_"+toString(j));
    457477#endif     
    458             PORT_MAP(_component,src , "in_RETIRE_EVENT_"+toString(i)+"_"+toString(j)+"_FLUSH",
    459                                 dest, "in_RETIRE_EVENT_"+toString(i)+"_"+toString(j)+"_FLUSH");
     478//          PORT_MAP(_component,src , "in_RETIRE_EVENT_"+toString(i)+"_"+toString(j)+"_FLUSH",
     479//                                 dest, "in_RETIRE_EVENT_"+toString(i)+"_"+toString(j)+"_FLUSH");
    460480            PORT_MAP(_component,src , "in_RETIRE_EVENT_"+toString(i)+"_"+toString(j)+"_STOP",
    461481                                dest, "in_RETIRE_EVENT_"+toString(i)+"_"+toString(j)+"_STOP");
    … …  
    663683                                dest, "in_RETIRE_EVENT_"+toString(i)+"_"+toString(j)+"_STATE");
    664684          }
     685
     686
     687#ifdef DEBUG_TEST
     688      {
     689        dest = _name;
     690#ifdef POSITION
     691        _component->interface_map (src ,"info"
     692                                   dest,"info");
     693#endif
     694       
     695        PORT_MAP(_component,src , "in_INFO_ROB_EMPTY",
     696                            dest, "in_INFO_ROB_EMPTY");
     697      }
     698#endif
    665699    }
    666700

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

    r122 r123  
    3636        DELETE2_SIGNAL( in_RENAME_IN_OPERATION         ,_param->_nb_front_end, _param->_nb_inst_decod[it1],_param->_size_operation             );
    3737        DELETE2_SIGNAL( in_RENAME_IN_NO_EXECUTE        ,_param->_nb_front_end, _param->_nb_inst_decod[it1],1                                   );
     38//      DELETE2_SIGNAL( in_RENAME_IN_HAVE_EVENT        ,_param->_nb_front_end, _param->_nb_inst_decod[it1],1                                   );
     39        DELETE2_SIGNAL( in_RENAME_IN_LAST_EVENT        ,_param->_nb_front_end, _param->_nb_inst_decod[it1],1                                   );
    3840        DELETE2_SIGNAL( in_RENAME_IN_IS_DELAY_SLOT     ,_param->_nb_front_end, _param->_nb_inst_decod[it1],1                                   );
    3941#ifdef DEBUG
    … …  
    6466        DELETE1_SIGNAL(out_INSERT_OPERATION            ,_param->_nb_inst_insert,_param->_size_operation             );
    6567        DELETE1_SIGNAL(out_INSERT_NO_EXECUTE           ,_param->_nb_inst_insert,1                                   );
     68        DELETE1_SIGNAL(out_INSERT_LAST_EVENT           ,_param->_nb_inst_insert,1                                   );
    6669        DELETE1_SIGNAL(out_INSERT_IS_DELAY_SLOT        ,_param->_nb_inst_insert,1                                   );
    6770#ifdef DEBUG
    … …  
    129132        DELETE2_SIGNAL(out_RETIRE_EVENT_ACK            ,_param->_nb_front_end, _param->_nb_context[it1],1);
    130133        DELETE2_SIGNAL( in_RETIRE_EVENT_STATE          ,_param->_nb_front_end, _param->_nb_context[it1],_param->_size_event_state);
    131         DELETE2_SIGNAL( in_RETIRE_EVENT_FLUSH          ,_param->_nb_front_end, _param->_nb_context[it1],1);
     134//         DELETE2_SIGNAL( in_RETIRE_EVENT_FLUSH          ,_param->_nb_front_end, _param->_nb_context[it1],1);
    132135        DELETE2_SIGNAL( in_RETIRE_EVENT_STOP           ,_param->_nb_front_end, _param->_nb_context[it1],1);
    133136       
    134137        DELETE2_SIGNAL(in_SPR_READ_SR                  ,_param->_nb_front_end, _param->_nb_context[it1],_param->_size_spr);
     138
     139#ifdef DEBUG_TEST
     140        DELETE0_SIGNAL( in_INFO_ROB_EMPTY  ,1);
     141#endif
    135142      }
    136143    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   

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

    r88 r123  
    3939    usage_environment(_usage);
    4040
    41 #if DEBUG_Core == true
    42     log_printf(INFO,Core,FUNCTION,_("<%s> Parameters"),_name.c_str());
     41// #if DEBUG_Core == true
     42//     log_printf(INFO,Core,FUNCTION,_("<%s> Parameters"),_name.c_str());
    4343
    44     std::cout << *param << std::endl;
    45 #endif   
     44//     std::cout << *param << std::endl;
     45// #endif   
    4646
    4747    log_printf(INFO,Special_Register_unit,FUNCTION,_("<%s> : Allocation"),_name.c_str());

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

    r98 r123  
    2424    log_function(Special_Register_unit,FUNCTION,_name.c_str());
    2525
     26    if (PORT_READ(in_NRESET))
     27      {
    2628    // ===================================================================
    2729    // =====[ SPR_ACCESS ]================================================
    … …  
    7274          PORT_WRITE(out_SPR_ACCESS_INVALID [i], not valid);
    7375        }
     76      }
     77//     else
     78//       {
     79
     80//       }
    7481   
    7582    log_end(Special_Register_unit,FUNCTION);

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

    r98 r123  
    2424    log_function(Special_Register_unit,FUNCTION,_name.c_str());
    2525
     26//     if (PORT_READ(in_NRESET))
     27      {
    2628    // ===================================================================
    2729    // =====[ SPR_READ ]==================================================
    … …  
    3436//        PORT_WRITE(out_SPR_READ_SR [i][j],sr->read());
    3537//      }
     38      }
    3639
    3740    log_end(Special_Register_unit,FUNCTION);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/include/OOO_Engine.h

    r122 r123  
    7676  public    : SC_IN (Toperation_t      )  ***  in_RENAME_OPERATION                 ;//[nb_front_end][nb_inst_decod]
    7777  public    : SC_IN (Tcontrol_t        )  ***  in_RENAME_NO_EXECUTE                ;//[nb_front_end][nb_inst_decod]
     78//public    : SC_IN (Tcontrol_t        )  ***  in_RENAME_HAVE_EVENT                ;//[nb_front_end][nb_inst_decod]
     79  public    : SC_IN (Tcontrol_t        )  ***  in_RENAME_LAST_EVENT                ;//[nb_front_end][nb_inst_decod]
    7880  public    : SC_IN (Tcontrol_t        )  ***  in_RENAME_IS_DELAY_SLOT             ;//[nb_front_end][nb_inst_decod]
    7981#ifdef DEBUG

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

    r88 r123  
    3838    usage_environment(_usage);
    3939
    40 #if DEBUG_OOO_Engine == true
    41     log_printf(TRACE,OOO_Engine,FUNCTION,_("<%s> Parameters"),_name.c_str());
     40// #if DEBUG_OOO_Engine == true
     41//     log_printf(TRACE,OOO_Engine,FUNCTION,_("<%s> Parameters"),_name.c_str());
    4242
    43     std::cout << *param << std::endl;
    44 #endif
     43//     std::cout << *param << std::endl;
     44// #endif
    4545
    4646    log_printf(INFO,OOO_Engine,FUNCTION,_("<%s> Allocation"),_name.c_str());

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

    r122 r123  
    6565      _ALLOC2_SIGNAL_IN ( in_RENAME_OPERATION                 ,"OPERATION"                 ,Toperation_t      ,_param->_size_operation              ,_param->_nb_front_end,_param->_nb_inst_decod[it1]);
    6666      _ALLOC2_SIGNAL_IN ( in_RENAME_NO_EXECUTE                ,"NO_EXECUTE"                ,Tcontrol_t        ,1                                    ,_param->_nb_front_end,_param->_nb_inst_decod[it1]);
     67//    _ALLOC2_SIGNAL_IN ( in_RENAME_HAVE_EVENT                ,"HAVE_EVENT"                ,Tcontrol_t        ,1                                    ,_param->_nb_front_end,_param->_nb_inst_decod[it1]);
     68      _ALLOC2_SIGNAL_IN ( in_RENAME_LAST_EVENT                ,"LAST_EVENT"                ,Tcontrol_t        ,1                                    ,_param->_nb_front_end,_param->_nb_inst_decod[it1]);
    6769      _ALLOC2_SIGNAL_IN ( in_RENAME_IS_DELAY_SLOT             ,"IS_DELAY_SLOT"             ,Tcontrol_t        ,1                                    ,_param->_nb_front_end,_param->_nb_inst_decod[it1]);
    6870#ifdef DEBUG
    … …  
    441443                    PORT_MAP(_component,src , "in_RENAME_IN_"+toString(x)+"_"+toString(k)+"_NO_EXECUTE"   ,
    442444                                        dest, "in_RENAME_"   +toString(j)+"_"+toString(k)+"_NO_EXECUTE"   );
     445//                     PORT_MAP(_component,src , "in_RENAME_IN_"+toString(x)+"_"+toString(k)+"_HAVE_EVENT"   ,
     446//                                         dest, "in_RENAME_"   +toString(j)+"_"+toString(k)+"_HAVE_EVENT"   );
     447                    PORT_MAP(_component,src , "in_RENAME_IN_"+toString(x)+"_"+toString(k)+"_LAST_EVENT"   ,
     448                                        dest, "in_RENAME_"   +toString(j)+"_"+toString(k)+"_LAST_EVENT"   );
    443449                    PORT_MAP(_component,src , "in_RENAME_IN_"+toString(x)+"_"+toString(k)+"_IS_DELAY_SLOT",
    444450                                        dest, "in_RENAME_"   +toString(j)+"_"+toString(k)+"_IS_DELAY_SLOT");
    … …  
    511517            COMPONENT_MAP(_component,src ,"out_INSERT_"+toString(j)                +"_IS_DELAY_SLOT" ,
    512518                                     dest, "in_INSERT_"+toString(i)+"_"+toString(j)+"_IS_DELAY_SLOT" );
     519//             COMPONENT_MAP(_component,src ,"out_INSERT_"+toString(j)                +"_HAVE_EVENT"    ,
     520//                                      dest, "in_INSERT_"+toString(i)+"_"+toString(j)+"_HAVE_EVENT"    );
     521            COMPONENT_MAP(_component,src ,"out_INSERT_"+toString(j)                +"_LAST_EVENT"    ,
     522                                     dest, "in_INSERT_"+toString(i)+"_"+toString(j)+"_LAST_EVENT"    );
    513523#ifdef DEBUG
    514524            COMPONENT_MAP(_component,src ,"out_INSERT_"+toString(j)                +"_ADDRESS"       ,
    … …  
    682692                    COMPONENT_MAP(_component,src , "in_RETIRE_EVENT_"+toString(x)+"_"+toString(k)+"_STATE",
    683693                                             dest,"out_RETIRE_EVENT_"+toString(j)+"_"+toString(k)+"_STATE");
    684                     COMPONENT_MAP(_component,src , "in_RETIRE_EVENT_"+toString(x)+"_"+toString(k)+"_FLUSH",
    685                                              dest,"out_RETIRE_EVENT_"+toString(j)+"_"+toString(k)+"_FLUSH");
     694//                     COMPONENT_MAP(_component,src , "in_RETIRE_EVENT_"+toString(x)+"_"+toString(k)+"_FLUSH",
     695//                                              dest,"out_RETIRE_EVENT_"+toString(j)+"_"+toString(k)+"_FLUSH");
    686696                    COMPONENT_MAP(_component,src , "in_RETIRE_EVENT_"+toString(x)+"_"+toString(k)+"_STOP",
    687697                                             dest,"out_RETIRE_EVENT_"+toString(j)+"_"+toString(k)+"_STOP");
    … …  
    715725              }
    716726        }
     727
     728        // ~~~~~[ Interface : "info" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     729#ifdef DEBUG_TEST
     730        {
     731          dest = _name+"_commit_unit";
     732                   
     733#ifdef POSITION
     734          _component->interface_map (src ,"info",
     735                                     dest,"info");
     736#endif
     737          COMPONENT_MAP(_component,src , "in_INFO_ROB_EMPTY",
     738                                   dest,"out_INFO_ROB_EMPTY");
     739        }
     740#endif
    717741      }
    718742

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

    r122 r123  
    3535        DELETE2_SIGNAL( in_RENAME_OPERATION                 ,_param->_nb_front_end,_param->_nb_inst_decod[it1],_param->_size_operation              );
    3636        DELETE2_SIGNAL( in_RENAME_NO_EXECUTE                ,_param->_nb_front_end,_param->_nb_inst_decod[it1],1                                    );
     37//      DELETE2_SIGNAL( in_RENAME_HAVE_EVENT                ,_param->_nb_front_end,_param->_nb_inst_decod[it1],1                                    );
     38        DELETE2_SIGNAL( in_RENAME_LAST_EVENT                ,_param->_nb_front_end,_param->_nb_inst_decod[it1],1                                    );
    3739        DELETE2_SIGNAL( in_RENAME_IS_DELAY_SLOT             ,_param->_nb_front_end,_param->_nb_inst_decod[it1],1                                    );
    3840#ifdef DEBUG
Note: See TracChangeset for help on using the changeset viewer.