Ignore:
Timestamp:
Mar 18, 2009, 11:36:26 PM (15 years ago)
Author:
rosiere
Message:

1) Stat_list : fix retire old and new register bug
2) Stat_list : remove read_counter and valid flag, because validation of destination is in retire step (not in commit step)
3) Model : add class Model (cf Morpheo.sim)
4) Allocation : alloc_interface_begin and alloc_interface_end to delete temporary array.
5) Script : add distexe.sh
6) Add Comparator, Multiplier, Divider. But this component are not implemented
7) Software : add Dhrystone

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

Legend:

Unmodified
Added
Removed

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

    r110 r112  
    153153  ALLOC1_SC_SIGNAL(out_BRANCH_COMPLETE_NO_SEQUENCE    ,"out_BRANCH_COMPLETE_NO_SEQUENCE    ",Tcontrol_t        ,_param->_nb_inst_branch_complete);
    154154  ALLOC1_SC_SIGNAL( in_BRANCH_COMPLETE_MISS_PREDICTION," in_BRANCH_COMPLETE_MISS_PREDICTION",Tcontrol_t        ,_param->_nb_inst_branch_complete);
    155   ALLOC_SC_SIGNAL (out_UPDATE_VAL                      ,"out_UPDATE_VAL                      ",Tcontrol_t        );
    156   ALLOC_SC_SIGNAL ( in_UPDATE_ACK                      ," in_UPDATE_ACK                      ",Tcontrol_t        );
    157   ALLOC_SC_SIGNAL (out_UPDATE_CONTEXT_ID               ,"out_UPDATE_CONTEXT_ID               ",Tcontext_t        );
    158   ALLOC_SC_SIGNAL (out_UPDATE_FRONT_END_ID             ,"out_UPDATE_FRONT_END_ID             ",Tcontext_t        );
    159   ALLOC_SC_SIGNAL (out_UPDATE_DEPTH                    ,"out_UPDATE_DEPTH                    ",Tdepth_t          );
    160   ALLOC_SC_SIGNAL (out_UPDATE_TYPE                     ,"out_UPDATE_TYPE                     ",Tevent_type_t     );
    161   ALLOC_SC_SIGNAL (out_UPDATE_IS_DELAY_SLOT            ,"out_UPDATE_IS_DELAY_SLOT            ",Tcontrol_t        );
    162   ALLOC_SC_SIGNAL (out_UPDATE_ADDRESS                  ,"out_UPDATE_ADDRESS                  ",Taddress_t        );
    163   ALLOC_SC_SIGNAL (out_UPDATE_ADDRESS_EPCR_VAL         ,"out_UPDATE_ADDRESS_EPCR_VAL         ",Tcontrol_t        );
    164   ALLOC_SC_SIGNAL (out_UPDATE_ADDRESS_EPCR             ,"out_UPDATE_ADDRESS_EPCR             ",Taddress_t        );
    165   ALLOC_SC_SIGNAL (out_UPDATE_ADDRESS_EEAR_VAL         ,"out_UPDATE_ADDRESS_EEAR_VAL         ",Tcontrol_t        );
    166   ALLOC_SC_SIGNAL (out_UPDATE_ADDRESS_EEAR             ,"out_UPDATE_ADDRESS_EEAR             ",Tgeneral_data_t   );
     155  ALLOC0_SC_SIGNAL(out_UPDATE_VAL                      ,"out_UPDATE_VAL                      ",Tcontrol_t        );
     156  ALLOC0_SC_SIGNAL( in_UPDATE_ACK                      ," in_UPDATE_ACK                      ",Tcontrol_t        );
     157  ALLOC0_SC_SIGNAL(out_UPDATE_CONTEXT_ID               ,"out_UPDATE_CONTEXT_ID               ",Tcontext_t        );
     158  ALLOC0_SC_SIGNAL(out_UPDATE_FRONT_END_ID             ,"out_UPDATE_FRONT_END_ID             ",Tcontext_t        );
     159  ALLOC0_SC_SIGNAL(out_UPDATE_DEPTH                    ,"out_UPDATE_DEPTH                    ",Tdepth_t          );
     160  ALLOC0_SC_SIGNAL(out_UPDATE_TYPE                     ,"out_UPDATE_TYPE                     ",Tevent_type_t     );
     161  ALLOC0_SC_SIGNAL(out_UPDATE_IS_DELAY_SLOT            ,"out_UPDATE_IS_DELAY_SLOT            ",Tcontrol_t        );
     162  ALLOC0_SC_SIGNAL(out_UPDATE_ADDRESS                  ,"out_UPDATE_ADDRESS                  ",Taddress_t        );
     163  ALLOC0_SC_SIGNAL(out_UPDATE_ADDRESS_EPCR_VAL         ,"out_UPDATE_ADDRESS_EPCR_VAL         ",Tcontrol_t        );
     164  ALLOC0_SC_SIGNAL(out_UPDATE_ADDRESS_EPCR             ,"out_UPDATE_ADDRESS_EPCR             ",Taddress_t        );
     165  ALLOC0_SC_SIGNAL(out_UPDATE_ADDRESS_EEAR_VAL         ,"out_UPDATE_ADDRESS_EEAR_VAL         ",Tcontrol_t        );
     166  ALLOC0_SC_SIGNAL(out_UPDATE_ADDRESS_EEAR             ,"out_UPDATE_ADDRESS_EEAR             ",Tgeneral_data_t   );
    167167
    168168  ALLOC2_SC_SIGNAL( in_EVENT_VAL             ," in_EVENT_VAL             ",Tcontrol_t,_param->_nb_front_end,_param->_nb_context[it1]);
    … …  
    304304  INSTANCE1_SC_SIGNAL(_Commit_unit,out_BRANCH_COMPLETE_NO_SEQUENCE    ,_param->_nb_inst_branch_complete);
    305305  INSTANCE1_SC_SIGNAL(_Commit_unit, in_BRANCH_COMPLETE_MISS_PREDICTION,_param->_nb_inst_branch_complete);
    306   INSTANCE_SC_SIGNAL (_Commit_unit,out_UPDATE_VAL                      );
    307   INSTANCE_SC_SIGNAL (_Commit_unit, in_UPDATE_ACK                      );
     306  INSTANCE0_SC_SIGNAL(_Commit_unit,out_UPDATE_VAL                      );
     307  INSTANCE0_SC_SIGNAL(_Commit_unit, in_UPDATE_ACK                      );
    308308  if (_param->_have_port_context_id)
    309   INSTANCE_SC_SIGNAL (_Commit_unit,out_UPDATE_CONTEXT_ID               );
     309  INSTANCE0_SC_SIGNAL(_Commit_unit,out_UPDATE_CONTEXT_ID               );
    310310  if (_param->_have_port_front_end_id)
    311   INSTANCE_SC_SIGNAL (_Commit_unit,out_UPDATE_FRONT_END_ID             );
     311  INSTANCE0_SC_SIGNAL(_Commit_unit,out_UPDATE_FRONT_END_ID             );
    312312  if (_param->_have_port_depth)
    313   INSTANCE_SC_SIGNAL (_Commit_unit,out_UPDATE_DEPTH                    );
    314   INSTANCE_SC_SIGNAL (_Commit_unit,out_UPDATE_TYPE                     );
    315   INSTANCE_SC_SIGNAL (_Commit_unit,out_UPDATE_IS_DELAY_SLOT            );
    316   INSTANCE_SC_SIGNAL (_Commit_unit,out_UPDATE_ADDRESS                  );
    317   INSTANCE_SC_SIGNAL (_Commit_unit,out_UPDATE_ADDRESS_EPCR_VAL         );
    318   INSTANCE_SC_SIGNAL (_Commit_unit,out_UPDATE_ADDRESS_EPCR             );
    319   INSTANCE_SC_SIGNAL (_Commit_unit,out_UPDATE_ADDRESS_EEAR_VAL         );
    320   INSTANCE_SC_SIGNAL (_Commit_unit,out_UPDATE_ADDRESS_EEAR             );
     313  INSTANCE0_SC_SIGNAL(_Commit_unit,out_UPDATE_DEPTH                    );
     314  INSTANCE0_SC_SIGNAL(_Commit_unit,out_UPDATE_TYPE                     );
     315  INSTANCE0_SC_SIGNAL(_Commit_unit,out_UPDATE_IS_DELAY_SLOT            );
     316  INSTANCE0_SC_SIGNAL(_Commit_unit,out_UPDATE_ADDRESS                  );
     317  INSTANCE0_SC_SIGNAL(_Commit_unit,out_UPDATE_ADDRESS_EPCR_VAL         );
     318  INSTANCE0_SC_SIGNAL(_Commit_unit,out_UPDATE_ADDRESS_EPCR             );
     319  INSTANCE0_SC_SIGNAL(_Commit_unit,out_UPDATE_ADDRESS_EEAR_VAL         );
     320  INSTANCE0_SC_SIGNAL(_Commit_unit,out_UPDATE_ADDRESS_EEAR             );
    321321
    322322  INSTANCE2_SC_SIGNAL(_Commit_unit, in_EVENT_VAL                       ,_param->_nb_front_end, _param->_nb_context[it1]);
    … …  
    708708  DELETE1_SC_SIGNAL(out_BRANCH_COMPLETE_NO_SEQUENCE    ,_param->_nb_inst_branch_complete);
    709709  DELETE1_SC_SIGNAL( in_BRANCH_COMPLETE_MISS_PREDICTION,_param->_nb_inst_branch_complete);
    710   DELETE_SC_SIGNAL (out_UPDATE_VAL                      );
    711   DELETE_SC_SIGNAL ( in_UPDATE_ACK                      );
    712   DELETE_SC_SIGNAL (out_UPDATE_CONTEXT_ID               );
    713   DELETE_SC_SIGNAL (out_UPDATE_FRONT_END_ID             );
    714   DELETE_SC_SIGNAL (out_UPDATE_DEPTH                    );
    715   DELETE_SC_SIGNAL (out_UPDATE_TYPE                     );
    716   DELETE_SC_SIGNAL (out_UPDATE_IS_DELAY_SLOT            );
    717   DELETE_SC_SIGNAL (out_UPDATE_ADDRESS                  );
    718   DELETE_SC_SIGNAL (out_UPDATE_ADDRESS_EPCR_VAL         );
    719   DELETE_SC_SIGNAL (out_UPDATE_ADDRESS_EPCR             );
    720   DELETE_SC_SIGNAL (out_UPDATE_ADDRESS_EEAR_VAL         );
    721   DELETE_SC_SIGNAL (out_UPDATE_ADDRESS_EEAR             );
     710  DELETE0_SC_SIGNAL(out_UPDATE_VAL                      );
     711  DELETE0_SC_SIGNAL( in_UPDATE_ACK                      );
     712  DELETE0_SC_SIGNAL(out_UPDATE_CONTEXT_ID               );
     713  DELETE0_SC_SIGNAL(out_UPDATE_FRONT_END_ID             );
     714  DELETE0_SC_SIGNAL(out_UPDATE_DEPTH                    );
     715  DELETE0_SC_SIGNAL(out_UPDATE_TYPE                     );
     716  DELETE0_SC_SIGNAL(out_UPDATE_IS_DELAY_SLOT            );
     717  DELETE0_SC_SIGNAL(out_UPDATE_ADDRESS                  );
     718  DELETE0_SC_SIGNAL(out_UPDATE_ADDRESS_EPCR_VAL         );
     719  DELETE0_SC_SIGNAL(out_UPDATE_ADDRESS_EPCR             );
     720  DELETE0_SC_SIGNAL(out_UPDATE_ADDRESS_EEAR_VAL         );
     721  DELETE0_SC_SIGNAL(out_UPDATE_ADDRESS_EEAR             );
    722722
    723723  DELETE2_SC_SIGNAL( in_EVENT_VAL                       ,_param->_nb_front_end, _param->_nb_context[it1]);

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

    r111 r112  
    238238  private   : Tevent_state_t               ** reg_EVENT_STATE                      ;//[nb_front_end][nb_context]
    239239  private   : bool                         ** reg_EVENT_FLUSH                      ;//[nb_front_end][nb_context]
     240  private   : bool                         ** reg_EVENT_STOP                       ;//[nb_front_end][nb_context]
    240241
    241242//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

    r111 r112  
    3535      ROB_STORE_HEAD_KO              , //
    3636      ROB_OTHER_WAIT_END             , //
    37       ROB_MISS_WAIT_END              , //
     37
     38      ROB_EVENT_WAIT_END             , //
     39
    3840      ROB_END_OK_SPECULATIVE         , //
    3941      ROB_END_OK                     , //
    … …  
    4951      ROB_END_EXCEPTION_UPDATE       , //
    5052      ROB_END_EXCEPTION                //
     53
    5154    } rob_state_t;
    5255
    … …  
    121124      case morpheo::behavioural::core::multi_ooo_engine::ooo_engine::commit_unit::ROB_STORE_HEAD_KO              : return "ROB_STORE_HEAD_KO"               ; break;
    122125      case morpheo::behavioural::core::multi_ooo_engine::ooo_engine::commit_unit::ROB_OTHER_WAIT_END             : return "ROB_OTHER_WAIT_END"              ; break;
    123       case morpheo::behavioural::core::multi_ooo_engine::ooo_engine::commit_unit::ROB_MISS_WAIT_END              : return "ROB_MISS_WAIT_END"               ; break;
     126      case morpheo::behavioural::core::multi_ooo_engine::ooo_engine::commit_unit::ROB_EVENT_WAIT_END             : return "ROB_EVENT_WAIT_END"              ; break;
    124127      case morpheo::behavioural::core::multi_ooo_engine::ooo_engine::commit_unit::ROB_END_OK_SPECULATIVE         : return "ROB_END_OK_SPECULATIVE"          ; break;
    125128      case morpheo::behavioural::core::multi_ooo_engine::ooo_engine::commit_unit::ROB_END_OK                     : return "ROB_END_OK"                      ; break;

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

    r110 r112  
    118118# ifdef SYSTEMCASS_SPECIFIC
    119119        // List dependency information
    120         for (uint32_t i=0; i<_param->_nb_rename_unit; i++)
    121           for (uint32_t j=0; j<_param->_nb_inst_insert[i]; j++)
    122             for (uint32_t x=0; x<_param->_nb_rename_unit; x++)
    123               for (uint32_t y=0; y<_param->_nb_inst_insert[x]; y++)
    124                 {
    125                   (*(out_INSERT_ACK       [i][j])) (*(in_INSERT_VAL [x][y]));
    126                   if (_param->_have_port_rob_ptr)
    127                   (*(out_INSERT_PACKET_ID [i][j])) (*(in_INSERT_VAL [x][y]));
    128                 }
     120//      for (uint32_t i=0; i<_param->_nb_rename_unit; i++)
     121//        for (uint32_t j=0; j<_param->_nb_inst_insert[i]; j++)
     122//          for (uint32_t x=0; x<_param->_nb_rename_unit; x++)
     123//            for (uint32_t y=0; y<_param->_nb_inst_insert[x]; y++)
     124//              {
     125//                (*(out_INSERT_ACK       [i][j])) (*(in_INSERT_VAL [x][y]));
     126//                if (_param->_have_port_rob_ptr)
     127//                (*(out_INSERT_PACKET_ID [i][j])) (*(in_INSERT_VAL [x][y]));
     128//              }
    129129# endif   
    130130

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

    r111 r112  
    5858    // ~~~~~[ Interface "insert" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    5959    {
    60       ALLOC2_INTERFACE("insert", IN, SOUTH, _("Interface with rename_unit."),_param->_nb_rename_unit,_param->_nb_inst_insert[it1]);
     60      ALLOC2_INTERFACE_BEGIN("insert", IN, SOUTH, _("Interface with rename_unit."),_param->_nb_rename_unit,_param->_nb_inst_insert[it1]);
    6161
    6262      _ALLOC2_VALACK_IN ( in_INSERT_VAL                     ,VAL,_param->_nb_rename_unit,_param->_nb_inst_insert[it1]);
    … …  
    9696      _ALLOC2_SIGNAL_IN ( in_INSERT_NUM_REG_RE_PHY_OLD      ,"num_reg_re_phy_old"   ,Tspecial_address_t,_param->_size_special_register      ,_param->_nb_rename_unit,_param->_nb_inst_insert[it1]);
    9797      _ALLOC2_SIGNAL_IN ( in_INSERT_NUM_REG_RE_PHY_NEW      ,"num_reg_re_phy_new"   ,Tspecial_address_t,_param->_size_special_register      ,_param->_nb_rename_unit,_param->_nb_inst_insert[it1]);
     98
     99      ALLOC2_INTERFACE_END(_param->_nb_rename_unit,_param->_nb_inst_insert[it1]);
    98100    }
    99101
    100102    // ~~~~~[ Interface "retire" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    101103    {
    102       ALLOC2_INTERFACE("retire",OUT,SOUTH, _("Interface to update rename_unit."),_param->_nb_rename_unit,_param->_nb_inst_retire[it1]);
     104      ALLOC2_INTERFACE_BEGIN("retire",OUT,SOUTH, _("Interface to update rename_unit."),_param->_nb_rename_unit,_param->_nb_inst_retire[it1]);
    103105     
    104106      _ALLOC2_VALACK_OUT(out_RETIRE_VAL                     ,VAL,_param->_nb_rename_unit,_param->_nb_inst_retire[it1]);
    … …  
    125127      _ALLOC2_SIGNAL_OUT(out_RETIRE_NUM_REG_RE_PHY_OLD      ,"num_reg_re_phy_old"   ,Tspecial_address_t,_param->_size_special_register      ,_param->_nb_rename_unit,_param->_nb_inst_retire[it1]);
    126128      _ALLOC2_SIGNAL_OUT(out_RETIRE_NUM_REG_RE_PHY_NEW      ,"num_reg_re_phy_new"   ,Tspecial_address_t,_param->_size_special_register      ,_param->_nb_rename_unit,_param->_nb_inst_retire[it1]);
     129
     130      ALLOC2_INTERFACE_END(_param->_nb_rename_unit,_param->_nb_inst_retire[it1]);
    127131    }
    128132
    129133    // ~~~~~[ Interface : "retire_event" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    130134    {
    131       ALLOC2_INTERFACE("retire_event",OUT,SOUTH, _("Interface to update rename_unit."),_param->_nb_front_end,_param->_nb_context[it1]);
     135      ALLOC2_INTERFACE_BEGIN("retire_event",OUT,SOUTH, _("Interface to update rename_unit."),_param->_nb_front_end,_param->_nb_context[it1]);
    132136   
    133137      _ALLOC2_VALACK_OUT(out_RETIRE_EVENT_VAL               ,VAL,_param->_nb_front_end,_param->_nb_context[it1]);
    134138      _ALLOC2_VALACK_IN ( in_RETIRE_EVENT_ACK               ,ACK,_param->_nb_front_end,_param->_nb_context[it1]);
    135139      _ALLOC2_SIGNAL_OUT(out_RETIRE_EVENT_STATE             ,"state"                ,Tevent_state_t    ,_param->_size_event_state           ,_param->_nb_front_end,_param->_nb_context[it1]);
     140
     141      ALLOC2_INTERFACE_END(_param->_nb_front_end,_param->_nb_context[it1]);
    136142    }
    137143
    138144    // ~~~~~[ Interface : "commit" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    139145    {
    140       ALLOC1_INTERFACE("commit",IN,EAST,_("End of execute."),_param->_nb_inst_commit);
     146      ALLOC1_INTERFACE_BEGIN("commit",IN,EAST,_("End of execute."),_param->_nb_inst_commit);
    141147
    142148      ALLOC1_VALACK_IN ( in_COMMIT_VAL               ,VAL);
    … …  
    152158//    ALLOC1_SIGNAL_OUT(out_COMMIT_NUM_REG_RD        ,"num_reg_rd" ,Tgeneral_address_t,_param->_size_general_register+_param->_size_rename_unit_id);
    153159      ALLOC1_SIGNAL_OUT(out_COMMIT_NUM_REG_RD        ,"num_reg_rd" ,Tgeneral_address_t,_param->_size_general_register);
     160
     161      ALLOC1_INTERFACE_END(_param->_nb_inst_commit);
    154162    }
    155163
    156164    // ~~~~~[ Interface : "reexecute" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    157165    {
    158       ALLOC1_INTERFACE("reexecute",OUT,EAST,_("Interface to reexecute an instruction (store)"),_param->_nb_inst_reexecute);
     166      ALLOC1_INTERFACE_BEGIN("reexecute",OUT,EAST,_("Interface to reexecute an instruction (store)"),_param->_nb_inst_reexecute);
    159167
    160168      ALLOC1_VALACK_OUT(out_REEXECUTE_VAL                  ,VAL);
    … …  
    166174      ALLOC1_SIGNAL_OUT(out_REEXECUTE_TYPE                 ,"type"                 ,Ttype_t           ,_param->_size_type);
    167175      ALLOC1_SIGNAL_OUT(out_REEXECUTE_STORE_QUEUE_PTR_WRITE,"store_queue_ptr_write",Tlsq_ptr_t        ,_param->_size_store_queue_ptr);
     176
     177      ALLOC1_INTERFACE_END(_param->_nb_inst_reexecute);
    168178    }
    169179
    170180    // ~~~~~[ Interface : "branch_complete" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    171181    {
    172       ALLOC1_INTERFACE("branch_complete",OUT,WEST,_("Interface to reexecute an instruction (store)"),_param->_nb_inst_branch_complete);
     182      ALLOC1_INTERFACE_BEGIN("branch_complete",OUT,WEST,_("Interface to reexecute an instruction (store)"),_param->_nb_inst_branch_complete);
    173183
    174184      ALLOC1_VALACK_OUT(out_BRANCH_COMPLETE_VAL            ,VAL);
    … …  
    181191      ALLOC1_SIGNAL_OUT(out_BRANCH_COMPLETE_NO_SEQUENCE    ,"no_sequence"    ,Tcontrol_t         ,1);
    182192      ALLOC1_SIGNAL_IN ( in_BRANCH_COMPLETE_MISS_PREDICTION,"miss_prediction",Tcontrol_t         ,1);
     193
     194      ALLOC1_INTERFACE_END(_param->_nb_inst_branch_complete);
    183195    }
    184196
    185197    // ~~~~~[ Interface : "update" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    186198    {
    187       ALLOC_INTERFACE("update", OUT, WEST,_("Interface with to Context State."));
    188 
    189       ALLOC_VALACK_OUT(out_UPDATE_VAL                      ,VAL);
    190       ALLOC_VALACK_IN ( in_UPDATE_ACK                      ,ACK);
    191       ALLOC_SIGNAL_OUT(out_UPDATE_CONTEXT_ID               ,"context_id"      ,Tcontext_t         ,_param->_size_context_id);
    192       ALLOC_SIGNAL_OUT(out_UPDATE_FRONT_END_ID             ,"front_end_id"    ,Tcontext_t         ,_param->_size_front_end_id);
    193       ALLOC_SIGNAL_OUT(out_UPDATE_DEPTH                    ,"depth"           ,Tdepth_t           ,_param->_size_depth    );
    194       ALLOC_SIGNAL_OUT(out_UPDATE_TYPE                     ,"type"            ,Tevent_type_t      ,_param->_size_event_type);
    195       ALLOC_SIGNAL_OUT(out_UPDATE_IS_DELAY_SLOT            ,"is_delay_slot"   ,Tcontrol_t         ,1);
    196       ALLOC_SIGNAL_OUT(out_UPDATE_ADDRESS                  ,"address"         ,Taddress_t         ,_param->_size_instruction_address);
    197       ALLOC_SIGNAL_OUT(out_UPDATE_ADDRESS_EPCR_VAL         ,"address_epcr_val",Tcontrol_t         ,1);
    198       ALLOC_SIGNAL_OUT(out_UPDATE_ADDRESS_EPCR             ,"address_epcr"    ,Taddress_t         ,_param->_size_instruction_address);
    199       ALLOC_SIGNAL_OUT(out_UPDATE_ADDRESS_EEAR_VAL         ,"address_eear_val",Tcontrol_t         ,1);
    200       ALLOC_SIGNAL_OUT(out_UPDATE_ADDRESS_EEAR             ,"address_eear"    ,Tgeneral_data_t    ,_param->_size_general_data);
     199      ALLOC0_INTERFACE_BEGIN("update", OUT, WEST,_("Interface with to Context State."));
     200
     201      ALLOC0_VALACK_OUT(out_UPDATE_VAL                      ,VAL);
     202      ALLOC0_VALACK_IN ( in_UPDATE_ACK                      ,ACK);
     203      ALLOC0_SIGNAL_OUT(out_UPDATE_CONTEXT_ID               ,"context_id"      ,Tcontext_t         ,_param->_size_context_id);
     204      ALLOC0_SIGNAL_OUT(out_UPDATE_FRONT_END_ID             ,"front_end_id"    ,Tcontext_t         ,_param->_size_front_end_id);
     205      ALLOC0_SIGNAL_OUT(out_UPDATE_DEPTH                    ,"depth"           ,Tdepth_t           ,_param->_size_depth    );
     206      ALLOC0_SIGNAL_OUT(out_UPDATE_TYPE                     ,"type"            ,Tevent_type_t      ,_param->_size_event_type);
     207      ALLOC0_SIGNAL_OUT(out_UPDATE_IS_DELAY_SLOT            ,"is_delay_slot"   ,Tcontrol_t         ,1);
     208      ALLOC0_SIGNAL_OUT(out_UPDATE_ADDRESS                  ,"address"         ,Taddress_t         ,_param->_size_instruction_address);
     209      ALLOC0_SIGNAL_OUT(out_UPDATE_ADDRESS_EPCR_VAL         ,"address_epcr_val",Tcontrol_t         ,1);
     210      ALLOC0_SIGNAL_OUT(out_UPDATE_ADDRESS_EPCR             ,"address_epcr"    ,Taddress_t         ,_param->_size_instruction_address);
     211      ALLOC0_SIGNAL_OUT(out_UPDATE_ADDRESS_EEAR_VAL         ,"address_eear_val",Tcontrol_t         ,1);
     212      ALLOC0_SIGNAL_OUT(out_UPDATE_ADDRESS_EEAR             ,"address_eear"    ,Tgeneral_data_t    ,_param->_size_general_data);
     213
     214      ALLOC0_INTERFACE_END();
    201215    }
    202216
    203217    // ~~~~~[ Interface "event" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    204218    {
    205       ALLOC2_INTERFACE("event",IN,WEST,_("Interface with Context State (event)."),_param->_nb_front_end, _param->_nb_context[it1]);
     219      ALLOC2_INTERFACE_BEGIN("event",IN,WEST,_("Interface with Context State (event)."),_param->_nb_front_end, _param->_nb_context[it1]);
    206220
    207221      _ALLOC2_VALACK_IN ( in_EVENT_VAL             , VAL                                                           ,_param->_nb_front_end, _param->_nb_context[it1]);
    … …  
    211225      _ALLOC2_SIGNAL_IN ( in_EVENT_ADDRESS_NEXT_VAL,"ADDRESS_NEXT_VAL",Tcontrol_t,1                                ,_param->_nb_front_end, _param->_nb_context[it1]);
    212226      _ALLOC2_SIGNAL_IN ( in_EVENT_IS_DS_TAKE      ,"IS_DS_TAKE"      ,Tcontrol_t,1                                ,_param->_nb_front_end, _param->_nb_context[it1]);
     227
     228      ALLOC2_INTERFACE_END(_param->_nb_front_end, _param->_nb_context[it1]);
    213229    } 
    214230
    215231    // ~~~~~[ Interface : "nb_inst" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    216232    {
    217       ALLOC2_INTERFACE("nb_inst",OUT,WEST,_("Interface with Context State (synchronization)."),_param->_nb_front_end, _param->_nb_context[it1]);
     233      ALLOC2_INTERFACE_BEGIN("nb_inst",OUT,WEST,_("Interface with Context State (synchronization)."),_param->_nb_front_end, _param->_nb_context[it1]);
    218234
    219235      _ALLOC2_SIGNAL_OUT(out_NB_INST_COMMIT_ALL             ,"commit_all",Tcounter_t         ,_param->_size_nb_inst_commit,_param->_nb_front_end, _param->_nb_context[it1]);
    220236      _ALLOC2_SIGNAL_OUT(out_NB_INST_COMMIT_MEM             ,"commit_mem",Tcounter_t         ,_param->_size_nb_inst_commit,_param->_nb_front_end, _param->_nb_context[it1]);
    221237      _ALLOC2_SIGNAL_IN ( in_NB_INST_DECOD_ALL              ,"decod_all" ,Tcounter_t         ,_param->_size_nb_inst_decod ,_param->_nb_front_end, _param->_nb_context[it1]);
     238
     239      ALLOC2_INTERFACE_END(_param->_nb_front_end, _param->_nb_context[it1]);
    222240    }
    223241
    224242    // ~~~~~[ Interface : "depth" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    225243    {
    226       ALLOC2_INTERFACE("depth",IN,WEST,_("Interface with Prediction unit."),_param->_nb_front_end, _param->_nb_context[it1]);
     244      ALLOC2_INTERFACE_BEGIN("depth",IN,WEST,_("Interface with Prediction unit."),_param->_nb_front_end, _param->_nb_context[it1]);
    227245
    228246      _ALLOC2_SIGNAL_IN ( in_DEPTH_MIN                     ,"min"      ,Tdepth_t           ,_param->_size_depth,_param->_nb_front_end, _param->_nb_context[it1]);
    229247      _ALLOC2_SIGNAL_IN ( in_DEPTH_MAX                     ,"max"      ,Tdepth_t           ,_param->_size_depth,_param->_nb_front_end, _param->_nb_context[it1]);
    230248      _ALLOC2_SIGNAL_IN ( in_DEPTH_FULL                    ,"full"     ,Tcontrol_t         ,1                  ,_param->_nb_front_end, _param->_nb_context[it1]);
     249
     250      ALLOC2_INTERFACE_END(_param->_nb_front_end, _param->_nb_context[it1]);
    231251    }
    232252
    … …  
    234254    // ~~~~~[ Interface : "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    235255    {
    236       ALLOC2_INTERFACE("spr_read",IN ,EAST,_("Interface with special register file (read)."),_param->_nb_front_end, _param->_nb_context[it1]);
     256      ALLOC2_INTERFACE_BEGIN("spr_read",IN ,EAST,_("Interface with special register file (read)."),_param->_nb_front_end, _param->_nb_context[it1]);
    237257
    238258      _ALLOC2_SIGNAL_IN ( in_SPR_READ_SR_OVE                ,"sr_ove"    ,Tcontrol_t         ,1,_param->_nb_front_end, _param->_nb_context[it1]);
     259
     260      ALLOC2_INTERFACE_END(_param->_nb_front_end, _param->_nb_context[it1]);
    239261    }
    240262
    241263    // ~~~~~[ Interface : "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    242264    {
    243       ALLOC2_INTERFACE("spr_write",OUT,EAST,_("Interface with special register file (write)."),_param->_nb_front_end, _param->_nb_context[it1]);
     265      ALLOC2_INTERFACE_BEGIN("spr_write",OUT,EAST,_("Interface with special register file (write)."),_param->_nb_front_end, _param->_nb_context[it1]);
    244266
    245267      _ALLOC2_VALACK_OUT(out_SPR_WRITE_VAL                    ,VAL,_param->_nb_front_end, _param->_nb_context[it1]);
    … …  
    251273      _ALLOC2_SIGNAL_OUT(out_SPR_WRITE_SR_OV_VAL              ,"sr_ov_val"   ,Tcontrol_t         ,1                         ,_param->_nb_front_end, _param->_nb_context[it1]);
    252274      _ALLOC2_SIGNAL_OUT(out_SPR_WRITE_SR_OV                  ,"sr_ov"       ,Tcontrol_t         ,1                         ,_param->_nb_front_end, _param->_nb_context[it1]);
     275
     276      ALLOC2_INTERFACE_END(_param->_nb_front_end, _param->_nb_context[it1]);
    253277    }
    254278
    … …  
    289313    ALLOC2(reg_EVENT_STATE          ,Tevent_state_t,_param->_nb_front_end,_param->_nb_context [it1]);
    290314    ALLOC2(reg_EVENT_FLUSH          ,bool          ,_param->_nb_front_end,_param->_nb_context [it1]);
     315    ALLOC2(reg_EVENT_STOP           ,bool          ,_param->_nb_front_end,_param->_nb_context [it1]);
    291316
    292317//  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

    r111 r112  
    124124        DELETE1_SIGNAL( in_BRANCH_COMPLETE_MISS_PREDICTION,_param->_nb_inst_branch_complete,1);
    125125
    126         DELETE_SIGNAL (out_UPDATE_VAL                      ,1                         );
    127         DELETE_SIGNAL ( in_UPDATE_ACK                      ,1                         );
    128         DELETE_SIGNAL (out_UPDATE_CONTEXT_ID               ,_param->_size_context_id  );
    129         DELETE_SIGNAL (out_UPDATE_FRONT_END_ID             ,_param->_size_front_end_id);
    130         DELETE_SIGNAL (out_UPDATE_DEPTH                    ,_param->_size_depth       );
    131         DELETE_SIGNAL (out_UPDATE_TYPE                     ,_param->_size_event_type  );
    132         DELETE_SIGNAL (out_UPDATE_IS_DELAY_SLOT            ,1                         );
    133         DELETE_SIGNAL (out_UPDATE_ADDRESS                  ,_param->_size_instruction_address     );
    134         DELETE_SIGNAL (out_UPDATE_ADDRESS_EPCR_VAL         ,1                         );
    135         DELETE_SIGNAL (out_UPDATE_ADDRESS_EPCR             ,_param->_size_instruction_address     );
    136         DELETE_SIGNAL (out_UPDATE_ADDRESS_EEAR_VAL         ,1                         );
    137         DELETE_SIGNAL (out_UPDATE_ADDRESS_EEAR             ,_param->_size_instruction_address     );
     126        DELETE0_SIGNAL(out_UPDATE_VAL                      ,1                         );
     127        DELETE0_SIGNAL( in_UPDATE_ACK                      ,1                         );
     128        DELETE0_SIGNAL(out_UPDATE_CONTEXT_ID               ,_param->_size_context_id  );
     129        DELETE0_SIGNAL(out_UPDATE_FRONT_END_ID             ,_param->_size_front_end_id);
     130        DELETE0_SIGNAL(out_UPDATE_DEPTH                    ,_param->_size_depth       );
     131        DELETE0_SIGNAL(out_UPDATE_TYPE                     ,_param->_size_event_type  );
     132        DELETE0_SIGNAL(out_UPDATE_IS_DELAY_SLOT            ,1                         );
     133        DELETE0_SIGNAL(out_UPDATE_ADDRESS                  ,_param->_size_instruction_address     );
     134        DELETE0_SIGNAL(out_UPDATE_ADDRESS_EPCR_VAL         ,1                         );
     135        DELETE0_SIGNAL(out_UPDATE_ADDRESS_EPCR             ,_param->_size_instruction_address     );
     136        DELETE0_SIGNAL(out_UPDATE_ADDRESS_EEAR_VAL         ,1                         );
     137        DELETE0_SIGNAL(out_UPDATE_ADDRESS_EEAR             ,_param->_size_instruction_address     );
    138138
    139139        DELETE2_SIGNAL( in_EVENT_VAL                       ,_param->_nb_front_end, _param->_nb_context[it1],1                    );
    … …  
    194194        DELETE2(reg_EVENT_STATE          ,_param->_nb_front_end,_param->_nb_context [it1]);
    195195        DELETE2(reg_EVENT_FLUSH          ,_param->_nb_front_end,_param->_nb_context [it1]);
     196        DELETE2(reg_EVENT_STOP           ,_param->_nb_front_end,_param->_nb_context [it1]);
    196197//      DELETE2(reg_PC_PREVIOUS          ,_param->_nb_front_end,_param->_nb_context [it1]);
    197198        DELETE2(reg_PC_CURRENT           ,_param->_nb_front_end,_param->_nb_context [it1]);

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

    r100 r112  
    3030#endif
    3131    bool       can_rename_select [_param->_nb_rename_unit];
    32    
    33     // Initialisation
     32    bool       event_stop;
     33   
     34//     Initialisation
     35    event_stop = false; // one signal for all context.
     36    for (uint32_t i=0; i<_param->_nb_front_end; ++i)
     37      for (uint32_t j=0; j<_param->_nb_context[i]; ++j)
     38        event_stop |= reg_EVENT_STOP [i][j];
    3439    for (uint32_t i=0; i<_param->_nb_bank; i++)
    3540      {
    … …  
    5257//     log_printf(TRACE,Commit_unit,FUNCTION,"  * reg_NUM_BANK_TAIL : %d",reg_NUM_BANK_TAIL);
    5358
    54     std::list<generic::priority::select_t> * select_insert = _priority_insert ->select(); // same select for all insert
    55     std::list<generic::priority::select_t>::iterator it=select_insert ->begin();
    56 
    57     // Scan all bank ...
    58     for (uint32_t i=0; i<_param->_nb_bank; i++)
     59    if (not event_stop)
    5960      {
    60         // compute the bank number (num_bank_tail is the older write slot)
    61         uint32_t num_bank = (reg_NUM_BANK_TAIL+i)%_param->_nb_bank;
    62 
    63 //      log_printf(TRACE,Commit_unit,FUNCTION,"  * BANK : %d", num_bank);
    64 //      log_printf(TRACE,Commit_unit,FUNCTION,"    * val  : %d", internal_BANK_INSERT_VAL [num_bank]);
    65 //      log_printf(TRACE,Commit_unit,FUNCTION,"    * full : %d", bank_full [num_bank]);
    66 
    67         // Scan all insert interface to find a valid transaction
    68         while (it!=select_insert ->end())
    69           {
    70             uint32_t num_rename_unit = it->grp;
    71             uint32_t num_inst_insert = it->elt;
    72 
    73             it++;
    74 
    75             log_printf(TRACE,Commit_unit,FUNCTION,"  * INSERT [%d][%d]", num_rename_unit,num_inst_insert);
    76 //          log_printf(TRACE,Commit_unit,FUNCTION,"    * INSERT_VAL        : %d", PORT_READ(in_INSERT_VAL [num_rename_unit][num_inst_insert]));
    77             log_printf(TRACE,Commit_unit,FUNCTION,"    * can_rename_select : %d", can_rename_select [num_rename_unit]);
    78 
    79             // Test if have instruction
    80             //   -> rename_unit_glue test the in-order insert !!!!!
    81             if (can_rename_select [num_rename_unit] // and
    82 //              PORT_READ(in_INSERT_VAL [num_rename_unit][num_inst_insert])
    83                 )
    84               {
    85                 log_printf(TRACE,Commit_unit,FUNCTION,"      * have instruction");
    86                 log_printf(TRACE,Commit_unit,FUNCTION,"      * bank_full : %d",bank_full [num_bank]);
    87 
    88                 // test if bank is not busy (full or previous access)
    89                 if (not bank_full [num_bank])
    90                   {
    91                     // find !!!
    92                     insert_ack       [num_rename_unit][num_inst_insert] = true;
    93 
    94                     Tpacket_t packet_id = ((num_bank << _param->_shift_num_bank) | reg_BANK_PTR [num_bank]);
    95 
     61        std::list<generic::priority::select_t> * select_insert = _priority_insert ->select(); // same select for all insert
     62        std::list<generic::priority::select_t>::iterator it=select_insert ->begin();
     63       
     64        // Scan all bank ...
     65        for (uint32_t i=0; i<_param->_nb_bank; i++)
     66          {
     67            // compute the bank number (num_bank_tail is the older write slot)
     68            uint32_t num_bank = (reg_NUM_BANK_TAIL+i)%_param->_nb_bank;
     69     
     70//          log_printf(TRACE,Commit_unit,FUNCTION,"  * BANK : %d", num_bank);
     71//          log_printf(TRACE,Commit_unit,FUNCTION,"    * val  : %d", internal_BANK_INSERT_VAL [num_bank]);
     72//          log_printf(TRACE,Commit_unit,FUNCTION,"    * full : %d", bank_full [num_bank]);
     73     
     74            // Scan all insert interface to find a valid transaction
     75            while (it!=select_insert ->end())
     76              {
     77                uint32_t num_rename_unit = it->grp;
     78                uint32_t num_inst_insert = it->elt;
     79     
     80                it++;
     81     
     82                log_printf(TRACE,Commit_unit,FUNCTION,"  * INSERT [%d][%d]", num_rename_unit,num_inst_insert);
     83//                  log_printf(TRACE,Commit_unit,FUNCTION,"    * INSERT_VAL        : %d", PORT_READ(in_INSERT_VAL [num_rename_unit][num_inst_insert]));
     84                log_printf(TRACE,Commit_unit,FUNCTION,"    * can_rename_select : %d", can_rename_select [num_rename_unit]);
     85     
     86                // Test if have instruction
     87                //   -> rename_unit_glue test the in-order insert !!!!!
     88                if (can_rename_select [num_rename_unit] // and
     89//              PORT_READ(in_INSERT_VAL [num_rename_unit][num_inst_insert])
     90                    )
     91                  {
     92                    log_printf(TRACE,Commit_unit,FUNCTION,"      * have instruction");
     93                    log_printf(TRACE,Commit_unit,FUNCTION,"      * bank_full : %d",bank_full [num_bank]);
     94                   
     95                    // test if bank is not busy (full or previous access)
     96                    if (not bank_full [num_bank])
     97                      {
     98                        // find !!!
     99                        insert_ack       [num_rename_unit][num_inst_insert] = true;
     100                       
     101                        Tpacket_t packet_id = ((num_bank << _param->_shift_num_bank) | reg_BANK_PTR [num_bank]);
     102                       
    96103#ifdef SYSTEMC_VHDL_COMPATIBILITY
    97                     insert_packet_id [num_rename_unit][num_inst_insert] = packet_id;
     104                        insert_packet_id [num_rename_unit][num_inst_insert] = packet_id;
    98105#else
    99                     if (_param->_have_port_rob_ptr  )
    100                     PORT_WRITE(out_INSERT_PACKET_ID [num_rename_unit][num_inst_insert],packet_id);
     106                        if (_param->_have_port_rob_ptr  )
     107                        PORT_WRITE(out_INSERT_PACKET_ID [num_rename_unit][num_inst_insert],packet_id);
    101108#endif
    102                     internal_BANK_INSERT_VAL             [num_bank] = true;
    103                     internal_BANK_INSERT_NUM_RENAME_UNIT [num_bank] = num_rename_unit;
    104                     internal_BANK_INSERT_NUM_INST        [num_bank] = num_inst_insert;
    105                    
    106                     break;
    107                   }
    108               }
     109                        internal_BANK_INSERT_VAL             [num_bank] = true;
     110                        internal_BANK_INSERT_NUM_RENAME_UNIT [num_bank] = num_rename_unit;
     111                        internal_BANK_INSERT_NUM_INST        [num_bank] = num_inst_insert;
     112                       
     113                        break;
     114                      }
     115                  }
    109116               
    110             // is a valid instruction, but it's not send at a bank
    111             //  ... invalid this rename_unit (because, insert in_order)
    112             can_rename_select [num_rename_unit] = false;
    113           }
     117                // is a valid instruction, but it's not send at a bank
     118                //  ... invalid this rename_unit (because, insert in_order)
     119                can_rename_select [num_rename_unit] = false;
     120              }
     121          }
    114122      }
    115123   

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

    r110 r112  
    7676                PORT_READ(in_RETIRE_ACK [x][y])) // not busy
    7777              {
    78                 rob_state_t state = entry->state;
    79                
    80                 if ((state == ROB_END_OK         ) or
    81                     (state == ROB_END_KO         ) or
    82                     (state == ROB_END_BRANCH_MISS) or
    83                     (state == ROB_END_LOAD_MISS  ) or
    84                     (state == ROB_END_MISS       )//  or
    85 //                  (state == ROB_END_EXCEPTION)
    86                     )
    87                   {
    88                     Tcontext_t         front_end_id   = entry->front_end_id;
    89                     Tcontext_t         context_id     = entry->context_id; 
    90                     Tcontrol_t         write_re       = entry->write_re;
    91                     Tspecial_address_t num_reg_re_log = entry->num_reg_re_log;
    92 
    93                     // if state is ok, when write flags in the SR regsiters
    94                     bool spr_write_ack = true;
    95 
    96                     // Write in SR the good flag
    97                     if ((state == ROB_END_OK  ) and write_re)
    98                       // ROB_END_BRANCH_MISS is a valid branch instruction but don't modify RE
    99                       {
    100                         spr_write_ack = PORT_READ(in_SPR_WRITE_ACK [front_end_id][context_id]);
    101 
    102                         // retire_ack is set !!!
    103                         spr_write_val       [front_end_id][context_id] = 1;
    104 
    105                         Tspecial_data_t flags = entry->flags;
    106 
    107                         switch (num_reg_re_log)
    108                           {
    109                           case SPR_LOGIC_SR_F     :
    110                             {
    111                               spr_write_sr_f_val  [front_end_id][context_id] = 1;
    112                               spr_write_sr_f      [front_end_id][context_id] = (flags & FLAG_F )!=0;
    113 
    114                               break;
    115                             }
    116                           case SPR_LOGIC_SR_CY_OV :
    117                             {
    118                               spr_write_sr_cy_val [front_end_id][context_id] = 1;
    119                               spr_write_sr_ov_val [front_end_id][context_id] = 1;       
    120                               spr_write_sr_cy     [front_end_id][context_id] = (flags & FLAG_CY)!=0;
    121                               spr_write_sr_ov     [front_end_id][context_id] = (flags & FLAG_OV)!=0;
    122                        
    123                               break;
    124                             }
    125                           default :
    126                             {
     78                rob_state_t state        = entry->state;
     79                  if ((state == ROB_END_OK         ) or
     80                      (state == ROB_END_KO         ) or
     81                      (state == ROB_END_BRANCH_MISS) or
     82                      (state == ROB_END_LOAD_MISS  ) or
     83                      (state == ROB_END_MISS       )//  or
     84//                    (state == ROB_END_EXCEPTION)
     85                      )
     86                    {
     87                      Tcontrol_t         write_re       = entry->write_re;
     88                      Tspecial_address_t num_reg_re_log = entry->num_reg_re_log;
     89                      Tcontext_t         front_end_id   = entry->front_end_id;
     90                      Tcontext_t         context_id     = entry->context_id; 
     91                     
     92                      // if state is ok, when write flags in the SR regsiters
     93                      bool spr_write_ack = true;
     94                     
     95                      // Write in SR the good flag
     96                      if ((state == ROB_END_OK  ) and write_re)
     97                        // ROB_END_BRANCH_MISS is a valid branch instruction but don't modify RE
     98                        {
     99                          spr_write_ack = PORT_READ(in_SPR_WRITE_ACK [front_end_id][context_id]);
     100                         
     101                          // retire_ack is set !!!
     102                          spr_write_val       [front_end_id][context_id] = 1;
     103                         
     104                          Tspecial_data_t flags = entry->flags;
     105                         
     106                          switch (num_reg_re_log)
     107                            {
     108                            case SPR_LOGIC_SR_F     :
     109                              {
     110                                spr_write_sr_f_val  [front_end_id][context_id] = 1;
     111                                spr_write_sr_f      [front_end_id][context_id] = (flags & FLAG_F )!=0;
     112                               
     113                                break;
     114                              }
     115                            case SPR_LOGIC_SR_CY_OV :
     116                              {
     117                                spr_write_sr_cy_val [front_end_id][context_id] = 1;
     118                                spr_write_sr_ov_val [front_end_id][context_id] = 1;     
     119                                spr_write_sr_cy     [front_end_id][context_id] = (flags & FLAG_CY)!=0;
     120                                spr_write_sr_ov     [front_end_id][context_id] = (flags & FLAG_OV)!=0;
     121                               
     122                                break;
     123                              }
     124                            default :
     125                              {
    127126#ifdef DEBUG_TEST
    128                               throw ERRORMORPHEO(FUNCTION,_("Invalid num_reg_re_log.\n"));
     127                                throw ERRORMORPHEO(FUNCTION,_("Invalid num_reg_re_log.\n"));
    129128#endif
    130                             }
    131                           }
    132                       }
    133 
    134                     // find an instruction can be retire, and in order
    135 
    136                     if (spr_write_ack)
    137                       {
    138                         retire_val [x][y] = 1;
    139                         num_inst_retire [x] ++;
    140                         internal_BANK_RETIRE_VAL [num_bank] = true;
    141                       }
    142 
    143                     internal_BANK_RETIRE_NUM_RENAME_UNIT [num_bank] = x;
    144                     internal_BANK_RETIRE_NUM_INST        [num_bank] = y;
    145 
    146                     if (_param->_have_port_front_end_id)
    147                     PORT_WRITE(out_RETIRE_FRONT_END_ID          [x][y], front_end_id                );
    148                     if (_param->_have_port_context_id)
    149                     PORT_WRITE(out_RETIRE_CONTEXT_ID            [x][y], context_id                  );
    150 //                  PORT_WRITE(out_RETIRE_RENAME_UNIT_ID        [x][y], entry->rename_unit_id       );
    151                     PORT_WRITE(out_RETIRE_USE_STORE_QUEUE       [x][y], entry->use_store_queue      );
    152                     PORT_WRITE(out_RETIRE_USE_LOAD_QUEUE        [x][y], entry->use_load_queue       );
    153                     PORT_WRITE(out_RETIRE_STORE_QUEUE_PTR_WRITE [x][y], entry->store_queue_ptr_write);
    154                     if (_param->_have_port_load_queue_ptr)
    155                     PORT_WRITE(out_RETIRE_LOAD_QUEUE_PTR_WRITE  [x][y], entry->load_queue_ptr_write );
    156                     PORT_WRITE(out_RETIRE_READ_RA               [x][y], entry->read_ra              );
    157                     PORT_WRITE(out_RETIRE_NUM_REG_RA_PHY        [x][y], entry->num_reg_ra_phy       );
    158                     PORT_WRITE(out_RETIRE_READ_RB               [x][y], entry->read_rb              );
    159                     PORT_WRITE(out_RETIRE_NUM_REG_RB_PHY        [x][y], entry->num_reg_rb_phy       );
    160                     PORT_WRITE(out_RETIRE_READ_RC               [x][y], entry->read_rc              );
    161                     PORT_WRITE(out_RETIRE_NUM_REG_RC_PHY        [x][y], entry->num_reg_rc_phy       );
    162                     PORT_WRITE(out_RETIRE_WRITE_RD              [x][y], entry->write_rd             );
    163                     PORT_WRITE(out_RETIRE_NUM_REG_RD_LOG        [x][y], entry->num_reg_rd_log       );
    164                     PORT_WRITE(out_RETIRE_NUM_REG_RD_PHY_OLD    [x][y], entry->num_reg_rd_phy_old   );
    165                     PORT_WRITE(out_RETIRE_NUM_REG_RD_PHY_NEW    [x][y], entry->num_reg_rd_phy_new   );
    166                     PORT_WRITE(out_RETIRE_WRITE_RE              [x][y], write_re                    );
    167                     PORT_WRITE(out_RETIRE_NUM_REG_RE_LOG        [x][y], num_reg_re_log              );
    168                     PORT_WRITE(out_RETIRE_NUM_REG_RE_PHY_OLD    [x][y], entry->num_reg_re_phy_old   );
    169                     PORT_WRITE(out_RETIRE_NUM_REG_RE_PHY_NEW    [x][y], entry->num_reg_re_phy_new   );
    170 
    171                     // Event -> rob must be manage this event
    172                     if ((state == ROB_END_BRANCH_MISS) or
    173                         (state == ROB_END_LOAD_MISS))
    174                       can_retire [x] = false;
    175                   }
     129                              }
     130                            }
     131                        }
     132                     
     133                      // find an instruction can be retire, and in order
     134                     
     135                      if (spr_write_ack)
     136                        {
     137                          retire_val [x][y] = 1;
     138                          num_inst_retire [x] ++;
     139                          internal_BANK_RETIRE_VAL [num_bank] = true;
     140                        }
     141                     
     142                      internal_BANK_RETIRE_NUM_RENAME_UNIT [num_bank] = x;
     143                      internal_BANK_RETIRE_NUM_INST        [num_bank] = y;
     144                     
     145                      if (_param->_have_port_front_end_id)
     146                      PORT_WRITE(out_RETIRE_FRONT_END_ID          [x][y], front_end_id                );
     147                      if (_param->_have_port_context_id)
     148                      PORT_WRITE(out_RETIRE_CONTEXT_ID            [x][y], context_id                  );
     149//                    PORT_WRITE(out_RETIRE_RENAME_UNIT_ID        [x][y], entry->rename_unit_id       );
     150                      PORT_WRITE(out_RETIRE_USE_STORE_QUEUE       [x][y], entry->use_store_queue      );
     151                      PORT_WRITE(out_RETIRE_USE_LOAD_QUEUE        [x][y], entry->use_load_queue       );
     152                      PORT_WRITE(out_RETIRE_STORE_QUEUE_PTR_WRITE [x][y], entry->store_queue_ptr_write);
     153                      if (_param->_have_port_load_queue_ptr)
     154                      PORT_WRITE(out_RETIRE_LOAD_QUEUE_PTR_WRITE  [x][y], entry->load_queue_ptr_write );
     155                      PORT_WRITE(out_RETIRE_READ_RA               [x][y], entry->read_ra              );
     156                      PORT_WRITE(out_RETIRE_NUM_REG_RA_PHY        [x][y], entry->num_reg_ra_phy       );
     157                      PORT_WRITE(out_RETIRE_READ_RB               [x][y], entry->read_rb              );
     158                      PORT_WRITE(out_RETIRE_NUM_REG_RB_PHY        [x][y], entry->num_reg_rb_phy       );
     159                      PORT_WRITE(out_RETIRE_READ_RC               [x][y], entry->read_rc              );
     160                      PORT_WRITE(out_RETIRE_NUM_REG_RC_PHY        [x][y], entry->num_reg_rc_phy       );
     161                      PORT_WRITE(out_RETIRE_WRITE_RD              [x][y], entry->write_rd             );
     162                      PORT_WRITE(out_RETIRE_NUM_REG_RD_LOG        [x][y], entry->num_reg_rd_log       );
     163                      PORT_WRITE(out_RETIRE_NUM_REG_RD_PHY_OLD    [x][y], entry->num_reg_rd_phy_old   );
     164                      PORT_WRITE(out_RETIRE_NUM_REG_RD_PHY_NEW    [x][y], entry->num_reg_rd_phy_new   );
     165                      PORT_WRITE(out_RETIRE_WRITE_RE              [x][y], write_re                    );
     166                      PORT_WRITE(out_RETIRE_NUM_REG_RE_LOG        [x][y], num_reg_re_log              );
     167                      PORT_WRITE(out_RETIRE_NUM_REG_RE_PHY_OLD    [x][y], entry->num_reg_re_phy_old   );
     168                      PORT_WRITE(out_RETIRE_NUM_REG_RE_PHY_NEW    [x][y], entry->num_reg_re_phy_new   );
     169
     170                      // Event -> rob must be manage this event
     171                      if ((state == ROB_END_BRANCH_MISS) or
     172                          (state == ROB_END_LOAD_MISS))
     173                        can_retire [x] = false;
     174                    }
    176175              }
    177176

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

    r111 r112  
    4949              reg_EVENT_STATE           [i][j] = EVENT_STATE_NO_EVENT;
    5050              reg_EVENT_FLUSH           [i][j] = false;
     51              reg_EVENT_STOP            [i][j] = false;
    5152
    5253//            reg_PC_PREVIOUS           [i][j] = (0x100-4)>>2;
    … …  
    9091                      reg_EVENT_STATE [i][j] = EVENT_STATE_END;
    9192                      reg_EVENT_FLUSH [i][j] = false;
     93                      //reg_EVENT_STOP  [i][j] = false;
    9294                    }
    9395                  break;
    … …  
    324326                      case ROB_BRANCH_WAIT_END : {state = (have_exception)?ROB_END_EXCEPTION_WAIT_HEAD:ROB_BRANCH_COMPLETE; break;}
    325327                        // Store KO
    326                       case ROB_MISS_WAIT_END   : {state = ROB_END_KO_SPECULATIVE; break;}
     328                      case ROB_EVENT_WAIT_END  : {state = ROB_END_KO_SPECULATIVE; break;}
    327329                        // Store OK, Load and other instruction
    328330                      case ROB_OTHER_WAIT_END  : {state = (have_exception)?ROB_END_EXCEPTION_WAIT_HEAD:((have_miss_speculation)?ROB_END_LOAD_MISS_SPECULATIVE:ROB_END_OK_SPECULATIVE); break;}
    … …  
    333335                        }
    334336                      }
     337
     338                    if ((have_exception or have_miss_speculation) and
     339                        (reg_EVENT_FLUSH [entry->front_end_id][entry->context_id] == 0))
     340                      reg_EVENT_STOP [entry->front_end_id][entry->context_id] = true;
    335341
    336342                    // update Re Order Buffer
    … …  
    364370               
    365371                log_printf(TRACE,Commit_unit,FUNCTION,"  * RETIRE            [%d][%d]",x,y);
     372                log_printf(TRACE,Commit_unit,FUNCTION,"    * num_bank     : %d",num_bank     );
    366373               
    367374#ifdef DEBUG_TEST
    … …  
    381388                log_printf(TRACE,Commit_unit,FUNCTION,"    * front_end_id : %d",front_end_id );
    382389                log_printf(TRACE,Commit_unit,FUNCTION,"    * context_id   : %d",context_id   );
     390                log_printf(TRACE,Commit_unit,FUNCTION,"    * rob_ptr      : %d",((num_bank << _param->_shift_num_bank) | entry->ptr));
    383391                log_printf(TRACE,Commit_unit,FUNCTION,"    * num_thread   : %d",num_thread   );
    384392                log_printf(TRACE,Commit_unit,FUNCTION,"    * type         : %s",toString(type).c_str());
    … …  
    406414//                     throw ERRORMORPHEO(FUNCTION,toString(_("Retire : Instruction's address_next (%.8x) is different of commit_unit's address_next (%.8x)"),entry->address_next,reg_PC_NEXT [front_end_id][context_id]));
    407415                  }
    408                
     416
    409417                if ((state == ROB_END_BRANCH_MISS) or
    410418                    (state == ROB_END_LOAD_MISS))
    411                   {
    412                     reg_EVENT_STATE [front_end_id][context_id] = EVENT_STATE_EVENT;
    413                     reg_EVENT_FLUSH [front_end_id][context_id] = true;
    414                   }
     419                    {
     420                      reg_EVENT_STATE [front_end_id][context_id] = EVENT_STATE_EVENT;
     421                      reg_EVENT_FLUSH [front_end_id][context_id] = true;
     422                      reg_EVENT_STOP  [front_end_id][context_id] = false;
     423                    }
    415424               
    416425#if defined(DEBUG) and defined(DEBUG_Commit_unit) and (DEBUG_Commit_unit == true)
    … …  
    475484              {
    476485              case ROB_STORE_HEAD_OK : {state = ROB_OTHER_WAIT_END; break; }
    477               case ROB_STORE_HEAD_KO : {state = ROB_MISS_WAIT_END ; break; }
     486              case ROB_STORE_HEAD_KO : {state = ROB_EVENT_WAIT_END; break; }
    478487              default : {throw ERRORMORPHEO(FUNCTION,_("Reexecute : invalid state value.\n"));}
    479488              }
    … …  
    500509                throw ERRORMORPHEO(FUNCTION,_("Branch_complete : Invalid state value.\n"));
    501510#endif
    502 
    503               entry->state = (PORT_READ(in_BRANCH_COMPLETE_MISS_PREDICTION [i]))?ROB_END_BRANCH_MISS_SPECULATIVE:ROB_END_OK_SPECULATIVE;
     511              Tcontrol_t miss = PORT_READ(in_BRANCH_COMPLETE_MISS_PREDICTION [i]);
     512             
     513              entry->state = (miss)?ROB_END_BRANCH_MISS_SPECULATIVE:ROB_END_OK_SPECULATIVE;
     514             
     515              if (miss and (reg_EVENT_FLUSH [entry->front_end_id][entry->context_id] == 0))
     516                reg_EVENT_STOP [entry->front_end_id][entry->context_id] = true;
     517
     518
    504519//               entry->state = ROB_END_OK_SPECULATIVE;
    505520            }
    … …  
    612627                  switch (state)
    613628                    {
    614                     case ROB_BRANCH_WAIT_END             : {state = ROB_MISS_WAIT_END; break;}
    615                     case ROB_BRANCH_COMPLETE             : {state = ROB_END_MISS     ; break;}
     629                    case ROB_BRANCH_WAIT_END             : {state = ROB_EVENT_WAIT_END; break;}
     630                    case ROB_BRANCH_COMPLETE             : {state = ROB_END_MISS      ; break;}
    616631                    case ROB_END_BRANCH_MISS             :
    617                     case ROB_END_BRANCH_MISS_SPECULATIVE : {state = ROB_END_MISS     ; break;}
     632                    case ROB_END_BRANCH_MISS_SPECULATIVE : {state = ROB_END_MISS      ; break;}
    618633                    case ROB_END_LOAD_MISS_UPDATE        :
    619634                    case ROB_END_LOAD_MISS               :
    620                     case ROB_END_LOAD_MISS_SPECULATIVE   : {state = ROB_END_MISS     ; break;}
    621                     case ROB_STORE_WAIT_HEAD_OK          : {state = ROB_STORE_HEAD_KO; break;}
     635                    case ROB_END_LOAD_MISS_SPECULATIVE   : {state = ROB_END_MISS      ; break;}
     636                    case ROB_STORE_WAIT_HEAD_OK          : {state = ROB_STORE_HEAD_KO ; break;}
    622637                  //case ROB_STORE_WAIT_HEAD_KO          : {state = ; break;}
    623                     case ROB_OTHER_WAIT_END              : {state = ROB_MISS_WAIT_END; break;}
     638                    case ROB_OTHER_WAIT_END              : {state = ROB_EVENT_WAIT_END; break;}
    624639                    case ROB_END_OK                      :
    625                     case ROB_END_OK_SPECULATIVE          : {state = ROB_END_MISS     ; break;}
     640                    case ROB_END_OK_SPECULATIVE          : {state = ROB_END_MISS      ; break;}
    626641                    case ROB_END_KO                      :
    627                     case ROB_END_KO_SPECULATIVE          : {state = ROB_END_MISS     ; break;}
     642                    case ROB_END_KO_SPECULATIVE          : {state = ROB_END_MISS      ; break;}
    628643                    case ROB_END_EXCEPTION_UPDATE        :
    629644                    case ROB_END_EXCEPTION               :
    630                     case ROB_END_EXCEPTION_WAIT_HEAD     : {state = ROB_END_MISS     ; break;}
     645                    case ROB_END_EXCEPTION_WAIT_HEAD     : {state = ROB_END_MISS      ; break;}
    631646                                                         
    632647                      // don't change                   
    633648                    case ROB_STORE_HEAD_KO               : {break;}
    634                     case ROB_MISS_WAIT_END               : {break;}
     649                    case ROB_EVENT_WAIT_END              : {break;}
    635650                    case ROB_END_MISS                    : {break;}
    636651                                                         
    … …  
    671686                    case ROB_STORE_WAIT_HEAD_OK      : {state = ROB_STORE_HEAD_OK;        break;}
    672687                    case ROB_END_EXCEPTION_WAIT_HEAD : {state = ROB_END_EXCEPTION_UPDATE; break;}
    673                     default : {break;} // else, no change
     688                    default : {break;} // else, no change
    674689                    }
    675690                }
    … …  
    701716            log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_STATE  : %s",toString(reg_EVENT_STATE [i][j]).c_str());
    702717            log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_FLUSH  : %d",reg_EVENT_FLUSH [i][j]);
     718            log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_STOP   : %d",reg_EVENT_STOP  [i][j]);
    703719            log_printf(TRACE,Commit_unit,FUNCTION,"      * NB_INST_ALL  : %d",reg_NB_INST_COMMIT_ALL[i][j]);
    704720            log_printf(TRACE,Commit_unit,FUNCTION,"      * NB_INST_MEM  : %d",reg_NB_INST_COMMIT_MEM[i][j]);
    … …  
    784800//            or (entry->state == ROB_STORE_HEAD_KO              )
    785801//            or (entry->state == ROB_OTHER_WAIT_END             )
    786 //            or (entry->state == ROB_MISS_WAIT_END              )
     802//            or (entry->state == ROB_EVENT_WAIT_END             )
    787803//            or (entry->state == ROB_END_OK_SPECULATIVE         )
    788804              or (entry->state == ROB_END_OK                     )
Note: See TracChangeset for help on using the changeset viewer.