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
Files:
64 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];

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Victim/Victim_Pseudo_LRU/SelfTest/include/test.h

    r81 r95  
    1414
    1515#include "Behavioural/Generic/Victim/Victim_Pseudo_LRU/include/Victim_Pseudo_LRU.h"
     16#include "Common/include/Time.h"
    1617
    1718using namespace std;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Victim/Victim_Pseudo_LRU/SelfTest/src/test.cpp

    r88 r95  
    8989        (*(_Victim_Pseudo_LRU->out_ACCESS_VICTIM  [i])) (ACCESS_VICTIM  [i]);
    9090      }
     91
     92  Time * _time = new Time();
    9193
    9294  /********************************************************
    … …  
    210212
    211213  cout << "<" << name << "> ............ Stop Simulation" << endl;
     214  delete _time;
    212215
    213216#endif

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Victim/Victim_Pseudo_LRU/src/Victim_Pseudo_LRU_allocation.cpp

    r88 r95  
    3636                                                              );
    3737     
    38       in_CLOCK        = interface->set_signal_clk              ("clock" ,1);
    39       in_NRESET       = interface->set_signal_in  <Tcontrol_t> ("nreset",1);
     38      in_CLOCK        = interface->set_signal_clk              ("clock" ,1, CLOCK_VHDL_YES);
     39      in_NRESET       = interface->set_signal_in  <Tcontrol_t> ("nreset",1, RESET_VHDL_YES);
    4040    }
    4141

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Victim/Victim_Pseudo_LRU/src/Victim_Pseudo_LRU_vhdl_body.cpp

    r81 r95  
    116116        }
    117117
    118     vhdl->set_body ("");
    119     vhdl->set_body ("-- port update");
    120     for (uint32_t i=0; i<_param->_nb_update; i++)
    121       for (int32_t j=static_cast<uint32_t>(log2(_param->_nb_entity)-1); j>=0; j--)
    122         {
    123           uint32_t cpt=0;
     118//     vhdl->set_body ("");
     119//     vhdl->set_body ("-- port update");
     120//     for (uint32_t i=0; i<_param->_nb_update; i++)
     121//       for (int32_t j=static_cast<uint32_t>(log2(_param->_nb_entity)-1); j>=0; j--)
     122//      {
     123//        uint32_t cpt=0;
    124124         
    125           for (int32_t k=(1<<j)-1; k<static_cast<int32_t>(_param->_nb_entity-1); k+=(1<<(j+1)))
    126             {
    127               bool   have_cond = false;
    128               std::string cond      = "";
    129              
    130               // condition to change the bit
    131               for (uint32_t l=j+1; l<static_cast<uint32_t>(log2(_param->_nb_entity));l++)
    132                 {
    133                   have_cond = true;
    134 
    135                   if (l==static_cast<uint32_t>(j+1))
    136                     cond += "when";
    137                   else
    138                     cond += " and";
    139                   cond += " in_UPDATE_"+toString(i)+"_ENTITY("+toString(l)+")='"+toString((cpt>>(l-(j+1)))&1)+"'";
    140                 }
    141              
    142               vhdl->set_body ("update_next_entry_"+toString(i)+"("+toString(k)+") <=");
    143               vhdl->set_body ("\tnot in_UPDATE_"+toString(i)+"_ENTITY("+toString(j)+") "+cond);
    144               if (have_cond == true)
    145                 {
    146                   std::string update_address;
    147 
    148                   if (_param->_size_table>1)
    149                     update_address = "conv_integer(in_UPDATE_"+toString(i)+"_ADDRESS)";
    150                   else
    151                     update_address = "0";
     125//        for (int32_t k=(1<<j)-1; k<static_cast<int32_t>(_param->_nb_entity-1); k+=(1<<(j+1)))
     126//          {
     127//            bool   have_cond = false;
     128//            std::string cond      = "";
     129             
     130//            // condition to change the bit
     131//            for (uint32_t l=j+1; l<static_cast<uint32_t>(log2(_param->_nb_entity));l++)
     132//              {
     133//                have_cond = true;
     134
     135//                if (l==static_cast<uint32_t>(j+1))
     136//                  cond += "when";
     137//                else
     138//                  cond += " and";
     139//                cond += " in_UPDATE_"+toString(i)+"_ENTITY("+toString(l)+")='"+toString((cpt>>(l-(j+1)))&1)+"'";
     140//              }
     141             
     142//            vhdl->set_body ("update_next_entry_"+toString(i)+"("+toString(k)+") <=");
     143//            vhdl->set_body ("\tnot in_UPDATE_"+toString(i)+"_ENTITY("+toString(j)+") "+cond);
     144//            if (have_cond == true)
     145//              {
     146//                std::string update_address;
     147
     148//                if (_param->_size_table>1)
     149//                  update_address = "conv_integer(in_UPDATE_"+toString(i)+"_ADDRESS)";
     150//                else
     151//                  update_address = "0";
    152152                 
    153                   vhdl->set_body ("\telse reg_TABLE ("+update_address+")("+toString(k)+")");
    154                 }
    155               vhdl->set_body ("\t;");         
    156               cpt ++;
    157             }
    158         }
     153//                vhdl->set_body ("\telse reg_TABLE ("+update_address+")("+toString(k)+")");
     154//              }
     155//            vhdl->set_body ("\t;");         
     156//            cpt ++;
     157//          }
     158//      }
    159159
    160160    vhdl->set_body ("");
    … …  
    182182      }
    183183
    184     vhdl->set_body ("\t\t-- Update port");
    185     for (uint32_t i=0; i<_param->_nb_update; i++)
    186       {
    187         std::string update_address;
    188 
    189         if (_param->_size_table>1)
    190           update_address = "conv_integer(in_UPDATE_"+toString(i)+"_ADDRESS)";
    191         else
    192           update_address = "0";
     184//     vhdl->set_body ("\t\t-- Update port");
     185//     for (uint32_t i=0; i<_param->_nb_update; i++)
     186//       {
     187//      std::string update_address;
     188
     189//      if (_param->_size_table>1)
     190//        update_address = "conv_integer(in_UPDATE_"+toString(i)+"_ADDRESS)";
     191//      else
     192//        update_address = "0";
    193193                 
    194         vhdl->set_body ("\t\tif (in_UPDATE_"+toString(i)+"_VAL = '1') then");
    195         vhdl->set_body ("\t\t\treg_TABLE ("+update_address+") <= update_next_entry_"+toString(i)+";");
    196         vhdl->set_body ("\t\tend if;");
    197       }
     194//      vhdl->set_body ("\t\tif (in_UPDATE_"+toString(i)+"_VAL = '1') then");
     195//      vhdl->set_body ("\t\t\treg_TABLE ("+update_address+") <= update_next_entry_"+toString(i)+";");
     196//      vhdl->set_body ("\t\tend if;");
     197//       }
    198198
    199199    vhdl->set_body ("\tend if;");
    … …  
    210210      {
    211211        vhdl->set_body ("out_ACCESS_"+toString(i)+"_ACK    <= '1';");
    212         vhdl->set_body ("out_ACCESS_"+toString(i)+"_ENTITY <= access_entity_"+toString(i)+" when in_ACCESS_"+toString(i)+"_VAL = '1' else (others => '0');");
     212        vhdl->set_body ("out_ACCESS_"+toString(i)+"_VICTIM <= access_entity_"+toString(i)+" when in_ACCESS_"+toString(i)+"_VAL = '1' else (others => '0');");
    213213      }
    214214    vhdl->set_body ("");
    215     for (uint32_t i=0; i<_param->_nb_update; i++)
    216       {
    217         vhdl->set_body ("out_UPDATE_"+toString(i)+"_ACK    <= '1';");
    218       }
     215//     for (uint32_t i=0; i<_param->_nb_update; i++)
     216//       {
     217//      vhdl->set_body ("out_UPDATE_"+toString(i)+"_ACK    <= '1';");
     218//       }
    219219  };
    220220

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Victim/Victim_Pseudo_LRU/src/Victim_Pseudo_LRU_vhdl_declaration.cpp

    r81 r95  
    2929      }
    3030
    31     for (uint32_t i=0; i<_param->_nb_update; i++)
    32       {
    33         vhdl->set_signal ("update_next_entry_"+toString(i)+"",std_logic(_param->_nb_entity-1));
    34       }
     31//     for (uint32_t i=0; i<_param->_nb_update; i++)
     32//       {
     33//      vhdl->set_signal ("update_next_entry_"+toString(i)+"",std_logic(_param->_nb_entity-1));
     34//       }
    3535  };
    3636

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/include/Version.h

    r94 r95  
    1010#define MORPHEO_MAJOR_VERSION 0
    1111#define MORPHEO_MINOR_VERSION 2
    12 #define MORPHEO_REVISION      "94"
     12#define MORPHEO_REVISION      "95"
    1313#define MORPHEO_CODENAME      "Castor"
    1414
    15 #define MORPHEO_DATE_DAY      "15" 
     15#define MORPHEO_DATE_DAY      "16" 
    1616#define MORPHEO_DATE_MONTH    "12"
    1717#define MORPHEO_DATE_YEAR     "2008"

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/include/Vhdl.h

    r94 r95  
    2626    std::string std_logic_conv     (uint32_t size, std::string   value);
    2727    std::string std_logic_conv     (uint32_t size, uint32_t value);
     28    std::string std_logic_cst      (uint32_t size, uint32_t value);
    2829    std::string std_logic_range    (uint32_t size, uint32_t max , uint32_t min , bool force=false);
    2930    std::string std_logic_range    (               uint32_t max , uint32_t min , bool force=false);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Component_vhdl_instance.cpp

    r81 r95  
    2727      std::list<Interface_fifo *>         * list_interface = (_entity)->get_interfaces_list()->get_interface_list();
    2828      std::list<Interface_fifo *>::iterator j              = list_interface->begin();
     29      bool print_comment = false;
    2930      if (not list_interface->empty())
    3031        {
    31           vhdl->set_body ("------------------------------------------------------");
    32           vhdl->set_body ("-- Output's Buffer");
    33           vhdl->set_body ("------------------------------------------------------");
    34          
    3532          while (j != list_interface->end())
    3633            {
    … …  
    4845                           (signal->get_connect_from_signal () != NULL) )
    4946                        {
     47                          if (not print_comment)
     48                            {
     49                              vhdl->set_body ("------------------------------------------------------");
     50                              vhdl->set_body ("-- Output's Buffer");
     51                              vhdl->set_body ("------------------------------------------------------");
     52                             
     53                              print_comment = true;
     54                            }
     55
    5056                          // Create name
    5157                          std::string signal_name = "signal_"+toString(cpt++);
    … …  
    6773              ++j;
    6874            }
    69           vhdl->set_body ("");
    70           vhdl->set_body ("------------------------------------------------------");
    71           vhdl->set_body ("");
     75
     76          if (print_comment)
     77            {
     78              vhdl->set_body ("");
     79              vhdl->set_body ("------------------------------------------------------");
     80              vhdl->set_body ("");
     81            }
    7282        }
    7383    }

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interface_testbench_test.cpp

    r81 r95  
    2424
    2525    std::string test_name    = testbench_test_name(vhdl);
    26     std::string test_name_ok = testbench_test_ok     (vhdl);
     26    std::string test_name_ok = testbench_test_ok  (vhdl);
    2727
    2828    vhdl->set_body(test_name + " <= '1' when ("+reset_name+" = '0') else "+test_name_ok+";");

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interface_testbench_test_ok.cpp

    r81 r95  
    2424    if (_list_signal->empty()== false)
    2525      {
    26         std::list<Signal*>::iterator i     = _list_signal->begin();
     26        std::list<Signal*>::iterator i = _list_signal->begin();
    2727
    2828        while (i != _list_signal->end())

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Signal_testbench_test_ok.cpp

    r81 r95  
    1919    if (_direction == OUT)
    2020      vhdl->set_body ("\tand "+_name+" = "+_name+"_test");
    21 
     21   
    2222    log_printf(FUNC,Behavioural,"testbench_test_ok","End");
    2323  };

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_set_constant.cpp

    r81 r95  
    2727
    2828  void Vhdl::set_constant (std::string      name     ,
    29                            uint32_t    size     ,
     29                           uint32_t         size     ,
    3030                           std::string      init)
    3131  {
    … …  
    3535  };
    3636
    37   void Vhdl::set_constant (std::string      name     ,
     37  void Vhdl::set_constant (std::string name     ,
    3838                           uint32_t    size     ,
    3939                           uint32_t    init)
    4040  {
    4141    log_printf(FUNC,Behavioural,FUNCTION,"Begin");
    42     set_constant(name,std_logic(size),std_logic_conv(size,init));
     42    set_constant(name,std_logic(size),std_logic_cst(size,init));
    4343    log_printf(FUNC,Behavioural,FUNCTION,"End");
    4444  };

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_set_signal.cpp

    r93 r95  
    99
    1010#include "Behavioural/include/Vhdl.h"
    11 
     11#include "Common/include/ToBase2.h"
    1212#include <sstream>
    1313
    … …  
    5656  {
    5757    log_printf(FUNC,Behavioural,FUNCTION,"Begin");
    58     set_signal(name,std_logic(size),std_logic_conv(size,init));
     58    set_signal(name,std_logic(size),std_logic_cst(size,init));
    5959    log_printf(FUNC,Behavioural,FUNCTION,"End");
    6060  };

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_std_logic.cpp

    r94 r95  
    1010#include <math.h>
    1111#include "Behavioural/include/Vhdl.h"
     12#include "Common/include/ToBase2.h"
    1213
    1314namespace morpheo              {
    … …  
    5758
    5859    return _return;
     60  };
     61
     62#undef  FUNCTION
     63#define FUNCTION "Vhdl::std_logic_cst"
     64  std::string std_logic_cst (uint32_t size, uint32_t value)
     65  {
     66    log_printf(FUNC,Behavioural,FUNCTION,"Begin");
     67
     68    std::string conv;
     69
     70    if (size == 1)
     71      conv = "'"+toString(value&1)+"'";
     72    else
     73      conv = "\""+toBase2<uint32_t>(value,size)+"\"";
     74
     75    log_printf(FUNC,Behavioural,FUNCTION,"End");
     76
     77    return conv;
    5978  };
    6079

  • trunk/IPs/systemC/processor/Morpheo/Documentation/doc/document-morpheo-vhdl_generation/tex/document-morpheo-vhdl_generation-fr.tex

    r94 r95  
    66
    77Ce document est une aide pour les développeur des générateurs de modèles VHDL de \cpu.
    8 Il est décomposé en 5 sections :
     8Il est décomposé en 6 sections :
    99\begin{itemize}
    1010\item Dans la section \ref{tree}, nous présentons l'arborescence des répertoires.
    … …  
    1313\item Dans la section \ref{vhdl_structural}, nous expliquerons la manière de créer des sous composants.
    1414\item Dans la section \ref{example}, nous montrerons quelques exemples.
     15\item Dans la section \ref{testbench}, nous présenterons la méthodologie de test.
    1516\end{itemize}
    1617
    … …  
    363364
    364365\end{verbatim}
     366
     367\Section {Test du VHDL}\label{testbench}
     368
     369Lors d'une simulation systemC, \cpu va générer des fichiers de tests pour le modèle VHDL de chaque composant interne.
     370Ces tests sont tous écrit de la même façon. Soit l'interface X et le signal Y :
     371\begin{itemize}
     372\item Une variable {\it counter} indique le numéro de cycle courant. Elle est initialisé à 0. Elle est incrémenté à chaque cycle.
     373\item Le composant est instancé avec des signaux internes de même nom.
     374\item Pour chaque cycle, on affecte à chaque entrée la valeur obtenu lors de la simulation systemC.
     375\item Pour chaque sortie, on définit un signal dont le nom est {\it out\_X\_Y\_test}. Ces signaux sont affecté au valeur obtenu des sorties lors la simulation systemC.
     376\item Le signal {\it interface\_X\_test\_ok} est égal à 1 si chaque sortie calculé par la simulation VHDL est égal au sortie attendu (calculé par la simulation systemC).
     377\item Le signal {\it interface\_X\_test\_transaction} est à 1 si tous les signaux de validité et d'aquittement sont à 1.
     378\item Le signal {\it interface\_X\_test\_tmp} est à 1 si la simulation systemC indique qu'il y a une transaction et que la simulation vhdl indique également une transaction et que toute les sortie sont bien les sorties obtenu. Si la simulation systemC n'indique pas de transaction, on vérifie que c'est également le cas pour la simulation VHDL.
     379\item Le signal {\it interface\_X\_test} est égal au signal {\it interface\_X\_test\_tmp} quand il n'y a pas de reset. sinon il est positionné à 1.
     380\item Le signal {\it test} est un et logique entre tout tous les signaux {\it interface\_X\_test}.
     381\item La simulation VHDL ce termine si le signal {\it test} vaut 0 (dans ce cas, le test est un échec), ou que le registre {\it counter} vaut le nombre de cycle requis par la simulation systemC (dans ce cas, le test est un succès).
     382\end{itemize}
     383
     384Nous pouvons remarquer que :
     385\begin{itemize}
     386\item Nous vérifions la compatibilité au cycle des transactions entre le modèle systemC et le modèle VHDL.
     387\item Nous vérifions la compatibilité au bit près des données échangé lors qu'il y a une transaction sur une interface.
     388\item Nous ne vérifions pas la compatibilité au bit près des données présente sur une interface qui ne fait pas de transaction lors d'un cycle.
     389\end{itemize}

  • trunk/IPs/systemC/processor/Morpheo/Files/Instance_min.cfg

    r88 r95  
    77    <parameter name="nb_inst_fetch"                         value="1" />
    88    <parameter name="ras_size_queue"                        value="2" />
    9     <parameter name="upt_size_queue"                        value="2" />
     9    <parameter name="upt_size_queue"                        value="1" />
     10    <parameter name="ufpt_size_queue"                       value="1" />
    1011
    1112    <group id="0">

  • trunk/IPs/systemC/processor/Morpheo/Files/Instance_scalar_1.cfg

    r88 r95  
    88    <parameter name="ras_size_queue"                        value="2" />
    99    <parameter name="upt_size_queue"                        value="2" />
     10    <parameter name="ufpt_size_queue"                       value="2" />
    1011
    1112    <group id="0">

  • trunk/IPs/systemC/processor/Morpheo/Files/Instance_scalar_2.cfg

    r88 r95  
    88    <parameter name="ras_size_queue"                        value="8" />
    99    <parameter name="upt_size_queue"                        value="4" />
     10    <parameter name="ufpt_size_queue"                       value="2" />
    1011
    1112    <group id="0">

  • trunk/IPs/systemC/processor/Morpheo/Files/Morpheo.sim

    r88 r95  
    2323  <parameter name="directory_log"              value="/tmp/Morpheo/" />
    2424
     25  <parameter name="debug"                      value="0" />
     26
    2527</parameters>
Note: See TracChangeset for help on using the changeset viewer.