Ignore:
Timestamp:
Dec 16, 2008, 5:24:26 PM (16 years ago)
Author:
rosiere
Message:

1) Update Prediction Table - New architecture (systemC) done (and tested) -> need change interface in top level
2) Change documentation on VHDL generation
3) Change VHDL constant (case std_logic and std_logic_vector)

Location:
trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end
Files:
45 edited

Legend:

Unmodified
Added
Removed

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Context_State/SelfTest/src/test.cpp

    r88 r95  
    5454//ALLOC1_SC_SIGNAL( in_BRANCH_EVENT_MISS_PREDICTION   ," in_BRANCH_EVENT_MISS_PREDICTION   ",Tcontrol_t   ,_param->_nb_context);
    5555  ALLOC1_SC_SIGNAL( in_BRANCH_EVENT_ADDRESS_SRC       ," in_BRANCH_EVENT_ADDRESS_SRC       ",Taddress_t   ,_param->_nb_context);
     56  ALLOC1_SC_SIGNAL( in_BRANCH_EVENT_ADDRESS_DEST_VAL  ," in_BRANCH_EVENT_ADDRESS_DEST_VAL  ",Tcontrol_t   ,_param->_nb_context);
    5657  ALLOC1_SC_SIGNAL( in_BRANCH_EVENT_ADDRESS_DEST      ," in_BRANCH_EVENT_ADDRESS_DEST      ",Taddress_t   ,_param->_nb_context);
    5758
    … …  
    129130//INSTANCE1_SC_SIGNAL(_Context_State, in_BRANCH_EVENT_MISS_PREDICTION   ,_param->_nb_context);
    130131  INSTANCE1_SC_SIGNAL(_Context_State, in_BRANCH_EVENT_ADDRESS_SRC       ,_param->_nb_context);
     132  INSTANCE1_SC_SIGNAL(_Context_State, in_BRANCH_EVENT_ADDRESS_DEST_VAL  ,_param->_nb_context);
    131133  INSTANCE1_SC_SIGNAL(_Context_State, in_BRANCH_EVENT_ADDRESS_DEST      ,_param->_nb_context);
    132134  INSTANCE1_SC_SIGNAL(_Context_State, in_DECOD_EVENT_VAL                ,_param->_nb_decod_unit);
    … …  
    12341236//DELETE1_SC_SIGNAL( in_BRANCH_EVENT_MISS_PREDICTION   ,_param->_nb_context);
    12351237  DELETE1_SC_SIGNAL( in_BRANCH_EVENT_ADDRESS_SRC       ,_param->_nb_context);
     1238  DELETE1_SC_SIGNAL( in_BRANCH_EVENT_ADDRESS_DEST_VAL  ,_param->_nb_context);
    12361239  DELETE1_SC_SIGNAL( in_BRANCH_EVENT_ADDRESS_DEST      ,_param->_nb_context);
    12371240  DELETE1_SC_SIGNAL( in_DECOD_EVENT_VAL                ,_param->_nb_decod_unit);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Context_State/include/Context_State.h

    r88 r95  
    7070//public    : SC_IN (Tcontrol_t         )  **  in_BRANCH_EVENT_MISS_PREDICTION       ;//[nb_context]
    7171  public    : SC_IN (Taddress_t         )  **  in_BRANCH_EVENT_ADDRESS_SRC           ;//[nb_context]
     72  public    : SC_IN (Tcontrol_t         )  **  in_BRANCH_EVENT_ADDRESS_DEST_VAL      ;//[nb_context]
    7273  public    : SC_IN (Taddress_t         )  **  in_BRANCH_EVENT_ADDRESS_DEST          ;//[nb_context]
    7374
    … …  
    116117  public    : SC_OUT(Tcontrol_t         )  ** out_EVENT_ADDRESS_NEXT_VAL             ;//[nb_context]
    117118  public    : SC_OUT(Tcontrol_t         )  ** out_EVENT_IS_DS_TAKE                   ;//[nb_context]
     119  public    : SC_OUT(Tevent_type_t      )  ** out_EVENT_TYPE                         ;//[nb_context]
     120  public    : SC_OUT(Tdepth_t           )  ** out_EVENT_DEPTH                        ;//[nb_context]
    118121
    119122    // ~~~~~[ Interface "spr_event" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Context_State/src/Context_State_allocation.cpp

    r88 r95  
    6666//    ALLOC1_SIGNAL_IN ( in_BRANCH_EVENT_MISS_PREDICTION       ,"miss_prediction"        ,Tcontrol_t         ,1);
    6767      ALLOC1_SIGNAL_IN ( in_BRANCH_EVENT_ADDRESS_SRC           ,"address_src"            ,Taddress_t         ,_param->_size_instruction_address);
     68      ALLOC1_SIGNAL_IN ( in_BRANCH_EVENT_ADDRESS_DEST_VAL      ,"address_dest_val"       ,Tcontrol_t         ,1);
    6869      ALLOC1_SIGNAL_IN ( in_BRANCH_EVENT_ADDRESS_DEST          ,"address_dest"           ,Taddress_t         ,_param->_size_instruction_address);
    6970    }

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Context_State/src/Context_State_deallocation.cpp

    r88 r95  
    3434//      DELETE1_SIGNAL( in_BRANCH_EVENT_MISS_PREDICTION       ,_param->_nb_context,1);
    3535        DELETE1_SIGNAL( in_BRANCH_EVENT_ADDRESS_SRC           ,_param->_nb_context,_param->_size_instruction_address);
     36        DELETE1_SIGNAL( in_BRANCH_EVENT_ADDRESS_DEST_VAL      ,_param->_nb_context,1);
    3637        DELETE1_SIGNAL( in_BRANCH_EVENT_ADDRESS_DEST          ,_param->_nb_context,_param->_size_instruction_address);
    3738

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Context_State/src/Context_State_transition.cpp

    r88 r95  
    6969              if (is_valid)
    7070                {
     71                  Tcontrol_t dest_val = PORT_READ(in_BRANCH_EVENT_ADDRESS_DEST_VAL[i]);
    7172                  reg_STATE                  [i] =  CONTEXT_STATE_KO_MISS;
    72                   reg_EVENT_ADDRESS          [i] =  PORT_READ(in_BRANCH_EVENT_ADDRESS_SRC [i])+1; // address delay slot
    73                   reg_EVENT_ADDRESS_EPCR     [i] =  PORT_READ(in_BRANCH_EVENT_ADDRESS_DEST[i]);   // address_next
    74                   reg_EVENT_ADDRESS_EPCR_VAL [i] =  1; // address_dest is valid
     73                  reg_EVENT_ADDRESS          [i] =  PORT_READ(in_BRANCH_EVENT_ADDRESS_SRC  [i])+1; // address delay slot
     74                  reg_EVENT_ADDRESS_EPCR     [i] =  PORT_READ(in_BRANCH_EVENT_ADDRESS_DEST [i]);   // address_next
     75                  reg_EVENT_ADDRESS_EPCR_VAL [i] =  dest_val;
    7576                //reg_EVENT_ADDRESS_EEAR     [i] =  0;
    7677                  reg_EVENT_ADDRESS_EEAR_VAL [i] =  0;
    77                   reg_EVENT_IS_DELAY_SLOT    [i] =  1;
    78                   reg_EVENT_IS_DS_TAKE       [i] =  0;// ??
     78                  reg_EVENT_IS_DELAY_SLOT    [i] =  dest_val;
     79                  reg_EVENT_IS_DS_TAKE       [i] =  dest_val;
    7980                  reg_EVENT_DEPTH            [i] =  depth;
    8081                }

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/SelfTest/include/Decod_request.h

    r88 r95  
    234234
    235235    // ===== l.bf 11
    236     w = y+(11<<2);
     236    w = y+(11);
    237237    request.push_back (entry_t(
    238238    0x1000000b,x,y,z,
    … …  
    262262
    263263    // ===== l.bf -9
    264     w = y+(-9<<2);
     264    w = y+(-9);
    265265    request.push_back (entry_t(
    266266    0x13fffff7,x,y,z,
    … …  
    290290
    291291    // ===== l.bnf 11
    292     w = y+(11<<2);
     292    w = y+(11);
    293293    request.push_back (entry_t(
    294294    0x0c00000b,x,y,z,
    … …  
    318318
    319319    // ===== l.bnf -9
    320     w = y+(-9<<2);
     320    w = y+(-9);
    321321    request.push_back (entry_t(
    322322    0x0ffffff7,x,y,z,
    … …  
    382382
    383383    // ===== l.j 1018
    384     w = y+(1018<<2);
     384    w = y+(1018);
    385385    request.push_back (entry_t(
    386386    0x000003fa,x,y,z,
    … …  
    410410
    411411    // ===== l.j -1018
    412     w = y+(-1018<<2);
     412    w = y+(-1018);
    413413    request.push_back (entry_t(
    414414    0x03fffc06,x,y,z,
    … …  
    438438
    439439    // ===== l.jal 1018
    440     w = y+(1018<<2);
     440    w = y+(1018);
    441441    request.push_back (entry_t(
    442442    0x040003fa,x,y,z,
    … …  
    466466
    467467    // ===== l.jal -1018
    468     w = y+(-1018<<2);
     468    w = y+(-1018);
    469469    request.push_back (entry_t(
    470470    0x07fffc06,x,y,z,

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/src/Decod_allocation.cpp

    r88 r95  
    8989      ALLOC1_SIGNAL_OUT(out_DECOD_NO_EXECUTE   ,"no_execute"   ,Tcontrol_t        ,1                                   );
    9090      ALLOC1_SIGNAL_OUT(out_DECOD_IS_DELAY_SLOT,"is_delay_slot",Tcontrol_t        ,1                                   );
    91       ALLOC1_SIGNAL_OUT(out_DECOD_ADDRESS      ,"address"      ,Tgeneral_data_t   ,_param->_size_instruction_address          );
     91      ALLOC1_SIGNAL_OUT(out_DECOD_ADDRESS      ,"address"      ,Tgeneral_data_t   ,_param->_size_instruction_address   );
    9292      ALLOC1_SIGNAL_OUT(out_DECOD_HAS_IMMEDIAT ,"has_immediat" ,Tcontrol_t        ,1                                   );
    9393      ALLOC1_SIGNAL_OUT(out_DECOD_IMMEDIAT     ,"immediat"     ,Tgeneral_data_t   ,_param->_size_general_data          );

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod_queue/src/Decod_queue_allocation.cpp

    r88 r95  
    6767      ALLOC1_SIGNAL_IN ( in_DECOD_IN_NO_EXECUTE     ,"no_execute"   ,Tcontrol_t         ,1                                   );
    6868      ALLOC1_SIGNAL_IN ( in_DECOD_IN_IS_DELAY_SLOT  ,"is_delay_slot",Tcontrol_t         ,1                                   );
    69       ALLOC1_SIGNAL_IN ( in_DECOD_IN_ADDRESS        ,"address"      ,Tgeneral_data_t    ,_param->_size_general_data          );
     69      ALLOC1_SIGNAL_IN ( in_DECOD_IN_ADDRESS        ,"address"      ,Tgeneral_data_t    ,_param->_size_instruction_address   );
    7070      ALLOC1_SIGNAL_IN ( in_DECOD_IN_HAS_IMMEDIAT   ,"has_immediat" ,Tcontrol_t         ,1                                   );
    7171      ALLOC1_SIGNAL_IN ( in_DECOD_IN_IMMEDIAT       ,"immediat"     ,Tgeneral_data_t    ,_param->_size_general_data          );
    … …  
    9696      ALLOC1_SIGNAL_OUT(out_DECOD_OUT_NO_EXECUTE     ,"no_execute"   ,Tcontrol_t         ,1                                   );
    9797      ALLOC1_SIGNAL_OUT(out_DECOD_OUT_IS_DELAY_SLOT  ,"is_delay_slot",Tcontrol_t         ,1                                   );
    98       ALLOC1_SIGNAL_OUT(out_DECOD_OUT_ADDRESS        ,"address"      ,Tgeneral_data_t    ,_param->_size_general_data          );
     98      ALLOC1_SIGNAL_OUT(out_DECOD_OUT_ADDRESS        ,"address"      ,Tgeneral_data_t    ,_param->_size_instruction_address   );
    9999      ALLOC1_SIGNAL_OUT(out_DECOD_OUT_HAS_IMMEDIAT   ,"has_immediat" ,Tcontrol_t         ,1                                   );
    100100      ALLOC1_SIGNAL_OUT(out_DECOD_OUT_IMMEDIAT       ,"immediat"     ,Tgeneral_data_t    ,_param->_size_general_data          );

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod_queue/src/Parameters.cpp

    r88 r95  
    4242    if (is_toplevel)
    4343      {
    44         _size_context_id      = log2(nb_context);
    45         _size_nb_inst_decod   = log2(_size_queue)+1;
    46         _size_depth           = log2(max<uint32_t>(_nb_branch_speculated,_nb_context));
    47         _size_general_data    = size_general_data;
     44        _size_context_id          = log2(nb_context);
     45        _size_nb_inst_decod       = log2(_size_queue)+1;
     46        _size_depth               = log2(max<uint32_t>(_nb_branch_speculated,_nb_context));
     47        _size_general_data        = size_general_data;
     48        _size_instruction_address = size_general_data-2;
    4849
    49         _have_port_context_id = _size_context_id > 0;
    50         _have_port_depth      = _size_depth > 0;
     50        _have_port_context_id     = _size_context_id > 0;
     51        _have_port_depth          = _size_depth > 0;
    5152
    5253        copy ();

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Return_Address_Stack/SelfTest/src/test.cpp

    r88 r95  
    7171  ALLOC1_SC_SIGNAL( in_UPDATE_CONTEXT_ID     ," in_UPDATE_CONTEXT_ID     ",Tcontext_t,_param->_nb_inst_update );
    7272  ALLOC1_SC_SIGNAL( in_UPDATE_PUSH           ," in_UPDATE_PUSH           ",Tcontrol_t,_param->_nb_inst_update );
     73  ALLOC1_SC_SIGNAL( in_UPDATE_FLUSH          ," in_UPDATE_FLUSH          ",Tcontrol_t,_param->_nb_inst_update );
    7374  ALLOC1_SC_SIGNAL( in_UPDATE_INDEX          ," in_UPDATE_INDEX          ",Tptr_t    ,_param->_nb_inst_update );
    7475  ALLOC1_SC_SIGNAL( in_UPDATE_ADDRESS        ," in_UPDATE_ADDRESS        ",Taddress_t,_param->_nb_inst_update );
    … …  
    109110  INSTANCE1_SC_SIGNAL(_Return_Address_Stack, in_UPDATE_CONTEXT_ID     ,_param->_nb_inst_update );
    110111  INSTANCE1_SC_SIGNAL(_Return_Address_Stack, in_UPDATE_PUSH           ,_param->_nb_inst_update );
     112  INSTANCE1_SC_SIGNAL(_Return_Address_Stack, in_UPDATE_FLUSH          ,_param->_nb_inst_update );
    111113  INSTANCE1_SC_SIGNAL(_Return_Address_Stack, in_UPDATE_INDEX          ,_param->_nb_inst_update );
    112114  INSTANCE1_SC_SIGNAL(_Return_Address_Stack, in_UPDATE_ADDRESS        ,_param->_nb_inst_update );
    … …  
    451453  DELETE1_SC_SIGNAL( in_UPDATE_CONTEXT_ID       ,_param->_nb_inst_update);
    452454  DELETE1_SC_SIGNAL( in_UPDATE_PUSH             ,_param->_nb_inst_update);
     455  DELETE1_SC_SIGNAL( in_UPDATE_FLUSH            ,_param->_nb_inst_update);
    453456  DELETE1_SC_SIGNAL( in_UPDATE_ADDRESS          ,_param->_nb_inst_update);
    454457  DELETE1_SC_SIGNAL( in_UPDATE_INDEX            ,_param->_nb_inst_update);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Return_Address_Stack/include/Return_Address_Stack.h

    r82 r95  
    8888  public    : SC_IN (Tcontext_t)           **  in_UPDATE_CONTEXT_ID       ; //[nb_inst_update]
    8989  public    : SC_IN (Tcontrol_t)           **  in_UPDATE_PUSH             ; //[nb_inst_update]  1 = push, else pop
     90  public    : SC_IN (Tcontrol_t)           **  in_UPDATE_FLUSH            ; //[nb_inst_update]  1 = push, else pop
    9091  public    : SC_IN (Taddress_t)           **  in_UPDATE_ADDRESS          ; //[nb_inst_update]
    9192  public    : SC_IN (Tptr_t    )           **  in_UPDATE_INDEX            ; //[nb_inst_update]

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Return_Address_Stack/src/Parameters.cpp

    r88 r95  
    3737    _nb_inst_update  = nb_inst_update ;
    3838
    39     _size_index      = max<uint32_t>(size_queue,nb_context);
     39    _size_index      = log2(max<uint32_t>(size_queue,nb_context));
    4040
    4141    test();

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Return_Address_Stack/src/Return_Address_Stack_allocation.cpp

    r88 r95  
    9191      ALLOC1_SIGNAL_IN ( in_UPDATE_CONTEXT_ID       ,"context_id"       ,Tcontext_t,_param->_size_context_id);
    9292      ALLOC1_SIGNAL_IN ( in_UPDATE_PUSH             ,"push"             ,Tcontrol_t,1);
     93      ALLOC1_SIGNAL_IN ( in_UPDATE_FLUSH            ,"flush"            ,Tcontrol_t,1);
    9394      ALLOC1_SIGNAL_IN ( in_UPDATE_ADDRESS          ,"address"          ,Taddress_t,_param->_size_instruction_address);
    9495      ALLOC1_SIGNAL_IN ( in_UPDATE_INDEX            ,"index"            ,Tptr_t    ,_param->_size_index);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Return_Address_Stack/src/Return_Address_Stack_deallocation.cpp

    r88 r95  
    5252        DELETE1_SIGNAL( in_UPDATE_CONTEXT_ID       ,_param->_nb_inst_update,_param->_size_context_id);
    5353        DELETE1_SIGNAL( in_UPDATE_PUSH             ,_param->_nb_inst_update,1);
     54        DELETE1_SIGNAL( in_UPDATE_FLUSH            ,_param->_nb_inst_update,1);
    5455        DELETE1_SIGNAL( in_UPDATE_ADDRESS          ,_param->_nb_inst_update,_param->_size_instruction_address);
    5556        DELETE1_SIGNAL( in_UPDATE_INDEX            ,_param->_nb_inst_update,_param->_size_index);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Return_Address_Stack/src/Return_Address_Stack_transition.cpp

    r88 r95  
    207207          if (PORT_READ(in_UPDATE_VAL [i]) and internal_UPDATE_ACK [i])
    208208            {
    209               ERRORMORPHEO(FUNCTION,"Fonction à implémenter !!!!!!!!!!!!");
     209              throw ERRORMORPHEO(FUNCTION,"Fonction à implémenter !!!!!!!!!!!!");
    210210             
    211211
    … …  
    217217//                Tcontrol_t ifetch  = PORT_READ(in_UPDATE_PREDICTION_IFETCH [i]);
    218218//                Tcontrol_t push    = PORT_READ(in_UPDATE_PUSH             [i]);
     219//                Tcontrol_t flush   = PORT_READ(in_UPDATE_FLUSH            [i]);
    219220//                Tptr_t     index   = PORT_READ(in_UPDATE_INDEX            [i]);
    220221//                Taddress_t address = PORT_READ(in_UPDATE_ADDRESS          [i]);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/SelfTest/config_min.cfg

    r88 r95  
    36361       1       +1 # dir_pht_size_address_share [2] [3]
    37372       2       +1 # ras_size_queue             [0] [nb_context]
    38 2       2       +1 # upt_size_queue             [0] [nb_context]
     381       1       +1 # upt_size_queue             [0] [nb_context]
     391       1       +1 # ufpt_size_queue            [0] [nb_context]

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/SelfTest/config_mono_context.cfg

    r88 r95  
    661       4       *4 # nb_inst_decod              [0] [nb_decod_unit]
    771       1       +1 # nb_inst_branch_predict     
    8 1       2       +1 # nb_inst_branch_decod       
    9 1       2       +1 # nb_inst_branch_update     
    10 1       2       +1 # nb_inst_branch_complete   
    11 2       8       *4 # btb_size_queue             
     82       2       +1 # nb_inst_branch_decod       
     92       2       +1 # nb_inst_branch_update     
     102       2       +1 # nb_inst_branch_complete   
     112       8       *8 # btb_size_queue             
    12122       2       +1 # btb_associativity         
    13132       2       +1 # btb_size_counter           
    … …  
    35351       1       +1 # dir_pht_size_address_share [1] [3]
    36361       1       +1 # dir_pht_size_address_share [2] [3]
    37 2       4       *2 # ras_size_queue             [0] [nb_context]
    38 2       4       *2 # upt_size_queue             [0] [nb_context]
     374       4       *2 # ras_size_queue             [0] [nb_context]
     384       4       *2 # upt_size_queue             [0] [nb_context]
     392       2       +1 # ufpt_size_queue            [0] [nb_context]

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/SelfTest/config_mono_context_multi_decod.cfg

    r82 r95  
    40404       4       *2 # ras_size_queue             [0] [nb_context]
    41414       4       *4 # upt_size_queue             [0] [nb_context]
     422       2       *4 # ufpt_size_queue            [0] [nb_context]

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/SelfTest/config_multi_context.cfg

    r88 r95  
    46464       4       *4 # upt_size_queue             [2] [nb_context]
    47478       8       *4 # upt_size_queue             [3] [nb_context]
     481       1       *4 # ufpt_size_queue            [0] [nb_context]
     494       4       *4 # ufpt_size_queue            [1] [nb_context]
     502       2       *4 # ufpt_size_queue            [2] [nb_context]
     514       4       *4 # ufpt_size_queue            [3] [nb_context]

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/SelfTest/src/main.cpp

    r88 r95  
    3737  err (_(" * ras_size_queue             [nb_context]   (uint32_t    )\n"));
    3838  err (_(" * upt_size_queue             [nb_context]   (uint32_t    )\n"));
     39  err (_(" * ufpt_size_queue            [nb_context]   (uint32_t    )\n"));
    3940
    4041  exit (1);
    … …  
    5758  uint32_t     _size_address                   = fromString<uint32_t>(argv[x++]);
    5859
    59   if (argc != static_cast<int>(2+NB_PARAMS+3*_nb_context+_nb_decod_unit))
     60  if (argc != static_cast<int>(2+NB_PARAMS+4*_nb_context+_nb_decod_unit))
    6061    usage (argc, argv);
    6162
    … …  
    102103  for (uint32_t i=0; i<_nb_context; i++)
    103104    _upt_size_queue [i]                        = fromString<uint32_t    >(argv[x++]);
     105  uint32_t *   _ufpt_size_queue                = new uint32_t    [_nb_context];
     106  for (uint32_t i=0; i<_nb_context; i++)
     107    _ufpt_size_queue [i]                       = fromString<uint32_t    >(argv[x++]);
    104108
    105109  int _return = EXIT_SUCCESS;
    … …  
    130134         _ras_size_queue            ,
    131135         _upt_size_queue            ,
     136         _ufpt_size_queue           ,
    132137         true // is_toplevel
    133138         );
    … …  
    152157  delete [] _ras_size_queue            ;
    153158  delete [] _upt_size_queue            ;
     159  delete [] _ufpt_size_queue           ;
    154160
    155161  return (_return);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/SelfTest/src/test.cpp

    r88 r95  
    9191//ALLOC1_SC_SIGNAL(out_BRANCH_EVENT_MISS_PREDICTION       ,"out_BRANCH_EVENT_MISS_PREDICTION       ",Tcontrol_t         ,_param->_nb_context);
    9292  ALLOC1_SC_SIGNAL(out_BRANCH_EVENT_ADDRESS_SRC           ,"out_BRANCH_EVENT_ADDRESS_SRC           ",Taddress_t         ,_param->_nb_context);
     93  ALLOC1_SC_SIGNAL(out_BRANCH_EVENT_ADDRESS_DEST_VAL      ,"out_BRANCH_EVENT_ADDRESS_DEST_VAL      ",Tcontrol_t         ,_param->_nb_context);
    9394  ALLOC1_SC_SIGNAL(out_BRANCH_EVENT_ADDRESS_DEST          ,"out_BRANCH_EVENT_ADDRESS_DEST          ",Taddress_t         ,_param->_nb_context);
    9495                                                                                                                         
     96  ALLOC1_SC_SIGNAL( in_EVENT_STATE                    ," in_EVENT_STATE                    ",Tevent_state_t     ,_param->_nb_context);
     97  ALLOC1_SC_SIGNAL( in_EVENT_TYPE                     ," in_EVENT_TYPE                     ",Tevent_type_t      ,_param->_nb_context);
     98  ALLOC1_SC_SIGNAL( in_EVENT_DEPTH                    ," in_EVENT_DEPTH                    ",Tdepth_t           ,_param->_nb_context);
     99
    95100  ALLOC1_SC_SIGNAL(out_DEPTH_CURRENT                      ,"out_DEPTH_CURRENT                      ",Tdepth_t           ,_param->_nb_context);
    96101  ALLOC1_SC_SIGNAL(out_DEPTH_MIN                          ,"out_DEPTH_MIN                          ",Tdepth_t           ,_param->_nb_context);
    … …  
    152157//INSTANCE1_SC_SIGNAL(_Prediction_unit,out_BRANCH_EVENT_MISS_PREDICTION       ,_param->_nb_context);
    153158  INSTANCE1_SC_SIGNAL(_Prediction_unit,out_BRANCH_EVENT_ADDRESS_SRC           ,_param->_nb_context);
     159  INSTANCE1_SC_SIGNAL(_Prediction_unit,out_BRANCH_EVENT_ADDRESS_DEST_VAL      ,_param->_nb_context);
    154160  INSTANCE1_SC_SIGNAL(_Prediction_unit,out_BRANCH_EVENT_ADDRESS_DEST          ,_param->_nb_context);
    155161
     162  INSTANCE1_SC_SIGNAL(_Prediction_unit, in_EVENT_STATE                        ,_param->_nb_context);
     163  INSTANCE1_SC_SIGNAL(_Prediction_unit, in_EVENT_TYPE                         ,_param->_nb_context);
    156164  if (_param->_have_port_depth)
    157165    {
     166  INSTANCE1_SC_SIGNAL(_Prediction_unit, in_EVENT_DEPTH                        ,_param->_nb_context);
    158167  INSTANCE1_SC_SIGNAL(_Prediction_unit,out_DEPTH_CURRENT                      ,_param->_nb_context);
    159168  INSTANCE1_SC_SIGNAL(_Prediction_unit,out_DEPTH_MIN                          ,_param->_nb_context);
    … …  
    211220  for (uint32_t i=0; i<_param->_nb_context; ++i)
    212221    {
    213       TEST(Tcontrol_t,out_PREDICT_ACK      [i]->read(),1); // Accept new request
     222//       TEST(Tcontrol_t,out_PREDICT_ACK      [i]->read(),1); // Accept new request
    214223      TEST(Tcontrol_t,out_BRANCH_EVENT_VAL [i]->read(),0);
    215224      TEST(Tdepth_t  ,out_DEPTH_CURRENT    [i]->read(),0);
    … …  
    346355  DELETE1_SC_SIGNAL(out_BRANCH_COMPLETE_ADDRESS_DEST   ,_param->_nb_inst_branch_complete);
    347356
    348   DELETE1_SC_SIGNAL(out_BRANCH_EVENT_VAL            ,_param->_nb_context);
    349   DELETE1_SC_SIGNAL( in_BRANCH_EVENT_ACK            ,_param->_nb_context);
    350 //DELETE1_SC_SIGNAL(out_BRANCH_EVENT_CONTEXT_ID     ,_param->_nb_context);
    351 //DELETE1_SC_SIGNAL(out_BRANCH_EVENT_DEPTH          ,_param->_nb_context);
    352 //DELETE1_SC_SIGNAL(out_BRANCH_EVENT_MISS_PREDICTION,_param->_nb_context);
    353   DELETE1_SC_SIGNAL(out_BRANCH_EVENT_ADDRESS_SRC    ,_param->_nb_context);
    354   DELETE1_SC_SIGNAL(out_BRANCH_EVENT_ADDRESS_DEST   ,_param->_nb_context);
     357  DELETE1_SC_SIGNAL(out_BRANCH_EVENT_VAL              ,_param->_nb_context);
     358  DELETE1_SC_SIGNAL( in_BRANCH_EVENT_ACK              ,_param->_nb_context);
     359//DELETE1_SC_SIGNAL(out_BRANCH_EVENT_CONTEXT_ID       ,_param->_nb_context);
     360//DELETE1_SC_SIGNAL(out_BRANCH_EVENT_DEPTH            ,_param->_nb_context);
     361//DELETE1_SC_SIGNAL(out_BRANCH_EVENT_MISS_PREDICTION  ,_param->_nb_context);
     362  DELETE1_SC_SIGNAL(out_BRANCH_EVENT_ADDRESS_SRC      ,_param->_nb_context);
     363  DELETE1_SC_SIGNAL(out_BRANCH_EVENT_ADDRESS_DEST_VAL ,_param->_nb_context);
     364  DELETE1_SC_SIGNAL(out_BRANCH_EVENT_ADDRESS_DEST     ,_param->_nb_context);
     365
     366  DELETE1_SC_SIGNAL( in_EVENT_STATE                    ,_param->_nb_context);
     367  DELETE1_SC_SIGNAL( in_EVENT_TYPE                     ,_param->_nb_context);
     368  DELETE1_SC_SIGNAL( in_EVENT_DEPTH                    ,_param->_nb_context);
    355369
    356370  DELETE1_SC_SIGNAL(out_DEPTH_CURRENT      ,_param->_nb_context);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/SelfTest/config_mono_context.cfg

    r94 r95  
    11Update_Prediction_Table
    221       1       +1      # nb_context             
    3 4       8       *2      # size_upt_queue         [0] [nb_context]
     34       8       +1      # size_upt_queue         [0] [nb_context]
    441       4       +1      # size_ufpt_queue        [0] [nb_context]
    5532      32      *2      # size_address           

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/SelfTest/src/test.cpp

    r94 r95  
    77 */
    88
    9 #define NB_ITERATION  8
    10 #define CYCLE_MAX     (128*NB_ITERATION)
     9#define NB_ITERATION  16
     10#define CYCLE_MAX     (1024*NB_ITERATION)
    1111
    1212#include "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/SelfTest/include/test.h"
    … …  
    136136  ALLOC1_SC_SIGNAL(out_UPDATE_RAS_INDEX               ,"out_UPDATE_RAS_INDEX               ",Tptr_t             ,_param->_nb_inst_update);
    137137  ALLOC1_SC_SIGNAL(out_UPDATE_RAS_PREDICTION_IFETCH   ,"out_UPDATE_RAS_PREDICTION_IFETCH   ",Tcontrol_t         ,_param->_nb_inst_update);
     138
     139  ALLOC1_SC_SIGNAL( in_EVENT_STATE                    ," in_EVENT_STATE                    ",Tevent_state_t     ,_param->_nb_context);
     140  ALLOC1_SC_SIGNAL( in_EVENT_TYPE                     ," in_EVENT_TYPE                     ",Tevent_type_t      ,_param->_nb_context);
     141  ALLOC1_SC_SIGNAL( in_EVENT_DEPTH                    ," in_EVENT_DEPTH                    ",Tdepth_t           ,_param->_nb_context);
     142
    138143  ALLOC1_SC_SIGNAL(out_DEPTH_CURRENT                  ,"out_DEPTH_CURRENT                  ",Tdepth_t           ,_param->_nb_context);
    139144  ALLOC1_SC_SIGNAL(out_DEPTH_MIN                      ,"out_DEPTH_MIN                      ",Tdepth_t           ,_param->_nb_context);
    … …  
    225230  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_UPDATE_RAS_INDEX               ,_param->_nb_inst_update);
    226231  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_UPDATE_RAS_PREDICTION_IFETCH   ,_param->_nb_inst_update);
     232  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_EVENT_STATE                    ,_param->_nb_context);
     233  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_EVENT_TYPE                     ,_param->_nb_context);
    227234  if (_param->_have_port_depth)
    228235    {
     236  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_EVENT_DEPTH                    ,_param->_nb_context);
    229237  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_DEPTH_CURRENT                  ,_param->_nb_context);
    230238  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_DEPTH_MIN                      ,_param->_nb_context);
    … …  
    253261  const  int32_t percent_transaction_branch_event    = 75;
    254262
    255   const bool     test1 = false;
    256   const bool     test2 = false;
    257   const bool     test3 = false;
     263  const bool     test1 = true;
     264  const bool     test2 = true;
     265  const bool     test3 = true;
    258266  const bool     test4 = true;
    259267
    … …  
    270278  in_NRESET->write(1); 
    271279
    272   Tdepth_t ufpt_bottom [_param->_nb_context];
    273   Tdepth_t ufpt_top    [_param->_nb_context];
    274 
    275   Tdepth_t upt_bottom  [_param->_nb_context];
    276   Tdepth_t upt_top     [_param->_nb_context];
     280  Tdepth_t ufpt_bottom  [_param->_nb_context];
     281  Tdepth_t ufpt_top     [_param->_nb_context];
     282                       
     283  Tdepth_t upt_bottom   [_param->_nb_context];
     284  Tdepth_t upt_top      [_param->_nb_context];
     285  Tdepth_t upt_top_event[_param->_nb_context];
    277286
    278287  for (uint32_t i=0; i<_param->_nb_context; ++i)
    279288    {
    280       ufpt_bottom [i] = 0;
    281       ufpt_top    [i] = 0;
    282       upt_bottom  [i] = 0;
    283       upt_top     [i] = 0;
     289      ufpt_bottom  [i] = 0;
     290      ufpt_top     [i] = 0;
     291      upt_bottom   [i] = 0;
     292      upt_top      [i] = 0;
     293      upt_top_event[i] = 0;
    284294    }
    285295
    … …  
    305315      for (uint32_t i=0; i<_param->_nb_inst_update; ++i)
    306316        in_UPDATE_ACK          [i]->write(0);
    307 
     317      for (uint32_t i=0; i<_param->_nb_context; ++i)
     318        {
     319        in_EVENT_STATE [i]->write(EVENT_STATE_NO_EVENT);
     320        in_EVENT_TYPE  [i]->write(EVENT_TYPE_NONE     );
     321        }
    308322      //---------------------------------------------------------------------
    309323      //---------------------------------------------------------------------
    … …  
    913927          }
    914928        }
    915 
     929 
     930        {
     931          LABEL("EVENT_STATE");
     932         
     933          SC_START(1);
     934          in_EVENT_STATE [context]->write(EVENT_STATE_END            );
     935          in_EVENT_TYPE  [context]->write(EVENT_TYPE_MISS_SPECULATION);
     936
     937          SC_START(1);
     938          in_EVENT_STATE [context]->write(EVENT_STATE_NO_EVENT       );
     939          in_EVENT_TYPE  [context]->write(EVENT_TYPE_NONE            );
     940        }
    916941
    917942        // Wait Garbage Collector
    … …  
    13371362        }
    13381363
     1364        {
     1365          LABEL("EVENT_STATE");
     1366         
     1367          SC_START(1);
     1368          in_EVENT_STATE [context]->write(EVENT_STATE_END            );
     1369          in_EVENT_TYPE  [context]->write(EVENT_TYPE_MISS_SPECULATION);
     1370
     1371          SC_START(1);
     1372          in_EVENT_STATE [context]->write(EVENT_STATE_NO_EVENT       );
     1373          in_EVENT_TYPE  [context]->write(EVENT_TYPE_NONE            );
     1374        }
     1375
    13391376        // Wait Garbage Collector
    13401377        {
    … …  
    13781415                request.take_good        = 1;                                             
    13791416                request.flag             = (request.condition == BRANCH_CONDITION_FLAG_SET)?request.take_good:(not request.take_good);
    1380                 request.is_accurate      = false;
     1417                request.is_accurate      = true ;
    13811418                request.miss_ifetch      = false;
    13821419                request.miss_decod       = false;
    … …  
    14721509                    LABEL("DECOD           [%d] %d - %d",
    14731510                          port,
    1474                           in_PREDICT_VAL [port]->read(),
    1475                           out_PREDICT_ACK [port]->read());
     1511                          in_DECOD_VAL [port]->read(),
     1512                          out_DECOD_ACK [port]->read());
    14761513                   
    14771514                    if (in_DECOD_VAL [port]->read() and out_DECOD_ACK [port]->read())
    … …  
    15201557                request.take_good        = 1;                                             
    15211558                request.flag             = (request.condition == BRANCH_CONDITION_FLAG_SET)?request.take_good:(not request.take_good);
    1522                 request.is_accurate      = false;
     1559                request.is_accurate      = true ;
    15231560                request.miss_ifetch      = false;
    15241561                request.miss_decod       = false;
    … …  
    15831620          std::list<request_t>::iterator it_event;
    15841621          {
    1585             LABEL("BRANCH_COMPLETE - hit ifetch");
     1622            LABEL("BRANCH_COMPLETE - Miss ifetch");
    15861623           
    15871624            uint32_t port = rand() % _param->_nb_inst_branch_complete;
    … …  
    16001637
    16011638            if (update_ras(it_event->condition))
    1602               it_event->address_good = ~(it_event->address_dest);
     1639              {
     1640                it_event->address_good = ~(it_event->address_dest);
     1641              }
    16031642            else
    16041643              {
    … …  
    16491688                      TEST(Taddress_t,out_BRANCH_COMPLETE_ADDRESS_DEST   [port]->read(),it_event->address_good);
    16501689
    1651                       upt_top [it_event->context] = it_event->upt_ptr;
     1690                      upt_top_event [it_event->context] = upt_top [it_event->context];
     1691                      upt_top       [it_event->context] = it_event->upt_ptr;
     1692                    }
     1693                 
     1694                  SC_START(1);
     1695                } while (not have_transaction);
     1696             
     1697              in_BRANCH_COMPLETE_VAL [port]->write(0);
     1698             
     1699              if (_param->_have_port_depth)
     1700              TEST(Tdepth_t,out_DEPTH_MIN [context]->read(), upt_bottom [context]);
     1701              TEST(Tdepth_t,out_DEPTH_MAX [context]->read(), upt_top [context]);
     1702            }
     1703          }
     1704
     1705          {
     1706            LABEL("BRANCH_COMPLETE - Hit ifetch");
     1707           
     1708            uint32_t port = rand() % _param->_nb_inst_branch_complete;
     1709           
     1710            LABEL("  * port    : %d",port);
     1711           
     1712            std::list<request_t>::iterator it_upt = upt.begin();
     1713           
     1714            while (it_upt != it_event)
     1715            {
     1716              bool have_transaction = false;
     1717             
     1718              do
     1719                {
     1720                  in_BRANCH_COMPLETE_VAL        [port]->write((rand()%100)<percent_transaction_branch_complete);
     1721                  in_BRANCH_COMPLETE_CONTEXT_ID [port]->write(it_upt->context     );
     1722                  in_BRANCH_COMPLETE_DEPTH      [port]->write(it_upt->upt_ptr     );
     1723                  in_BRANCH_COMPLETE_ADDRESS    [port]->write(it_upt->address_dest);
     1724                  in_BRANCH_COMPLETE_FLAG       [port]->write(it_upt->flag        );
     1725
     1726                  if (_param->_have_port_depth)
     1727                  TEST(Tdepth_t,out_DEPTH_MIN [context]->read(), upt_bottom [context]);
     1728                  TEST(Tdepth_t,out_DEPTH_MAX [context]->read(), upt_top [context]);
     1729                 
     1730                  SC_START(0);
     1731                 
     1732                  LABEL("BRANCH_COMPLETE [%d] %d - %d.",port,in_BRANCH_COMPLETE_VAL [port]->read(),out_BRANCH_COMPLETE_ACK [port]->read());
     1733                 
     1734                  if (in_BRANCH_COMPLETE_VAL [port]->read() and out_BRANCH_COMPLETE_ACK [port]->read())
     1735                    {
     1736                      LABEL("BRANCH_COMPLETE [%d] - Transaction accepted",port);
     1737                      LABEL("  * CONTEXT_ID %d"  ,it_upt->context     );
     1738                      LABEL("  * DEPTH      %d"  ,it_upt->upt_ptr     );
     1739                      LABEL("  * CONDITION  %d"  ,it_upt->condition   );
     1740                      LABEL("  * ADDRESS    %.8x",it_upt->address_dest);
     1741                      LABEL("  * FLAG       %d"  ,it_upt->flag        );
     1742
     1743                      have_transaction = true;
     1744                     
     1745                      TEST(Tcontrol_t,out_BRANCH_COMPLETE_MISS_PREDICTION[port]->read(),it_upt->miss_commit );
     1746                      TEST(Tcontrol_t,out_BRANCH_COMPLETE_TAKE           [port]->read(),it_upt->take        );
     1747                      it_upt->take_good = it_upt->take;
     1748                      TEST(Taddress_t,out_BRANCH_COMPLETE_ADDRESS_SRC    [port]->read(),it_upt->address_src );
     1749                      TEST(Taddress_t,out_BRANCH_COMPLETE_ADDRESS_DEST   [port]->read(),it_upt->address_dest);
     1750
     1751                      it_upt++;
    16521752                    }
    16531753                 
    … …  
    17401840
    17411841          {
    1742             LABEL("UPDATE - upt");
     1842            LABEL("UPDATE - upt (after event)");
    17431843           
    17441844            uint32_t port = 0;
    … …  
    17461846            LABEL("  * port    : %d",port);
    17471847            std::list<request_t>::iterator it_upt = upt.end();
    1748             --it_upt;
    17491848
    17501849//             for (uint32_t i=0; i<upt.size(); i++)
    1751             while (it_upt != it_event)
     1850            do
    17521851              {
     1852                --it_upt;
     1853               
    17531854                bool have_transaction = false;
    17541855               
     1856                if (need_update(it_upt->condition))
    17551857                do
    17561858                  {
    … …  
    17681870                      {
    17691871                        LABEL("UPDATE [%d] - Transaction accepted",port);
     1872                        LABEL("  * address_src                : %.8x",it_upt->address_src);
     1873                        LABEL("  * out_UPDATE_BTB_ADDRESS_SRC : %.8x",out_UPDATE_BTB_ADDRESS_SRC[port]->read());
     1874
    17701875                        have_transaction = true;
    17711876                       
     1877                        bool btb_val = ((it_upt == it_event) and
     1878                                        (update_btb(it_upt->condition)));
     1879                        bool dir_val = ((it_upt == it_event) and
     1880                                        update_dir(it_upt->condition) and
     1881                                        not (it_upt->miss_ifetch or it_upt->miss_decod));
     1882                        bool ras_val = update_ras(it_upt->condition);
     1883
    17721884                        if (_param->_have_port_context_id)
    17731885                        TEST(Tcontext_t         ,out_UPDATE_CONTEXT_ID            [port]->read(),it_upt->context);
    17741886                        TEST(Tcontrol_t         ,out_UPDATE_MISS_PREDICTION       [port]->read(),it_upt->miss_commit);
    1775                         TEST(Tcontrol_t         ,out_UPDATE_DIRECTION_GOOD        [port]->read(),it_upt->take_good);
    1776                         TEST(Tcontrol_t         ,out_UPDATE_BTB_VAL               [port]->read(),update_btb(it_upt->condition));
    1777                         if (update_btb(it_upt->condition))
     1887                        TEST(Tcontrol_t         ,out_UPDATE_BTB_VAL               [port]->read(),btb_val);
     1888
     1889                        if (btb_val)
    17781890                          {
    17791891                        TEST(Taddress_t         ,out_UPDATE_BTB_ADDRESS_SRC       [port]->read(),it_upt->address_src);
    … …  
    17811893                        TEST(Tbranch_condition_t,out_UPDATE_BTB_CONDITION         [port]->read(),it_upt->condition);
    17821894                          }
    1783                         TEST(Tcontrol_t         ,out_UPDATE_DIR_VAL               [port]->read(),update_dir(it_upt->condition) and not (it_upt->miss_ifetch or it_upt->miss_decod));
     1895                        TEST(Tcontrol_t         ,out_UPDATE_DIR_VAL               [port]->read(),dir_val);
    17841896                       
    1785                         if (update_dir(it_upt->condition))
     1897                        if (dir_val)
     1898                          {
     1899                        TEST(Tcontrol_t         ,out_UPDATE_DIRECTION_GOOD        [port]->read(),it_upt->take_good);
    17861900                        if (_param->_have_port_history)
    17871901                        TEST(Thistory_t         ,out_UPDATE_DIR_HISTORY           [port]->read(),it_upt->history);
    1788                         TEST(Tcontrol_t         ,out_UPDATE_RAS_VAL               [port]->read(),update_ras(it_upt->condition));
    1789                         if (update_ras(it_upt->condition))
     1902                          }
     1903                        TEST(Tcontrol_t         ,out_UPDATE_RAS_VAL               [port]->read(),ras_val);
     1904
     1905                        if (ras_val)
    17901906                          {
    17911907//                      TEST(Tcontrol_t         ,out_UPDATE_RAS_FLUSH             [port]->read(),0);
    … …  
    17961912                          }
    17971913
    1798                         -- it_upt;
     1914//                         -- it_upt;
    17991915                      }
    18001916                   
    … …  
    18081924//               TEST(Tdepth_t,out_DEPTH_MAX [context]->read(), upt_top [context]);
    18091925              }
     1926            while (it_upt != it_event);
     1927
    18101928          }
    1811 //           upt.clear(); // Not yet
    1812 
     1929         
    18131930          {
    18141931            LABEL("BRANCH_EVENT - have miss decod");
    … …  
    18521969            }
    18531970          }
    1854          
     1971
    18551972          {
    1856             LABEL("UPDATE - upt");
     1973            LABEL("EVENT_STATE");
     1974           
     1975            SC_START(1);
     1976            in_EVENT_STATE [context]->write(EVENT_STATE_END            );
     1977            in_EVENT_TYPE  [context]->write(EVENT_TYPE_MISS_SPECULATION);
     1978           
     1979            SC_START(1);
     1980            in_EVENT_STATE [context]->write(EVENT_STATE_NO_EVENT       );
     1981            in_EVENT_TYPE  [context]->write(EVENT_TYPE_NONE            );
     1982          }
     1983
     1984          {
     1985            LABEL("UPDATE - upt (before event)");
    18571986           
    18581987            uint32_t port = 0;
    18591988           
    18601989            LABEL("  * port    : %d",port);
     1990            LABEL("  * size    : %d",upt.size());
    18611991            std::list<request_t>::iterator it_upt = upt.begin();
    18621992
    … …  
    19082038                          }
    19092039
    1910                         -- it_upt;
     2040                        ++ it_upt;
    19112041                      }
    19122042                   
    … …  
    19202050              }
    19212051          }
    1922           upt.clear(); // Not yet
     2052          upt.clear();
    19232053
    19242054          // Wait Garbage Collector
    19252055          {
    1926             upt_bottom [context] = (upt_bottom [context]+1)%_param->_size_upt_queue[context];
    1927 //        upt_top    [context] = (upt_top    [context]);
     2056            LABEL("GARBAGE COLLECTOR");
     2057            LABEL(" * upt bottom : %d",upt_bottom [context]);
     2058            LABEL(" * upt top    : %d",upt_top    [context]);
     2059
     2060            upt_top    [context] = (upt_top_event [context]);
     2061            upt_bottom [context] = (upt_top       [context]);
    19282062
    19292063            while ((upt_bottom [context] != out_DEPTH_MIN [context]->read()) or
    19302064                   (upt_top    [context] != out_DEPTH_MAX [context]->read()))
    1931               SC_START(1);
     2065              {
     2066                SC_START(1);
     2067              }
    19322068           
    19332069          }
    … …  
    19932129  delete [] out_BRANCH_EVENT_VAL            ;
    19942130  delete []  in_BRANCH_EVENT_ACK            ;
    1995 //   delete []  in_BRANCH_EVENT_CONTEXT_ID     ;
    1996 //   delete []  in_BRANCH_EVENT_DEPTH          ;
    1997 //   delete [] out_BRANCH_EVENT_MISS_PREDICTION;
     2131//delete []  in_BRANCH_EVENT_CONTEXT_ID     ;
     2132//delete []  in_BRANCH_EVENT_DEPTH          ;
     2133//delete [] out_BRANCH_EVENT_MISS_PREDICTION;
    19982134  delete [] out_BRANCH_EVENT_ADDRESS_SRC    ;
    19992135  delete [] out_BRANCH_EVENT_ADDRESS_DEST_VAL;
    … …  
    20192155  delete [] out_UPDATE_RAS_PREDICTION_IFETCH;
    20202156
     2157  DELETE1_SC_SIGNAL( in_EVENT_STATE                    ,_param->_nb_context);
     2158  DELETE1_SC_SIGNAL( in_EVENT_TYPE                     ,_param->_nb_context);
     2159  DELETE1_SC_SIGNAL( in_EVENT_DEPTH                    ,_param->_nb_context);
     2160
    20212161  // ~~~~~[ Interface : "depth" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    20222162  delete [] out_DEPTH_CURRENT;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/include/Types.h

    r88 r95  
    2121  typedef enum
    2222    {
    23       EVENT_STATE_OK                 , // Can predict
    24       EVENT_STATE_FLUSH_UFPT         , // in decod  stage, detect a miss, continue to execute but flush ufpt
    25       EVENT_STATE_FLUSH_UFPT_AND_UPT , // in commit stage, detect a miss, stop context and flush ufpt and upt
    26       EVENT_STATE_FLUSH_UPT_RAS      , // in commit stage, detect a miss, context is stop and ufpt is flush, update RAS
    27       EVENT_STATE_FLUSH_UPT          , // in commit stage, detect a miss, context is stop and ufpt is flush
    28       EVENT_STATE_UPDATE_CONTEXT       // prediction unit is update, send signal to context manager
     23      EVENT_STATE_OK                    , // Can predict
     24      EVENT_STATE_FLUSH_UFPT            , // in decod  stage, detect a miss, continue to execute but flush ufpt
     25      EVENT_STATE_FLUSH_UFPT_AND_UPT    , // in commit stage, detect a miss, stop context and flush ufpt and upt
     26      EVENT_STATE_FLUSH_UPT             , // in commit stage, detect a miss, context is stop and ufpt is flush, update RAS
     27      EVENT_STATE_UPDATE_CONTEXT        , // prediction unit is update, send signal to context manager
     28      EVENT_STATE_WAIT_END_EVENT          // prediction unit is ok, wait the end of envent (send by Context State)
    2929    } event_state_t;
    3030
    … …  
    4444      UPDATE_PREDICTION_STATE_KO                , // this branch is a miss prediction
    4545      UPDATE_PREDICTION_STATE_EVENT             , // previous branch is a miss prediction
    46       UPDATE_PREDICTION_STATE_END                 // branch is updated
     46      UPDATE_PREDICTION_STATE_END_OK            , // branch is updated,       update pointer
     47      UPDATE_PREDICTION_STATE_END_KO              // branch is updated, don't update pointer
    4748    } upt_state_t;
    4849
    … …  
    114115    switch (x)
    115116      {
    116       case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::EVENT_STATE_OK                   : return "ok"                  ; break;
    117       case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::EVENT_STATE_FLUSH_UFPT           : return "flush_ufpt"          ; break;
    118       case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::EVENT_STATE_FLUSH_UFPT_AND_UPT   : return "flush_ufpt_and_upt"  ; break;
    119       case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::EVENT_STATE_FLUSH_UPT_RAS        : return "flush_upt_ras"       ; break;
    120       case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::EVENT_STATE_FLUSH_UPT            : return "flush_upt"           ; break;
    121       case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::EVENT_STATE_UPDATE_CONTEXT       : return "update_context"      ; break;
     117      case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::EVENT_STATE_OK                      : return "ok"                     ; break;
     118      case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::EVENT_STATE_FLUSH_UFPT              : return "flush_ufpt"             ; break;
     119      case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::EVENT_STATE_FLUSH_UFPT_AND_UPT      : return "flush_ufpt_and_upt"     ; break;
     120      case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::EVENT_STATE_FLUSH_UPT               : return "flush_upt"              ; break;
     121      case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::EVENT_STATE_UPDATE_CONTEXT          : return "update_context"         ; break;
     122      case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::EVENT_STATE_WAIT_END_EVENT          : return "wait_and_event"         ; break;
    122123      default    : return ""      ; break;
    123124      }
    … …  
    145146      case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::UPDATE_PREDICTION_STATE_KO         : return "ko"        ; break;
    146147      case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::UPDATE_PREDICTION_STATE_EVENT      : return "event"     ; break;
    147       case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::UPDATE_PREDICTION_STATE_END        : return "end"       ; break;
     148      case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::UPDATE_PREDICTION_STATE_END_OK     : return "end_ok"    ; break;
     149      case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::UPDATE_PREDICTION_STATE_END_KO     : return "end_ko"    ; break;
    148150      default    : return ""      ; break;
    149151      }

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/include/Update_Prediction_Table.h

    r94 r95  
    170170  private   : uint32_t                      * reg_UPT_BOTTOM                     ; //[nb_context]
    171171  private   : uint32_t                      * reg_UPT_TOP                        ; //[nb_context]
     172  private   : uint32_t                      * reg_UPT_TOP_EVENT                  ; //[nb_context]
    172173  private   : uint32_t                      * reg_UPT_UPDATE                     ; //[nb_context]
    173174                                                                                             

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src/Update_Prediction_Table_allocation.cpp

    r94 r95  
    197197    ALLOC1(reg_UPT_BOTTOM                   ,uint32_t     ,_param->_nb_context);
    198198    ALLOC1(reg_UPT_TOP                      ,uint32_t     ,_param->_nb_context);
     199    ALLOC1(reg_UPT_TOP_EVENT                ,uint32_t     ,_param->_nb_context);
    199200    ALLOC1(reg_UPT_UPDATE                   ,uint32_t     ,_param->_nb_context);
    200201

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src/Update_Prediction_Table_deallocation.cpp

    r94 r95  
    8080
    8181        // ~~~~~[ Interface : "branch_event" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    82         delete [] out_BRANCH_EVENT_VAL            ;
    83         delete []  in_BRANCH_EVENT_ACK            ;
    84 //      if (_param->_have_port_context_id)
    85 //      delete []  in_BRANCH_EVENT_CONTEXT_ID     ;
    86 //      if (_param->_have_port_depth)
    87 //      delete []  in_BRANCH_EVENT_DEPTH          ;
    88 //      delete [] out_BRANCH_EVENT_MISS_PREDICTION;
    89         delete [] out_BRANCH_EVENT_ADDRESS_SRC    ;
    90         delete [] out_BRANCH_EVENT_ADDRESS_DEST_VAL;
    91         delete [] out_BRANCH_EVENT_ADDRESS_DEST   ;
    92        
     82        DELETE1_SIGNAL(out_BRANCH_EVENT_VAL              ,_param->_nb_context,1);
     83        DELETE1_SIGNAL( in_BRANCH_EVENT_ACK              ,_param->_nb_context,1);
     84//      DELETE1_SIGNAL(out_BRANCH_EVENT_CONTEXT_ID       ,_param->_nb_context,_param->_size_context_id);
     85//      DELETE1_SIGNAL(out_BRANCH_EVENT_DEPTH            ,_param->_nb_context,_param->_size_depth);
     86//      DELETE1_SIGNAL(out_BRANCH_EVENT_MISS_PREDICTION  ,_param->_nb_context,1);
     87        DELETE1_SIGNAL(out_BRANCH_EVENT_ADDRESS_SRC      ,_param->_nb_context,_param->_size_instruction_address);
     88        DELETE1_SIGNAL(out_BRANCH_EVENT_ADDRESS_DEST_VAL ,_param->_nb_context,1);
     89        DELETE1_SIGNAL(out_BRANCH_EVENT_ADDRESS_DEST     ,_param->_nb_context,_param->_size_instruction_address);
     90
    9391        // ~~~~~[ Interface : "update" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    9492        delete [] out_UPDATE_VAL                  ;
    … …  
    118116
    119117        // ~~~~~[ Interface : "depth" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    120         if (_param->_have_port_depth)
    121           {
    122         delete [] out_DEPTH_CURRENT;
    123         delete [] out_DEPTH_MIN;
    124           }
    125         delete [] out_DEPTH_MAX;
    126        
     118        DELETE1_SIGNAL(out_DEPTH_CURRENT      ,_param->_nb_context,_param->_size_depth);
     119        DELETE1_SIGNAL(out_DEPTH_MIN          ,_param->_nb_context,_param->_size_depth);
     120        DELETE1_SIGNAL(out_DEPTH_MAX          ,_param->_nb_context,_param->_size_depth+1);
     121
    127122        // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    128123        DELETE1(internal_PREDICT_ACK                     ,_param->_nb_inst_predict);
    … …  
    155150        DELETE1(reg_UPT_BOTTOM                   ,_param->_nb_context);
    156151        DELETE1(reg_UPT_TOP                      ,_param->_nb_context);
     152        DELETE1(reg_UPT_TOP_EVENT                ,_param->_nb_context);
    157153        DELETE1(reg_UPT_UPDATE                   ,_param->_nb_context);
    158154       

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src/Update_Prediction_Table_genMealy_decod.cpp

    r88 r95  
    2626   
    2727    // WARNING : One branch per context per cycle
     28    if (PORT_READ(in_NRESET) != 0)
     29      {
    2830    for (uint32_t i=0; i<_param->_nb_inst_decod; i++)
    2931      {
    … …  
    5860        PORT_WRITE(out_DECOD_ACK [i], internal_DECOD_ACK [i]);
    5961      }
    60 
     62      }
    6163    log_end(Update_Prediction_Table,FUNCTION);
    6264  };

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src/Update_Prediction_Table_genMoore.cpp

    r94 r95  
    5757        event_state_t event_state = reg_EVENT_STATE [i];
    5858
    59         retire_ras_from_ufpt [i] = ((event_state == EVENT_STATE_FLUSH_UFPT        ) or
     59        retire_ras_from_ufpt [i] = ((event_state == EVENT_STATE_FLUSH_UFPT            ) or
    6060                                    (event_state == EVENT_STATE_FLUSH_UFPT_AND_UPT));
    61         retire_ras_from_upt  [i] = (event_state == EVENT_STATE_FLUSH_UPT_RAS);
     61        retire_ras_from_upt  [i] = (event_state == EVENT_STATE_FLUSH_UPT);
    6262
    6363        ufpt_update          [i] = true;
    … …  
    154154                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * condition       : %s",toString(condition).c_str());
    155155             
    156                 Tcontrol_t          state_is_ok_ko           = ((state == UPDATE_PREDICTION_STATE_OK) or
    157                                                                 (state == UPDATE_PREDICTION_STATE_KO));
    158                 Tcontrol_t          state_is_event           = (state == UPDATE_PREDICTION_STATE_EVENT);
     156                Tcontrol_t          state_is_ok_ko           = ((state == UPDATE_PREDICTION_STATE_OK   ) or
     157                                                                (state == UPDATE_PREDICTION_STATE_KO   ));
     158                Tcontrol_t          state_is_event           = ((state == UPDATE_PREDICTION_STATE_KO   ) or
     159                                                                (state == UPDATE_PREDICTION_STATE_EVENT));
    159160                Tcontrol_t          state_is_event_update    = state_is_event and     need_update(condition);
    160161                Tcontrol_t          state_is_event_no_update = state_is_event and not need_update(condition);
    … …  
    167168                else
    168169                  {
    169                 val                   = state_is_ok_ko;
     170                val                   = (state == UPDATE_PREDICTION_STATE_OK);
    170171                val_without_ack       = false;
    171172                  }                 
    … …  
    173174                miss_prediction       = (state != UPDATE_PREDICTION_STATE_OK);
    174175                direction_good        = reg_UPDATE_PREDICTION_TABLE [context][depth]._good_take   ;
    175                 btb_val               = update_btb(condition);
     176                btb_val               = state_is_ok_ko and update_btb(condition);
    176177                btb_address_src       = reg_UPDATE_PREDICTION_TABLE [context][depth]._address_src ;
    177178                btb_address_dest      = reg_UPDATE_PREDICTION_TABLE [context][depth]._address_dest;
    178179                btb_condition         = condition;
    179                 dir_val               = update_dir(condition) and ifetch; // if not ifetch, then static prediction
     180                dir_val               = state_is_ok_ko and update_dir(condition) and ifetch; // if not ifetch, then static prediction
    180181                dir_history           = reg_UPDATE_PREDICTION_TABLE [context][depth]._history     ;
    181182                ras_val               = update_ras(condition); // repop/ repush data -> don't corrupt ras
    … …  
    208209              }
    209210          }
    210 
     211       
    211212        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * val             : %d",val    );
    212213        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * val_without_ack : %d",val_without_ack);
     214        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * miss_prediction : %d",miss_prediction);
     215        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * direction_good  : %d",direction_good );
    213216        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * btb_val         : %d",btb_val);
    214217        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * dir_val         : %d",dir_val);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src/Update_Prediction_Table_transition.cpp

    r94 r95  
    4444            reg_UPT_BOTTOM           [i] = 0;
    4545            reg_UPT_TOP              [i] = 0;
     46            reg_UPT_TOP_EVENT        [i] = 0;
    4647            reg_UPT_UPDATE           [i] = 0;
    4748                                                                                   
    … …  
    8788            {
    8889              uint32_t bottom = reg_UPT_BOTTOM [i];
    89              
     90              bool     end_ok = (reg_UPDATE_PREDICTION_TABLE [i][bottom]._state == UPDATE_PREDICTION_STATE_END_OK);
     91              bool     end_ko = (reg_UPDATE_PREDICTION_TABLE [i][bottom]._state == UPDATE_PREDICTION_STATE_END_KO);
     92
    9093              // Test if state is end
    91               if (reg_UPDATE_PREDICTION_TABLE [i][bottom]._state == UPDATE_PREDICTION_STATE_END)
     94              if (end_ok or end_ko)
    9295                {
    9396                  log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * UPT [%d][%d]",i,bottom);
    … …  
    9699                  // Free slot
    97100                  reg_UPDATE_PREDICTION_TABLE [i][bottom]._state = UPDATE_PREDICTION_STATE_EMPTY;
     101
    98102                  // Update pointer
    99103                  reg_UPT_BOTTOM [i] = (bottom+1)%_param->_size_upt_queue[i];
     104//                   if (bottom = reg_UPT_UPDATE [i])
     105//                     reg_UPT_UPDATE [i] = reg_UPT_BOTTOM [i];
     106                  if (end_ko) // free
     107                    {
     108                      reg_UPT_TOP    [i] = reg_UPT_TOP_EVENT [i];
     109                      reg_UPT_UPDATE [i] = reg_UPT_TOP_EVENT [i];
     110                    }
    100111                }
    101112            }
    … …  
    299310
    300311              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * BRANCH_COMPLETE[%d] - Accepted",i);
    301               log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * context : %d",context);
    302               log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * depth   : %d",depth);
    303               log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * miss    : %d",miss);
     312              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * context    : %d",context);
     313              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * depth      : %d",depth);
     314              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * miss       : %d",miss);
    304315             
    305316              if (miss)
    … …  
    312323                  uint32_t top        = reg_UPT_TOP [context];
    313324                  uint32_t new_update = ((top==0)?_param->_size_upt_queue[context]:top)-1;
     325
     326                  log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * top        : %d",top);
     327                  log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * new_update : %d",new_update);
     328
    314329                  for (uint32_t j=(depth+1)%_param->_size_upt_queue[context];
    315330                                j!=top;
    … …  
    317332                    reg_UPDATE_PREDICTION_TABLE [context][j]._state = UPDATE_PREDICTION_STATE_EVENT;
    318333                 
    319                   // TOP is next write slot : last slot is TOP-1
    320                   reg_UPT_UPDATE [context] = new_update;
    321                  
    322 //                reg_UPT_BOTTOM [context];
    323                   reg_UPT_TOP    [context] = depth;
     334                 
     335//                reg_UPT_BOTTOM    [context];
     336                  reg_UPT_TOP       [context] = depth;
     337                  reg_UPT_TOP_EVENT [context] = top;
    324338
    325339#ifdef DEBUG_TEST
    … …  
    331345                  reg_UPDATE_PREDICTION_TABLE [context][depth]._state = UPDATE_PREDICTION_STATE_KO;
    332346                 
    333 
    334                   Taddress_t          address_src = reg_UPDATE_PREDICTION_TABLE [context][depth]._address_src;
     347                  Taddress_t    address_src         = reg_UPDATE_PREDICTION_TABLE [context][depth]._address_src;
     348                  event_state_t event_state         = reg_EVENT_STATE [context];
     349                  bool          previous_update_ras = (event_state == EVENT_STATE_FLUSH_UPT);
     350                  bool          update_ras          = (new_update != depth);
     351
     352                  log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * update_ras : %d",update_ras);
    335353
    336354                  if (reg_UFPT_NB_NEED_UPDATE [context] > 0)
    … …  
    341359                  else
    342360                    {
    343                       log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * EVENT [%d] <- EVENT_STATE_FLUSH_UFPT_RAS (branch_complete - miss)",context);
    344                       // have ras prediction ?
    345                       reg_EVENT_STATE [context] = (new_update!=depth)?EVENT_STATE_FLUSH_UPT_RAS:EVENT_STATE_UPDATE_CONTEXT;
    346                     }
     361                      if (not previous_update_ras)
     362                        {
     363                          // have ras prediction ?
     364                          log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * EVENT [%d] <- EVENT_STATE_FLUSH_UPT (branch_complete - miss)",context);
     365
     366                          reg_EVENT_STATE [context] = EVENT_STATE_FLUSH_UPT;
     367             
     368                        }
     369                    }
     370
     371                  if (not previous_update_ras)
     372                    {
     373                      reg_UPT_UPDATE [context]  = new_update;
     374                    }
     375                  // else no update
    347376
    348377                  reg_EVENT_ADDRESS_SRC     [context] = address_src; // delay_slot is compute in Context_State
    … …  
    370399        // =====[ UPDATE ]====================================================
    371400        // ===================================================================
    372         for (uint32_t i=0; i<_param->_nb_inst_update; i++)
    373           if ((internal_UPDATE_VAL[i] and PORT_READ(in_UPDATE_ACK [i])) or
    374               (internal_UPDATE_VAL_WITHOUT_ACK [i]))
    375             {
    376               Tcontext_t context = internal_UPDATE_CONTEXT_ID [i];
    377               Tdepth_t   depth   = internal_UPDATE_DEPTH      [i];
    378               log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * UPDATE[%d] - Accepted",i);
    379               log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * context : %d",context);
    380               log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * depth   : %d",depth);
    381 
    382               if (internal_UPDATE_FROM_UFPT [i])
     401        {
     402          bool can_continue [_param->_nb_context];
     403          for (uint32_t i=0; i<_param->_nb_context; ++i)
     404            can_continue [i] = true;
     405
     406          for (uint32_t i=0; i<_param->_nb_inst_update; i++)
     407            {
     408              Tcontext_t context   = internal_UPDATE_CONTEXT_ID [i];
     409
     410              if ((internal_UPDATE_VAL[i] and PORT_READ(in_UPDATE_ACK [i])) or
     411                  (internal_UPDATE_VAL_WITHOUT_ACK [i] and can_continue [context]))
    383412                {
    384                 // if free a slot, also all queue is updated
    385                 // Last slot ?
    386                 if (reg_UFPT_UPDATE [context] == reg_UFPT_BOTTOM [context])
    387                   switch (reg_EVENT_STATE [context])
    388                     {
    389                     case EVENT_STATE_FLUSH_UFPT         : reg_EVENT_STATE [context] = EVENT_STATE_UPDATE_CONTEXT; break;
    390                     case EVENT_STATE_FLUSH_UFPT_AND_UPT : reg_EVENT_STATE [context] = (reg_UPT_UPDATE[context]!=reg_UPT_TOP[context])?EVENT_STATE_FLUSH_UPT_RAS:EVENT_STATE_UPDATE_CONTEXT;  break;
    391                     default : break;
    392                     }
    393                
    394                   log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * Update Fetch Prediction Table");
    395                  
    396                   // Change state
    397 #ifdef DEBUG_TEST
    398                   if (reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._state != UPDATE_FETCH_PREDICTION_STATE_EVENT)
    399                     throw ERRORMORPHEO(FUNCTION,_("Update : invalid ufpt state."));
    400 #endif
    401 
    402                   log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * UFPT [%d][%d].state <- UPDATE_FETCH_PREDICTION_STATE_END (update)",context,depth);
    403 
    404                   reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._state = UPDATE_FETCH_PREDICTION_STATE_END;
    405 
    406 
    407                   // Update pointer
    408                   log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * reg_UFPT_UPDATE (before) : %d",reg_UFPT_UPDATE [context]);
    409                   reg_UFPT_UPDATE [context] = ((depth==0)?_param->_size_ufpt_queue[context]:depth)-1;
    410                   log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * reg_UFPT_UPDATE (after ) : %d",reg_UFPT_UPDATE [context]);
    411                   // Free a register that need update ?
    412                   if (need_update(reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._condition))
    413                     reg_UFPT_NB_NEED_UPDATE [context] --;
     413                  Tdepth_t   depth     = internal_UPDATE_DEPTH      [i];
     414                 
     415                  log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * UPDATE[%d] - Accepted",i);
     416                  log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * context : %d",context);
     417                  log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * depth   : %d",depth);
     418                 
     419                  if (internal_UPDATE_FROM_UFPT [i])
     420                    {
     421                      // if free a slot, also all queue is updated
     422                      // Last slot ?
     423                      if (reg_UFPT_UPDATE [context] == reg_UFPT_BOTTOM [context])
     424                        switch (reg_EVENT_STATE [context])
     425                          {
     426                          case EVENT_STATE_FLUSH_UFPT             : reg_EVENT_STATE [context] = EVENT_STATE_UPDATE_CONTEXT; break;
     427                            // impossible to have an update on ufpt and reg_upt_update>reg_upt_top
     428                          case EVENT_STATE_FLUSH_UFPT_AND_UPT : reg_EVENT_STATE [context] = EVENT_STATE_FLUSH_UPT ; break;
     429                          default : break;
     430                          }
     431                     
     432                      log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * Update Fetch Prediction Table");
     433                     
     434                      // Change state
     435#ifdef DEBUG_TEST
     436                      if (reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._state != UPDATE_FETCH_PREDICTION_STATE_EVENT)
     437                        throw ERRORMORPHEO(FUNCTION,_("Update : invalid ufpt state."));
     438#endif
     439                     
     440                      log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * UFPT [%d][%d].state <- UPDATE_FETCH_PREDICTION_STATE_END (update)",context,depth);
     441                     
     442                      reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._state = UPDATE_FETCH_PREDICTION_STATE_END;
     443                     
     444                     
     445                      // Update pointer
     446                      log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * reg_UFPT_UPDATE (before) : %d",reg_UFPT_UPDATE [context]);
     447                      reg_UFPT_UPDATE [context] = ((depth==0)?_param->_size_ufpt_queue[context]:depth)-1;
     448                      log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * reg_UFPT_UPDATE (after ) : %d",reg_UFPT_UPDATE [context]);
     449                      // Free a register that need update ?
     450                      if (need_update(reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._condition))
     451                        reg_UFPT_NB_NEED_UPDATE [context] --;
     452                    }
     453                  else
     454                    {
     455                      log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * Update Prediction Table");
     456                     
     457                      // Change state
     458#ifdef DEBUG_TEST
     459                      if (internal_UPDATE_RAS [i])
     460                        {
     461                          if ((reg_UPDATE_PREDICTION_TABLE [context][depth]._state != UPDATE_PREDICTION_STATE_EVENT) and
     462                              (reg_UPDATE_PREDICTION_TABLE [context][depth]._state != UPDATE_PREDICTION_STATE_KO   ))
     463                            throw ERRORMORPHEO(FUNCTION,_("Update : invalid upt state."));
     464                        }
     465                      else
     466                        {
     467                          if (reg_UPDATE_PREDICTION_TABLE [context][depth]._state != UPDATE_PREDICTION_STATE_OK   )
     468                            throw ERRORMORPHEO(FUNCTION,_("Update : invalid upt state."));
     469                        }
     470#endif
     471
     472//                    bool have_event = ((reg_UPDATE_PREDICTION_TABLE [context][depth]._state == UPDATE_PREDICTION_STATE_KO) or
     473//                                       (reg_UPDATE_PREDICTION_TABLE [context][depth]._state == UPDATE_PREDICTION_STATE_EVENT));
     474                      bool ko     = (reg_UPDATE_PREDICTION_TABLE [context][depth]._state == UPDATE_PREDICTION_STATE_KO);
     475
     476                      // Have an update, test the state to transiste to the good state
     477                      if (ko)
     478                        {
     479                          log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * UPT  [%d][%d].state <- UPDATE_PREDICTION_STATE_END_KO (update)",context,depth);
     480                         
     481                          reg_UPDATE_PREDICTION_TABLE [context][depth]._state = UPDATE_PREDICTION_STATE_END_KO;
     482                        }
     483                      else
     484                        {
     485                          log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * UPT  [%d][%d].state <- UPDATE_PREDICTION_STATE_END_OK (update)",context,depth);
     486                         
     487                          reg_UPDATE_PREDICTION_TABLE [context][depth]._state = UPDATE_PREDICTION_STATE_END_OK;
     488                        }
     489                     
     490                      // Update pointer
     491                      //  * if update RAS : update pointer is decreaste until it equal at top pointer
     492                      if (internal_UPDATE_RAS [i])
     493                        {
     494                          // if end_event, restart too bottom, else decrease pointer
     495                          bool end_event  = (reg_UPT_UPDATE [context] == reg_UPT_TOP [context]);
     496                         
     497                          reg_UPT_UPDATE [context] = (end_event)?reg_UPT_BOTTOM[context]:(((depth==0)?_param->_size_upt_queue[context]:depth)-1);
     498                          if (end_event)
     499                            {
     500                              reg_UPT_UPDATE [context] = reg_UPT_BOTTOM[context];
     501                              reg_EVENT_STATE [context] = EVENT_STATE_UPDATE_CONTEXT;
     502                            }
     503                          else
     504                            {
     505                              reg_UPT_UPDATE [context] = (((depth==0)?_param->_size_upt_queue[context]:depth)-1);
     506                            }
     507                        }
     508                      else
     509                        {
     510                          // increase pointer
     511                          reg_UPT_UPDATE [context] = (depth+1)%_param->_size_upt_queue[context];
     512                        }
     513                     
     514                      // Free the branch with no accurate ?
     515                      if (reg_UPDATE_PREDICTION_TABLE [context][depth]._is_accurate == false)
     516                        reg_IS_ACCURATE [context] = true;
     517                    }
    414518                }
    415519              else
    416                 {
    417                   log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * Update Prediction Table");
    418                  
    419                   // Change state
    420 #ifdef DEBUG_TEST
    421                   if (internal_UPDATE_RAS [i])
    422                     {
    423                       if (reg_UPDATE_PREDICTION_TABLE [context][depth]._state != UPDATE_PREDICTION_STATE_EVENT)
    424                         throw ERRORMORPHEO(FUNCTION,_("Update : invalid upt state."));
    425                     }
    426                   else
    427                     {
    428                       if ((reg_UPDATE_PREDICTION_TABLE [context][depth]._state != UPDATE_PREDICTION_STATE_OK   ) and
    429                           (reg_UPDATE_PREDICTION_TABLE [context][depth]._state != UPDATE_PREDICTION_STATE_KO   ))
    430                         throw ERRORMORPHEO(FUNCTION,_("Update : invalid upt state."));
    431                     }
    432 #endif
    433 
    434                   log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * UPT  [%d][%d].state <- UPDATE_PREDICTION_STATE_END (update)",context,depth);
    435 
    436                   reg_UPDATE_PREDICTION_TABLE [context][depth]._state = UPDATE_PREDICTION_STATE_END;
    437 
    438                   // Update pointer
    439                   bool end_event = (reg_UPT_UPDATE [context] == reg_UPT_TOP [context]);
    440 
    441                   if (internal_UPDATE_RAS [i])
    442                     {
    443                       reg_UPT_UPDATE [context] = (end_event)?reg_UPT_BOTTOM[context]:(((depth==0)?_param->_size_upt_queue[context]:depth)-1);
    444                     }
    445                   else
    446                     {
    447                       reg_UPT_UPDATE [context] = (depth+1)%_param->_size_upt_queue[context];
    448                     }
    449                  
    450                   // End and event ?
    451                   if (end_event and
    452                       (reg_EVENT_STATE [context] != EVENT_STATE_OK))
    453                     {
    454                       reg_EVENT_STATE [context] = EVENT_STATE_UPDATE_CONTEXT;
    455                     }
    456 
    457                   // Free the branch with no accurate ?
    458                   if (reg_UPDATE_PREDICTION_TABLE [context][depth]._is_accurate == false)
    459                     reg_IS_ACCURATE [context] = true;
    460                 }
    461             }
     520                can_continue [context] = false;
     521            }
    462522       
    463         // Round robin
    464         reg_UPDATE_PRIORITY = (reg_UPDATE_PRIORITY+1)%_param->_nb_context;
     523          // Round robin
     524          reg_UPDATE_PRIORITY = (reg_UPDATE_PRIORITY+1)%_param->_nb_context;
     525        }
    465526
    466527        // ===================================================================
    … …  
    470531          if (internal_BRANCH_EVENT_VAL [i] and PORT_READ(in_BRANCH_EVENT_ACK [i]))
    471532            {
    472               log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * UPDATE[%d] - Accepted",i);
     533              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * BRANCH_EVENT [%d] - Accepted",i);
    473534
    474535#ifdef DEBUG_TEST
    … …  
    478539             
    479540              // Change state
    480               log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * EVENT [%d] <- EVENT_STATE_OK (branch_event)",i);
     541              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * EVENT [%d] <- EVENT_STATE_WAIT_END_EVENT (branch_event)",i);
    481542             
    482               reg_EVENT_STATE [i] = EVENT_STATE_OK;
     543              reg_EVENT_STATE [i] = EVENT_STATE_WAIT_END_EVENT;
    483544            }
     545
     546        // ===================================================================
     547        // =====[ EVENT ]=====================================================
     548        // ===================================================================
     549        for (uint32_t i=0; i<_param->_nb_context; ++i)
     550          {
     551            //----------------------------------------------------------------
     552            // Cases
     553            //----------------------------------------------------------------
     554            //   * EVENT_TYPE_NONE               - nothing
     555            //   * EVENT_TYPE_MISS_SPECULATION   
     556            //     * EVENT_STATE_END             - Change state, reset pointer
     557            //   * EVENT_TYPE_EXCEPTION          -
     558            //     * EVENT_STATE_EVENT           - Flush upft and upt
     559            //     * EVENT_STATE_END             - Change state, reset pointer
     560            //   * EVENT_TYPE_BRANCH_NO_ACCURATE - nothing : manage in decod and update
     561            //   * EVENT_TYPE_SPR_ACCESS         - nothing
     562            //   * EVENT_TYPE_MSYNC              - nothing
     563            //   * EVENT_TYPE_PSYNC              - nothing
     564            //   * EVENT_TYPE_CSYNC              - nothing
     565
     566            Tevent_state_t event_state = PORT_READ(in_EVENT_STATE [i]);
     567            Tevent_type_t  event_type  = PORT_READ(in_EVENT_TYPE  [i]);
     568//             Tdepth_t       depth       = PORT_READ(in_EVENT_DEPTH [i]);
     569           
     570            // Test if end of miss
     571            if ((event_state == EVENT_STATE_END) and
     572                (event_type  == EVENT_TYPE_MISS_SPECULATION))
     573              {
     574                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * EVENT");
     575                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * state : EVENT_STATE_END");
     576                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * type  : EVENT_TYPE_MISS_SPECULATION");
     577
     578#ifdef DEBUG_TEST
     579                if (reg_EVENT_STATE [i] != EVENT_STATE_WAIT_END_EVENT)
     580                  throw ERRORMORPHEO(FUNCTION,_("Event : invalid event state."));
     581#endif
     582               
     583                // Change state
     584                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * EVENT [%d] <- EVENT_STATE_OK (event)",i);
     585               
     586                reg_EVENT_STATE [i] = EVENT_STATE_OK;
     587
     588//                 uint32_t bottom = reg_UPT_BOTTOM [i];
     589
     590//                 reg_UPT_TOP    [i] = bottom;
     591//                 reg_UPT_UPDATE [i] = bottom;
     592              }
     593          }
    484594
    485595        // ===================================================================
    … …  
    561671        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"      * reg_UPT_BOTTOM          : %d",reg_UPT_BOTTOM         [i]);
    562672        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"      * reg_UPT_TOP             : %d",reg_UPT_TOP            [i]);
     673        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"      * reg_UPT_TOP_EVENT       : %d",reg_UPT_TOP_EVENT      [i]);
    563674        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"      * reg_UPT_UPDATE          : %d",reg_UPT_UPDATE         [i]);
    564675        for (uint32_t j=0; j<_param->_size_upt_queue[i]; j++)

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/include/Parameters.h

    r88 r95  
    5151  public : uint32_t *   _ras_size_queue                ;//[nb_context]
    5252  public : uint32_t *   _upt_size_queue                ;//[nb_context]
     53  public : uint32_t *   _ufpt_size_queue               ;//[nb_context]
    5354
    5455//public : uint32_t     _size_context_id               ;
    … …  
    9697                        uint32_t *   ras_size_queue                ,//[nb_context]
    9798                        uint32_t *   upt_size_queue                ,//[nb_context]
     99                        uint32_t *   ufpt_size_queue               ,//[nb_context]
    98100                        bool         is_toplevel=false
    99101                        );

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/include/Prediction_unit.h

    r88 r95  
    111111//public    : SC_OUT(Tcontrol_t         )  ** out_BRANCH_EVENT_MISS_PREDICTION        ; //[nb_context]
    112112  public    : SC_OUT(Taddress_t         )  ** out_BRANCH_EVENT_ADDRESS_SRC            ; //[nb_context]
     113  public    : SC_OUT(Tcontrol_t         )  ** out_BRANCH_EVENT_ADDRESS_DEST_VAL       ; //[nb_context]
    113114  public    : SC_OUT(Taddress_t         )  ** out_BRANCH_EVENT_ADDRESS_DEST           ; //[nb_context]
     115
     116    // ~~~~~[ Interface : "event" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     117  public    : SC_IN (Tevent_state_t     )  **  in_EVENT_STATE                    ; //[nb_context]
     118  public    : SC_IN (Tevent_type_t      )  **  in_EVENT_TYPE                     ; //[nb_context]
     119  public    : SC_IN (Tdepth_t           )  **  in_EVENT_DEPTH                    ; //[nb_context]
    114120
    115121    // ~~~~~[ Interface : "depth" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~           

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/src/Parameters.cpp

    r88 r95  
    4242                          uint32_t *   ras_size_queue                ,//[nb_context]
    4343                          uint32_t *   upt_size_queue                ,//[nb_context]
     44                          uint32_t *   ufpt_size_queue               ,//[nb_context]
    4445                          bool         is_toplevel
    4546                          )
    … …  
    7374    _ras_size_queue             = ras_size_queue            ;
    7475    _upt_size_queue             = upt_size_queue            ;
     76    _ufpt_size_queue            = ufpt_size_queue           ;
    7577   
    7678    _array_size_depth           = new uint32_t [_nb_context];
    … …  
    133135      (_nb_context             ,
    134136       _upt_size_queue         ,
     137       _ufpt_size_queue        ,
    135138       _size_address           ,
    136139       _nb_inst_branch_predict ,

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/src/Parameters_print.cpp

    r82 r95  
    6868        xml.  singleton_begin("ras_size_queue                        "); xml.attribut("value",toString(_ras_size_queue                     [i])); xml.singleton_end();
    6969        xml.  singleton_begin("upt_size_queue                        "); xml.attribut("value",toString(_upt_size_queue                     [i])); xml.singleton_end();
     70        xml.  singleton_begin("ufpt_size_queue                       "); xml.attribut("value",toString(_ufpt_size_queue                    [i])); xml.singleton_end();
    7071        xml. balise_close();
    7172      }

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/src/Prediction_unit_allocation.cpp

    r88 r95  
    113113      ALLOC1_INTERFACE("branch_event", IN,SOUTH, "branch_event", _param->_nb_context);
    114114     
    115       ALLOC1_VALACK_OUT(out_BRANCH_EVENT_VAL            ,VAL);
    116       ALLOC1_VALACK_IN ( in_BRANCH_EVENT_ACK            ,ACK);
    117 //    ALLOC1_SIGNAL_OUT(out_BRANCH_EVENT_CONTEXT_ID     ,"context_id"     ,Tcontext_t,_param->_size_context_id);
    118 //    ALLOC1_SIGNAL_OUT(out_BRANCH_EVENT_DEPTH          ,"depth"          ,Tdepth_t  ,_param->_size_depth);
    119 //    ALLOC1_SIGNAL_OUT(out_BRANCH_EVENT_MISS_PREDICTION,"miss_prediction",Tcontrol_t,1);
    120       ALLOC1_SIGNAL_OUT(out_BRANCH_EVENT_ADDRESS_SRC    ,"address_src"    ,Taddress_t,_param->_size_address);
    121       ALLOC1_SIGNAL_OUT(out_BRANCH_EVENT_ADDRESS_DEST   ,"address_dest"   ,Taddress_t,_param->_size_address);
     115      ALLOC1_VALACK_OUT(out_BRANCH_EVENT_VAL              ,VAL);
     116      ALLOC1_VALACK_IN ( in_BRANCH_EVENT_ACK              ,ACK);
     117//    ALLOC1_SIGNAL_OUT(out_BRANCH_EVENT_CONTEXT_ID       ,"context_id"      ,Tcontext_t,_param->_size_context_id);
     118//    ALLOC1_SIGNAL_OUT(out_BRANCH_EVENT_DEPTH            ,"depth"           ,Tdepth_t  ,_param->_size_depth);
     119//    ALLOC1_SIGNAL_OUT(out_BRANCH_EVENT_MISS_PREDICTION  ,"miss_prediction" ,Tcontrol_t,1);
     120      ALLOC1_SIGNAL_OUT(out_BRANCH_EVENT_ADDRESS_SRC      ,"address_src"     ,Taddress_t,_param->_size_address);
     121      ALLOC1_SIGNAL_OUT(out_BRANCH_EVENT_ADDRESS_DEST_VAL ,"address_dest_val",Tcontrol_t,1);
     122      ALLOC1_SIGNAL_OUT(out_BRANCH_EVENT_ADDRESS_DEST     ,"address_dest"    ,Taddress_t,_param->_size_address);
    122123    }
    123124
    … …  
    129130      ALLOC1_SIGNAL_OUT(out_DEPTH_MIN          ,"min"          ,Tdepth_t,_param->_size_depth);
    130131      ALLOC1_SIGNAL_OUT(out_DEPTH_MAX          ,"max"          ,Tdepth_t,_param->_size_depth+1);
     132    }
     133
     134    // ~~~~~[ Interface : "event" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     135    {
     136      ALLOC1_INTERFACE("event", IN,SOUTH,"event", _param->_nb_context);
     137
     138      ALLOC1_SIGNAL_IN ( in_EVENT_STATE  ,"state",Tevent_state_t,_param->_size_event_state);
     139      ALLOC1_SIGNAL_IN ( in_EVENT_TYPE   ,"type" ,Tevent_type_t ,_param->_size_event_type );
     140      ALLOC1_SIGNAL_IN ( in_EVENT_DEPTH  ,"depth",Tdepth_t      ,_param->_size_depth      );
    131141    }
    132142
    … …  
    509519          COMPONENT_MAP(_component,src , "in_UPDATE_"+toString(i)+    "_PUSH"             ,
    510520                                   dest,"out_UPDATE_"+toString(i)+"_RAS_PUSH"             );
     521          COMPONENT_MAP(_component,src , "in_UPDATE_"+toString(i)+    "_FLUSH"            ,
     522                                   dest,"out_UPDATE_"+toString(i)+"_RAS_FLUSH"            );
    511523          COMPONENT_MAP(_component,src , "in_UPDATE_"+toString(i)+    "_ADDRESS"          ,
    512524                                   dest,"out_UPDATE_"+toString(i)+"_RAS_ADDRESS"          );
    … …  
    636648          //in_UPDATE_UPT_RAS_ADDRESS           - component_map return_address_stack
    637649          //in_UPDATE_UPT_RAS_PUSH              - component_map return_address_stack
     650          //in_UPDATE_UPT_RAS_FLUSH             - component_map return_address_stack
    638651          //in_UPDATE_UPT_RAS_INDEX             - component_map return_address_stack
    639652          //in_UPDATE_UPT_RAS_PREDICTION_IFETCH - component_map return_address_stack
    … …  
    682695#endif
    683696
    684           PORT_MAP(_component,src ,"out_BRANCH_EVENT_"+toString(i)+"_VAL"         ,dest,"out_BRANCH_EVENT_"+toString(i)+"_VAL"         );
    685           PORT_MAP(_component,src , "in_BRANCH_EVENT_"+toString(i)+"_ACK"         ,dest, "in_BRANCH_EVENT_"+toString(i)+"_ACK"         );
    686           PORT_MAP(_component,src ,"out_BRANCH_EVENT_"+toString(i)+"_ADDRESS_SRC" ,dest,"out_BRANCH_EVENT_"+toString(i)+"_ADDRESS_SRC" );
    687           PORT_MAP(_component,src ,"out_BRANCH_EVENT_"+toString(i)+"_ADDRESS_DEST",dest,"out_BRANCH_EVENT_"+toString(i)+"_ADDRESS_DEST");
    688         }
     697          PORT_MAP(_component,src ,"out_BRANCH_EVENT_"+toString(i)+"_VAL"             ,dest,"out_BRANCH_EVENT_"+toString(i)+"_VAL"             );
     698          PORT_MAP(_component,src , "in_BRANCH_EVENT_"+toString(i)+"_ACK"             ,dest, "in_BRANCH_EVENT_"+toString(i)+"_ACK"             );
     699          PORT_MAP(_component,src ,"out_BRANCH_EVENT_"+toString(i)+"_ADDRESS_SRC"     ,dest,"out_BRANCH_EVENT_"+toString(i)+"_ADDRESS_SRC"     );
     700          PORT_MAP(_component,src ,"out_BRANCH_EVENT_"+toString(i)+"_ADDRESS_DEST_VAL",dest,"out_BRANCH_EVENT_"+toString(i)+"_ADDRESS_DEST_VAL");
     701          PORT_MAP(_component,src ,"out_BRANCH_EVENT_"+toString(i)+"_ADDRESS_DEST"    ,dest,"out_BRANCH_EVENT_"+toString(i)+"_ADDRESS_DEST"    );
     702        }
     703
     704      for (uint32_t i=0; i<_param->_nb_context; i++)
     705        {
     706          dest = _name;
     707
     708#ifdef POSITION
     709          _component->interface_map (src ,"event_"+toString(i),
     710                                     dest,"event_"+toString(i));
     711#endif
     712
     713          PORT_MAP(_component,src , "in_EVENT_"+toString(i)+"_STATE",dest, "in_EVENT_"+toString(i)+"_STATE");
     714          PORT_MAP(_component,src , "in_EVENT_"+toString(i)+"_TYPE" ,dest, "in_EVENT_"+toString(i)+"_TYPE" );
     715          if (_param->_have_port_depth)
     716          PORT_MAP(_component,src , "in_EVENT_"+toString(i)+"_DEPTH",dest, "in_EVENT_"+toString(i)+"_DEPTH");
     717        }
    689718
    690719      for (uint32_t i=0; i<_param->_nb_context; i++)

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/src/Prediction_unit_deallocation.cpp

    r88 r95  
    6262        DELETE1_SIGNAL(out_BRANCH_COMPLETE_ADDRESS_DEST   ,_param->_nb_inst_branch_complete,_param->_size_instruction_address);
    6363
    64         DELETE1_SIGNAL(out_BRANCH_EVENT_VAL            ,_param->_nb_context,1);
    65         DELETE1_SIGNAL( in_BRANCH_EVENT_ACK            ,_param->_nb_context,1);
    66 //      DELETE1_SIGNAL(out_BRANCH_EVENT_CONTEXT_ID     ,_param->_nb_context,_param->_size_context_id);
    67 //      DELETE1_SIGNAL(out_BRANCH_EVENT_DEPTH          ,_param->_nb_context,_param->_size_depth);
    68 //      DELETE1_SIGNAL(out_BRANCH_EVENT_MISS_PREDICTION,_param->_nb_context,1);
    69         DELETE1_SIGNAL(out_BRANCH_EVENT_ADDRESS_SRC    ,_param->_nb_context,_param->_size_instruction_address);
    70         DELETE1_SIGNAL(out_BRANCH_EVENT_ADDRESS_DEST   ,_param->_nb_context,_param->_size_instruction_address);
     64        DELETE1_SIGNAL(out_BRANCH_EVENT_VAL              ,_param->_nb_context,1);
     65        DELETE1_SIGNAL( in_BRANCH_EVENT_ACK              ,_param->_nb_context,1);
     66//      DELETE1_SIGNAL(out_BRANCH_EVENT_CONTEXT_ID       ,_param->_nb_context,_param->_size_context_id);
     67//      DELETE1_SIGNAL(out_BRANCH_EVENT_DEPTH            ,_param->_nb_context,_param->_size_depth);
     68//      DELETE1_SIGNAL(out_BRANCH_EVENT_MISS_PREDICTION  ,_param->_nb_context,1);
     69        DELETE1_SIGNAL(out_BRANCH_EVENT_ADDRESS_SRC      ,_param->_nb_context,_param->_size_instruction_address);
     70        DELETE1_SIGNAL(out_BRANCH_EVENT_ADDRESS_DEST_VAL ,_param->_nb_context,1);
     71        DELETE1_SIGNAL(out_BRANCH_EVENT_ADDRESS_DEST     ,_param->_nb_context,_param->_size_instruction_address);
     72
     73        DELETE1_SIGNAL( in_EVENT_STATE  ,_param->_nb_context,_param->_size_event_state);
     74        DELETE1_SIGNAL( in_EVENT_TYPE   ,_param->_nb_context,_param->_size_event_type );
     75        DELETE1_SIGNAL( in_EVENT_DEPTH  ,_param->_nb_context,_param->_size_depth      );
    7176
    7277        DELETE1_SIGNAL(out_DEPTH_CURRENT      ,_param->_nb_context,_param->_size_depth);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/SelfTest/config-context_1-decod_unit_1-a.cfg

    r88 r95  
    43438       8       +1      # ras_size_queue                [0] [nb_context]               
    44441       1       +1      # upt_size_queue                [0] [nb_context]               
     451       1       +1      # ufpt_size_queue               [0] [nb_context]               
    45461       1       +1      # size_inst_commit

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/SelfTest/config-context_4-decod_unit_1-a.cfg

    r88 r95  
    58582       2       +1      # upt_size_queue                [2] [nb_context]               
    59598       8       +1      # upt_size_queue                [3] [nb_context]               
     606       6       +1      # ufpt_size_queue               [0] [nb_context]               
     611       1       +1      # ufpt_size_queue               [1] [nb_context]               
     621       1       +1      # ufpt_size_queue               [2] [nb_context]               
     634       4       +1      # ufpt_size_queue               [3] [nb_context]               
    60641       1       +1      # size_inst_commit

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/SelfTest/config-context_4-decod_unit_2-a.cfg

    r88 r95  
    63632       2       +1      # upt_size_queue                [2] [nb_context]               
    64648       8       +1      # upt_size_queue                [3] [nb_context]               
     656       6       +1      # ufpt_size_queue               [0] [nb_context]               
     661       1       +1      # ufpt_size_queue               [1] [nb_context]               
     671       1       +1      # ufpt_size_queue               [2] [nb_context]               
     684       4       +1      # ufpt_size_queue               [3] [nb_context]               
    65691       1       +1      # size_inst_commit

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/SelfTest/config-context_4-decod_unit_2-b.cfg

    r88 r95  
    63632       2       +1      # upt_size_queue                [2] [nb_context]               
    64648       8       +1      # upt_size_queue                [3] [nb_context]               
     656       6       +1      # ufpt_size_queue               [0] [nb_context]               
     661       1       +1      # ufpt_size_queue               [1] [nb_context]               
     671       1       +1      # ufpt_size_queue               [2] [nb_context]               
     684       4       +1      # ufpt_size_queue               [3] [nb_context]               
    65691       1       +1      # size_inst_commit

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/SelfTest/config-min.cfg

    r88 r95  
    43432       2       +1      # ras_size_queue                [0] [nb_context]               
    44441       1       +1      # upt_size_queue                [0] [nb_context]               
     451       1       +1      # ufpt_size_queue               [0] [nb_context]               
    45461       1       +1      # size_inst_commit

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/SelfTest/src/main.cpp

    r88 r95  
    4444  err (_(" * ras_size_queue                [nb_context]                 (uint32_t         )\n"));
    4545  err (_(" * upt_size_queue                [nb_context]                 (uint32_t         )\n"));
     46  err (_(" * ufpt_size_queue               [nb_context]                 (uint32_t         )\n"));
    4647  err (_(" * size_inst_commit                                           (uint32_t         )\n"));
    4748
    … …  
    6970  uint32_t             _nb_decod_unit                     = fromString<uint32_t         >(argv[x++]);
    7071
    71   if (argc != static_cast<int>(2+NB_PARAMS+5*_nb_context+5*_nb_decod_unit))
     72  if (argc != static_cast<int>(2+NB_PARAMS+6*_nb_context+5*_nb_decod_unit))
    7273    {
    7374      msg("argc                : %d\n",argc);
    … …  
    158159  for (uint32_t i=0; i<_nb_context; ++i)
    159160    _upt_size_queue [i] = fromString<uint32_t>(argv[x++]);
     161
     162  uint32_t           * _ufpt_size_queue                   = new uint32_t [_nb_context];
     163  for (uint32_t i=0; i<_nb_context; ++i)
     164    _ufpt_size_queue [i] = fromString<uint32_t>(argv[x++]);
    160165
    161166  uint32_t             _size_inst_commit                  = fromString<uint32_t>(argv[x++]);
    … …  
    197202         _ras_size_queue                      ,
    198203         _upt_size_queue                      ,
     204         _ufpt_size_queue                     ,
    199205         _size_inst_commit                    ,
    200206         true // is_toplevel
    … …  
    231237  delete [] _dir_pht_nb_counter                  ;
    232238  delete [] _dir_pht_size_address_share          ;
     239  delete [] _ufpt_size_queue                   ;
    233240  delete [] _upt_size_queue                    ;
    234241  delete [] _ras_size_queue                    ;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/include/Parameters.h

    r88 r95  
    6565  public : uint32_t              * _ras_size_queue                       ;//[nb_context]
    6666  public : uint32_t              * _upt_size_queue                       ;//[nb_context]
     67  public : uint32_t              * _ufpt_size_queue                      ;//[nb_context]
     68
    6769    // context_state                                                     
    6870//public : uint32_t                _size_nb_inst_commit                  ;
    … …  
    132134                        uint32_t              * ras_size_queue                      ,
    133135                        uint32_t              * upt_size_queue                      ,
     136                        uint32_t              * ufpt_size_queue                     ,
    134137                        // context_state                                           
    135138                        uint32_t                size_nb_inst_commit                 ,

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/src/Front_end_allocation.cpp

    r88 r95  
    564564#endif
    565565
    566           COMPONENT_MAP(_component,src ,"out_BRANCH_EVENT_"+toString(i)+"_VAL"            ,
    567                                    dest, "in_BRANCH_EVENT_"+toString(i)+"_VAL"            );
    568           COMPONENT_MAP(_component,src , "in_BRANCH_EVENT_"+toString(i)+"_ACK"            ,
    569                                    dest,"out_BRANCH_EVENT_"+toString(i)+"_ACK"            );
    570 //        COMPONENT_MAP(_component,src ,"out_BRANCH_EVENT_"+toString(i)+"_CONTEXT_ID"     ,
    571 //                                 dest, "in_BRANCH_EVENT_"+toString(i)+"_CONTEXT_ID"     );
    572 //        COMPONENT_MAP(_component,src ,"out_BRANCH_EVENT_"+toString(i)+"_DEPTH"          ,
    573 //                                 dest, "in_BRANCH_EVENT_"+toString(i)+"_DEPTH"          );
    574 //        COMPONENT_MAP(_component,src ,"out_BRANCH_EVENT_"+toString(i)+"_MISS_PREDICTION",
    575 //                                 dest, "in_BRANCH_EVENT_"+toString(i)+"_MISS_PREDICTION");
    576           COMPONENT_MAP(_component,src ,"out_BRANCH_EVENT_"+toString(i)+"_ADDRESS_SRC"    ,
    577                                    dest, "in_BRANCH_EVENT_"+toString(i)+"_ADDRESS_SRC"    );
    578           COMPONENT_MAP(_component,src ,"out_BRANCH_EVENT_"+toString(i)+"_ADDRESS_DEST"   ,
    579                                    dest, "in_BRANCH_EVENT_"+toString(i)+"_ADDRESS_DEST"   );
     566          COMPONENT_MAP(_component,src ,"out_BRANCH_EVENT_"+toString(i)+"_VAL"             ,
     567                                   dest, "in_BRANCH_EVENT_"+toString(i)+"_VAL"             );
     568          COMPONENT_MAP(_component,src , "in_BRANCH_EVENT_"+toString(i)+"_ACK"             ,
     569                                   dest,"out_BRANCH_EVENT_"+toString(i)+"_ACK"             );
     570//        COMPONENT_MAP(_component,src ,"out_BRANCH_EVENT_"+toString(i)+"_CONTEXT_ID"      ,
     571//                                 dest, "in_BRANCH_EVENT_"+toString(i)+"_CONTEXT_ID"      );
     572//        COMPONENT_MAP(_component,src ,"out_BRANCH_EVENT_"+toString(i)+"_DEPTH"           ,
     573//                                 dest, "in_BRANCH_EVENT_"+toString(i)+"_DEPTH"           );
     574//        COMPONENT_MAP(_component,src ,"out_BRANCH_EVENT_"+toString(i)+"_MISS_PREDICTION" ,
     575//                                 dest, "in_BRANCH_EVENT_"+toString(i)+"_MISS_PREDICTION" );
     576          COMPONENT_MAP(_component,src ,"out_BRANCH_EVENT_"+toString(i)+"_ADDRESS_SRC"     ,
     577                                   dest, "in_BRANCH_EVENT_"+toString(i)+"_ADDRESS_SRC"     );
     578          COMPONENT_MAP(_component,src ,"out_BRANCH_EVENT_"+toString(i)+"_ADDRESS_DEST_VAL",
     579                                   dest, "in_BRANCH_EVENT_"+toString(i)+"_ADDRESS_DEST_VAL");
     580          COMPONENT_MAP(_component,src ,"out_BRANCH_EVENT_"+toString(i)+"_ADDRESS_DEST"    ,
     581                                   dest, "in_BRANCH_EVENT_"+toString(i)+"_ADDRESS_DEST"    );
    580582        }
    581583

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/src/Parameters.cpp

    r88 r95  
    5252                          uint32_t              * ras_size_queue                      ,
    5353                          uint32_t              * upt_size_queue                      ,
     54                          uint32_t              * ufpt_size_queue                     ,
    5455                          // context_state                                           
    5556                          uint32_t                size_nb_inst_commit                 ,
    … …  
    9394    _ras_size_queue                      = ras_size_queue                      ;
    9495    _upt_size_queue                      = upt_size_queue                      ;
     96    _ufpt_size_queue                     = ufpt_size_queue                     ;
    9597
    9698    test();
    … …  
    114116           _nb_inst_fetch     [i]        ,
    115117           log2(_upt_size_queue[i])      ,
    116            size_instruction_address                 );
     118           size_instruction_address      );
    117119      }
    118120
    … …  
    140142       _dir_pht_size_address_share    ,
    141143       _ras_size_queue                ,
    142        _upt_size_queue                );
     144       _upt_size_queue                ,
     145       _ufpt_size_queue               );
    143146
    144147    _translate_context_id_from_decod_unit= new std::vector<uint32_t> [_nb_decod_unit];
Note: See TracChangeset for help on using the changeset viewer.