Ignore:
Timestamp:
Mar 27, 2008, 11:04:49 AM (16 years ago)
Author:
rosiere
Message:

Add :

  • Execute_loop (must be test systemC)
  • Prediction
    • Direction : predifined scheme
    • Branch Target Buffer
  • iFetch_unit
    • ifetch_queue
    • pc management
  • Decod_unit
    • coming soon : support for custom operation
  • Rename_unit
    • RAT
    • Free_list
    • Dependence RAW check
    • Load store unit pointer
  • New Environnement (hierarchy_memory will remove in a next version)


Modif :

  • Manage Custom Operation
  • All component in execute_loop to use the new statistics management

Not Finish :

  • Return Address Stack
  • Environnement
Location:
trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit
Files:
6 added
26 edited
3 moved

Legend:

Unmodified
Added
Removed

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/Makefile.deps

    r72 r78  
    2020Functionnal_unit_LIBRARY        =       -lFunctionnal_unit      \
    2121                                        $(Custom_LIBRARY)       \
     22                                        -lFunctionnal_unit      \
    2223                                        $(Behavioural_LIBRARY) 
    2324

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/Operation/include/Operation.h

    r72 r78  
    1313#include "Common/include/ErrorMorpheo.h"
    1414#include "Behavioural/include/Types.h"
    15 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/include/Types.h"
     15#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/Operation/include/Types.h"
    1616
    1717namespace morpheo {

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/Operation/include/Types.h

    r76 r78  
    148148  };
    149149 
    150   typedef void function_execute_t (morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::functionnal_unit::execute_operation_t *,
    151                                    morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::functionnal_unit::execute_register_t  *,
    152                                    morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::functionnal_unit::execute_param_t     *);
    153 
    154   typedef void function_execute_end_cycle_t (morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::functionnal_unit::execute_register_t  *,
    155                                              morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::functionnal_unit::execute_param_t     *);
     150  typedef void function_execute_t
     151  (morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::functionnal_unit::execute_operation_t *,
     152   morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::functionnal_unit::execute_register_t  *,
     153   morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::functionnal_unit::execute_param_t     *);
     154 
     155  typedef void function_execute_end_cycle_t
     156  (morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::functionnal_unit::execute_register_t  *,
     157   morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::functionnal_unit::execute_param_t     *);
    156158
    157159 

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/Operation/src/Operation.cpp

    r76 r78  
    77 */
    88
    9 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/include/Operation.h"
     9#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/Operation/include/Operation.h"
    1010
    1111#define neg(data)                  (~(data)+1)

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/SelfTest/configuration.cfg

    r77 r78  
    882       2       +1      # size_special_data 
    9916      16      +1      # nb_special_register
     104       4       *2      # size_store_queue
     111       4       *4      # size_load_queue

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/SelfTest/src/main.cpp

    r77 r78  
    99#include "Behavioural/Custom/include/Custom_example.h"
    1010
    11 #define NB_PARAMS 8
     11#define NB_PARAMS 10
    1212
    1313void usage (int argc, char * argv[])
    … …  
    2323  err (_("  * size_special_data   (uint32_t)\n"));
    2424  err (_("  * nb_special_register (uint32_t)\n"));
     25  err (_("  * size_store_queue    (uint32_t)\n"));
     26  err (_("  * size_load_queue     (uint32_t)\n"));
    2527  exit (1);
    2628}
    … …  
    4648  const uint32_t size_special_data   = atoi(argv[x++]);
    4749  const uint32_t nb_special_register = atoi(argv[x++]);
     50  const uint32_t size_store_queue    = atoi(argv[x++]);
     51  const uint32_t size_load_queue     = atoi(argv[x++]);
    4852
    4953  execute_timing_t ** timing = new execute_timing_t * [MAX_TYPE];
    … …  
    6872         size_special_data   ,
    6973         nb_special_register ,
     74         size_store_queue    ,
     75         size_load_queue     ,
    7076         timing              ,
    7177         &(morpheo::behavioural::custom::example_get_custom_information)

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/SelfTest/src/test.cpp

    r76 r78  
    142142  sc_signal<Toperation_t      >  in_EXECUTE_IN_OPERATION      (rename.c_str());
    143143  sc_signal<Ttype_t           >  in_EXECUTE_IN_TYPE           (rename.c_str());
     144  sc_signal<Tlsq_ptr_t        >  in_EXECUTE_IN_STORE_QUEUE_PTR_WRITE (rename.c_str());
     145  sc_signal<Tlsq_ptr_t        >  in_EXECUTE_IN_LOAD_QUEUE_PTR_WRITE  (rename.c_str());
    144146  sc_signal<Tcontrol_t        >  in_EXECUTE_IN_HAS_IMMEDIAT   (rename.c_str());
    145147  sc_signal<Tgeneral_data_t   >  in_EXECUTE_IN_IMMEDIAT       (rename.c_str());
    … …  
    160162  sc_signal<Tpacket_t         > out_EXECUTE_OUT_PACKET_ID      (rename.c_str());
    161163//sc_signal<Toperation_t      > out_EXECUTE_OUT_OPERATION      (rename.c_str());
    162 //sc_signal<Ttype_t           > out_EXECUTE_OUT_TYPE           (rename.c_str());
     164  sc_signal<Ttype_t           > out_EXECUTE_OUT_TYPE           (rename.c_str());
    163165  sc_signal<Tcontrol_t        > out_EXECUTE_OUT_WRITE_RD       (rename.c_str());
    164166  sc_signal<Tgeneral_address_t> out_EXECUTE_OUT_NUM_REG_RD     (rename.c_str());
    … …  
    191193  (*(_Functionnal_unit-> in_EXECUTE_IN_OPERATION     )) ( in_EXECUTE_IN_OPERATION     );
    192194  (*(_Functionnal_unit-> in_EXECUTE_IN_TYPE          )) ( in_EXECUTE_IN_TYPE          );
     195  (*(_Functionnal_unit-> in_EXECUTE_IN_STORE_QUEUE_PTR_WRITE)) ( in_EXECUTE_IN_STORE_QUEUE_PTR_WRITE);
     196  if (_param->_have_port_load_queue_ptr)
     197  (*(_Functionnal_unit-> in_EXECUTE_IN_LOAD_QUEUE_PTR_WRITE )) ( in_EXECUTE_IN_LOAD_QUEUE_PTR_WRITE );
    193198  (*(_Functionnal_unit-> in_EXECUTE_IN_HAS_IMMEDIAT  )) ( in_EXECUTE_IN_HAS_IMMEDIAT  );
    194199  (*(_Functionnal_unit-> in_EXECUTE_IN_IMMEDIAT      )) ( in_EXECUTE_IN_IMMEDIAT      );
    … …  
    212217  (*(_Functionnal_unit->out_EXECUTE_OUT_PACKET_ID    )) (out_EXECUTE_OUT_PACKET_ID    );
    213218//(*(_Functionnal_unit->out_EXECUTE_OUT_OPERATION    )) (out_EXECUTE_OUT_OPERATION    );
    214 //(*(_Functionnal_unit->out_EXECUTE_OUT_TYPE         )) (out_EXECUTE_OUT_TYPE         );
     219  (*(_Functionnal_unit->out_EXECUTE_OUT_TYPE         )) (out_EXECUTE_OUT_TYPE         );
    215220  (*(_Functionnal_unit->out_EXECUTE_OUT_WRITE_RD     )) (out_EXECUTE_OUT_WRITE_RD     );
    216221  (*(_Functionnal_unit->out_EXECUTE_OUT_NUM_REG_RD   )) (out_EXECUTE_OUT_NUM_REG_RD   );
    … …  
    616621              in_EXECUTE_IN_OPERATION     .write(transaction_in.front()._operation    );
    617622              in_EXECUTE_IN_TYPE          .write(transaction_in.front()._type         );
     623              in_EXECUTE_IN_STORE_QUEUE_PTR_WRITE.write(0);
     624              if (_param->_have_port_load_queue_ptr)
     625              in_EXECUTE_IN_LOAD_QUEUE_PTR_WRITE .write(0);
    618626              in_EXECUTE_IN_HAS_IMMEDIAT  .write(transaction_in.front()._has_immediat );
    619627              in_EXECUTE_IN_IMMEDIAT      .write(transaction_in.front()._immediat     );
    … …  
    641649              TEST(Tcontext_t        , out_EXECUTE_OUT_OOO_ENGINE_ID.read(), transaction_out.front()._ooo_engine_id);
    642650            //TEST(Toperation_t      , out_EXECUTE_OUT_OPERATION    .read(), transaction_out.front()._operation    );
    643             //TEST(Ttype_t           , out_EXECUTE_OUT_TYPE         .read(), transaction_out.front()._type         );
     651              TEST(Ttype_t           , out_EXECUTE_OUT_TYPE         .read(), transaction_out.front()._type         );
    644652              TEST(Tcontrol_t        , out_EXECUTE_OUT_WRITE_RE     .read(), transaction_out.front()._write_re     );
    645653              TEST(Tgeneral_address_t, out_EXECUTE_OUT_NUM_REG_RD   .read(), transaction_out.front()._num_reg_rd   );

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/include/Functionnal_unit.h

    r76 r78  
    1010 */
    1111
    12 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/include/Operation.h"
    13 
    1412#ifdef SYSTEMC
    1513#include "systemc.h"
    … …  
    2018#include "Common/include/Debug.h"
    2119#include "Behavioural/include/Types.h"
     20#include "Behavioural/include/Identification.h"
    2221
     22#include "Behavioural/include/Types.h"
    2323#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/include/Parameters.h"
    24 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/include/Types.h"
     24#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/Operation/include/Operation.h"
    2525#ifdef STATISTICS
    2626#include "Behavioural/include/Stat.h"
    … …  
    8686  public    : SC_IN (Toperation_t      )    *  in_EXECUTE_IN_OPERATION      ;
    8787  public    : SC_IN (Ttype_t           )    *  in_EXECUTE_IN_TYPE           ;
     88  public    : SC_IN (Tlsq_ptr_t        )    *  in_EXECUTE_IN_STORE_QUEUE_PTR_WRITE;
     89  public    : SC_IN (Tlsq_ptr_t        )    *  in_EXECUTE_IN_LOAD_QUEUE_PTR_WRITE;
    8890  public    : SC_IN (Tcontrol_t        )    *  in_EXECUTE_IN_HAS_IMMEDIAT   ;
    8991  public    : SC_IN (Tgeneral_data_t   )    *  in_EXECUTE_IN_IMMEDIAT       ;
    … …  
    104106  public    : SC_OUT(Tpacket_t         )    * out_EXECUTE_OUT_PACKET_ID      ;
    105107//public    : SC_OUT(Toperation_t      )    * out_EXECUTE_OUT_OPERATION      ;
    106 //public    : SC_OUT(Ttype_t           )    * out_EXECUTE_OUT_TYPE           ;
     108  public    : SC_OUT(Ttype_t           )    * out_EXECUTE_OUT_TYPE           ;
    107109  public    : SC_OUT(Tcontrol_t        )    * out_EXECUTE_OUT_WRITE_RD       ;
    108110  public    : SC_OUT(Tgeneral_address_t)    * out_EXECUTE_OUT_NUM_REG_RD     ;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/include/Parameters.h

    r77 r78  
    1111#include "Common/include/Debug.h"
    1212#include "Behavioural/include/Parameters.h"
    13 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/include/Types.h"
     13#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/Operation/include/Types.h"
    1414#include "Behavioural/Custom/include/Custom.h"
     15#include "Behavioural/Custom/include/Custom_default.h"
    1516#include <math.h>
    1617
    … …  
    3637  public : const uint32_t            _size_special_data            ;
    3738  public : const uint32_t            _nb_special_register          ;
     39  public : const uint32_t            _size_store_queue             ;
     40  public : const uint32_t            _size_load_queue              ;
     41
    3842  public :       execute_timing_t ** _timing                       ;
    3943  public : morpheo::behavioural::custom::custom_information_t (*_get_custom_information) (uint32_t);
    … …  
    5054  public : const bool                _have_port_ooo_engine_id      ;
    5155  public : const bool                _have_port_packet_id          ;
     56  public : const bool                _have_port_load_queue_ptr     ;
    5257
    5358  public : const bool                _have_groupe_MAC              ;
    … …  
    6267                        uint32_t           size_special_data  ,
    6368                        uint32_t           nb_special_register,
     69                        uint32_t           size_store_queue   ,
     70                        uint32_t           size_load_queue    ,
    6471                        execute_timing_t** timing             ,
    6572                        morpheo::behavioural::custom::custom_information_t (*get_custom_information) (uint32_t));
    … …  
    6774  public : ~Parameters () ;
    6875
    69   public :        std::string  msg_error  (void);
     76  public :        Parameters_test msg_error  (void);
    7077
    7178  public :        std::string   print      (uint32_t depth);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/src/Functionnal_unit_allocation.cpp

    r77 r78  
    7171       in_EXECUTE_IN_OPERATION     = interface->set_signal_in <Toperation_t      > ("operation"    , _param->_size_operation    );
    7272       in_EXECUTE_IN_TYPE          = interface->set_signal_in <Ttype_t           > ("type"         , _param->_size_type         );
     73       in_EXECUTE_IN_STORE_QUEUE_PTR_WRITE = interface->set_signal_in <Tlsq_ptr_t> ("store_queue_ptr_write",log2(_param->_size_store_queue));
     74       if (_param->_have_port_load_queue_ptr)
     75       in_EXECUTE_IN_LOAD_QUEUE_PTR_WRITE  = interface->set_signal_in <Tlsq_ptr_t> ("load_queue_ptr_write" ,log2(_param->_size_load_queue));
    7376       in_EXECUTE_IN_HAS_IMMEDIAT  = interface->set_signal_in <Tcontrol_t        > ("has_immediat" , 1);
    7477       in_EXECUTE_IN_IMMEDIAT      = interface->set_signal_in <Tgeneral_data_t   > ("immediat"     , _param->_size_general_data);
    … …  
    102105       out_EXECUTE_OUT_PACKET_ID      = interface->set_signal_out<Tpacket_t         > ("packet_id"    ,_param->_size_packet_id    );
    103106     //out_EXECUTE_OUT_OPERATION      = interface->set_signal_out<Toperation_t      > ("operation"    ,_param->_size_operation    );
    104      //out_EXECUTE_OUT_TYPE           = interface->set_signal_out<Ttype_t           > ("type"         ,_param->_size_type         );
     107       out_EXECUTE_OUT_TYPE           = interface->set_signal_out<Ttype_t           > ("type"         ,_param->_size_type         );
    105108       out_EXECUTE_OUT_WRITE_RD       = interface->set_signal_out<Tcontrol_t        > ("write_rd"     ,1);
    106109       out_EXECUTE_OUT_NUM_REG_RD     = interface->set_signal_out<Tgeneral_address_t> ("num_reg_rd"   ,_param->_size_general_register);
    … …  
    111114       out_EXECUTE_OUT_EXCEPTION      = interface->set_signal_out<Texception_t      > ("exception"    ,_param->_size_exception);
    112115       out_EXECUTE_OUT_NO_SEQUENCE    = interface->set_signal_out<Tcontrol_t        > ("no_sequence"  ,1);
    113        out_EXECUTE_OUT_ADDRESS        = interface->set_signal_out<Tgeneral_data_t   > ("address     " ,_param->_size_general_data);
     116       out_EXECUTE_OUT_ADDRESS        = interface->set_signal_out<Tgeneral_data_t   > ("address"      ,_param->_size_general_data);
    114117     }
    115118

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/src/Functionnal_unit_deallocation.cpp

    r76 r78  
    4141        delete  in_EXECUTE_IN_OPERATION     ;
    4242        delete  in_EXECUTE_IN_TYPE          ;
     43        delete  in_EXECUTE_IN_STORE_QUEUE_PTR_WRITE;
     44        if (_param->_have_port_load_queue_ptr)
     45        delete  in_EXECUTE_IN_LOAD_QUEUE_PTR_WRITE ;
    4346        delete  in_EXECUTE_IN_HAS_IMMEDIAT  ;
    4447        delete  in_EXECUTE_IN_IMMEDIAT      ;
    … …  
    6265        delete out_EXECUTE_OUT_PACKET_ID      ;
    6366      //delete out_EXECUTE_OUT_OPERATION      ;
    64       //delete out_EXECUTE_OUT_TYPE           ;
     67        delete out_EXECUTE_OUT_TYPE           ;
    6568        delete out_EXECUTE_OUT_WRITE_RD       ;
    6669        delete out_EXECUTE_OUT_NUM_REG_RD     ;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/src/Functionnal_unit_genMoore.cpp

    r72 r78  
    3737    PORT_WRITE(out_EXECUTE_OUT_PACKET_ID    ,_execute_operation->_packet_id    );
    3838  //PORT_WRITE(out_EXECUTE_OUT_OPERATION    ,_execute_operation->_operation    );
    39   //PORT_WRITE(out_EXECUTE_OUT_TYPE         ,_execute_operation->_type         );
     39    PORT_WRITE(out_EXECUTE_OUT_TYPE         ,_execute_operation->_type         );
    4040    PORT_WRITE(out_EXECUTE_OUT_WRITE_RD     ,_execute_operation->_write_rd     );
    4141    PORT_WRITE(out_EXECUTE_OUT_NUM_REG_RD   ,_execute_operation->_num_reg_rd   );

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/src/Parameters.cpp

    r77 r78  
    2828                          uint32_t           size_special_data  ,
    2929                          uint32_t           nb_special_register,
     30                          uint32_t           size_store_queue   ,
     31                          uint32_t           size_load_queue    ,
    3032                          execute_timing_t** timing             ,
    3133                          morpheo::behavioural::custom::custom_information_t (*get_custom_information) (uint32_t)) :
    … …  
    3840    _size_special_data       (size_special_data     ),
    3941    _nb_special_register     (nb_special_register   ),
    40    
     42    _size_store_queue        (size_store_queue      ),
     43    _size_load_queue         (size_load_queue       ),
     44
    4145    _size_context_id         (log2(nb_context      )),
    4246    _size_front_end_id       (log2(nb_front_end    )),
    4347    _size_ooo_engine_id      (log2(nb_ooo_engine   )),
    4448    _size_packet_id          (log2(nb_packet       )),
    45     _size_general_register   (log2(_size_general_register)),
    46     _size_special_register   (log2(_size_special_register)),
     49    _size_general_register   (log2(nb_general_register)),
     50    _size_special_register   (log2(nb_special_register)),
    4751
    4852    _have_port_context_id    (_size_context_id    > 0),
    … …  
    5054    _have_port_ooo_engine_id (_size_ooo_engine_id > 0),
    5155    _have_port_packet_id     (_size_packet_id     > 0),
     56    _have_port_load_queue_ptr(_size_load_queue    > 1),
    5257
    5358    _have_groupe_MAC         ( (timing[TYPE_SPECIAL][OPERATION_SPECIAL_L_MAC  ]._latence > 0) or
    … …  
    5863
    5964    _timing                 = timing;
    60     _get_custom_information = get_custom_information;
     65
     66    if (get_custom_information == NULL)
     67      _get_custom_information = &(morpheo::behavioural::custom::default_get_custom_information);
     68    else
     69      _get_custom_information = get_custom_information;
    6170
    6271    test();
    … …  
    7685    _size_special_data       (param._size_special_data      ),
    7786    _nb_special_register     (param._nb_special_register    ),
     87    _size_store_queue        (param._size_store_queue       ),
     88    _size_load_queue         (param._size_load_queue        ),
    7889
    7990    _size_context_id         (param._size_context_id        ),
    … …  
    8899    _have_port_ooo_engine_id (param._have_port_ooo_engine_id),
    89100    _have_port_packet_id     (param._have_port_packet_id    ),
     101    _have_port_load_queue_ptr(param._have_port_load_queue_ptr),
    90102
    91103    _have_groupe_MAC         (param._have_groupe_MAC        )

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/src/Parameters_msg_error.cpp

    r77 r78  
    2222#undef  FUNCTION
    2323#define FUNCTION "Functionnal_unit::msg_error"
    24   std::string Parameters::msg_error(void)
     24  Parameters_test Parameters::msg_error(void)
    2525  {
    2626    log_printf(FUNC,Functionnal_unit,FUNCTION,"Begin");
    2727
    28     std::string msg = "";
     28    Parameters_test test("Functionnal_unit");
    2929
    3030    for (uint32_t i=0; i<_nb_type; i++)
    3131      for (uint32_t j=0; j<_nb_operation; j++)
    3232        if (_timing[i][j]._delay != _timing[i][j]._latence)
    33           msg = "  - For the type '"+toString(i)+"', and the operation '"+toString(j)+"', the delay and the latence must be equal.";
     33          test.error("For the type '"+toString(i)+"', and the operation '"+toString(j)+"', the delay and the latence must be equal.");
    3434
    3535    if (_have_groupe_MAC and ((_timing[TYPE_SPECIAL][OPERATION_SPECIAL_L_MAC  ]._latence == 0) or
    3636                              (_timing[TYPE_SPECIAL][OPERATION_SPECIAL_L_MACRC]._latence == 0) or
    3737                              (_timing[TYPE_SPECIAL][OPERATION_SPECIAL_L_MSB  ]._latence == 0)))
    38       msg = "  - The functionnal unit implement a MAC unit, the latence to operation OPERATION_ALU_L_MAC, OPERATION_ALU_L_MACRC and OPERATION_ALU_L_MSB must be higher than 0.";
    39 
    40     return msg;
     38      test.error("The functionnal unit implement a MAC unit, the latence to operation OPERATION_ALU_L_MAC, OPERATION_ALU_L_MACRC and OPERATION_ALU_L_MSB must be higher than 0.");
    4139
    4240    log_printf(FUNC,Functionnal_unit,FUNCTION,"End");
     41
     42    return test;
    4343  };
    4444

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/SelfTest/configuration.cfg

    r77 r78  
    552       2       +1      # nb_port_check
    662       2       +1      # speculative_load       {none,access,commit,bypass}
     70       0       +1      # bypass_memory
    782       2       *2      # nb_context             1      1       *2     
    892       2       *2      # nb_front_end           1      1       *2     
    … …  
    101164      64      *2      # nb_packet             
    111232      32      *2      # size_general_data     
     132       2       *2      # size_special_data     
    121432      32      *2      # nb_general_register   
     1516      16      *2      # nb_special_register   

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/SelfTest/src/main.cpp

    r77 r78  
    1010#define number_of_test 2
    1111
    12 #define NB_PARAMS 11
     12#define NB_PARAMS 14
    1313
    1414void usage (int argc, char * argv[])
    … …  
    2121       << " - nb_port_check           (uint32_t)" << endl
    2222       << " - speculative_load        (uint32_t)" << endl
     23       << " - nb_bypass_memory        (uint32_t)" << endl
    2324       << " - nb_context              (uint32_t)" << endl
    2425       << " - nb_front_end            (uint32_t)" << endl
    … …  
    2627       << " - nb_packet               (uint32_t)" << endl
    2728       << " - size_general_data       (uint32_t)" << endl
     29       << " - size_special_data       (uint32_t)" << endl
    2830       << " - nb_general_register     (uint32_t)" << endl
     31       << " - nb_special_register     (uint32_t)" << endl
    2932       << "" << endl;
    3033
    … …  
    5861        const uint32_t            _nb_port_check           = atoi(argv[x++]);
    5962        const Tspeculative_load_t _speculative_load        = fromString<Tspeculative_load_t>(argv[x++]);
     63        const uint32_t            _nb_bypass_memory        = atoi(argv[x++]);
    6064        const uint32_t            _nb_context              = atoi(argv[x++]);
    6165        const uint32_t            _nb_front_end            = atoi(argv[x++]);
    … …  
    6367        const uint32_t            _nb_packet               = atoi(argv[x++]);
    6468        const uint32_t            _size_general_data       = atoi(argv[x++]);
     69        const uint32_t            _size_special_data       = atoi(argv[x++]);
    6570        const uint32_t            _nb_general_register     = atoi(argv[x++]);
     71        const uint32_t            _nb_special_register     = atoi(argv[x++]);
    6672       
    6773        try
    … …  
    7480               _nb_port_check          ,
    7581               _speculative_load       ,
     82               _nb_bypass_memory       ,
    7683               _nb_context             ,
    7784               _nb_front_end           ,
    … …  
    7986               _nb_packet              ,
    8087               _size_general_data      ,
    81                _nb_general_register    );
     88               _size_special_data      ,
     89               _nb_general_register    ,
     90               _nb_special_register    );
    8291           
    8392            cout << param->print(1);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/SelfTest/src/test1.cpp

    r72 r78  
    7373  sc_signal<Tlsq_ptr_t        > *   in_MEMORY_IN_STORE_QUEUE_PTR_WRITE = new sc_signal<Tlsq_ptr_t        > (rename.c_str());
    7474  sc_signal<Tlsq_ptr_t        > *   in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE  = new sc_signal<Tlsq_ptr_t        > (rename.c_str());
    75   //sc_signal<Tcontrol_t        > *   in_MEMORY_IN_HAS_IMMEDIAT          = new sc_signal<Tcontrol_t        > (rename.c_str());
     75  sc_signal<Tcontrol_t        > *   in_MEMORY_IN_HAS_IMMEDIAT          = new sc_signal<Tcontrol_t        > (rename.c_str());
    7676  sc_signal<Tgeneral_data_t   > *   in_MEMORY_IN_IMMEDIAT              = new sc_signal<Tgeneral_data_t   > (rename.c_str());
    7777  sc_signal<Tgeneral_data_t   > *   in_MEMORY_IN_DATA_RA               = new sc_signal<Tgeneral_data_t   > (rename.c_str());
    7878  sc_signal<Tgeneral_data_t   > *   in_MEMORY_IN_DATA_RB               = new sc_signal<Tgeneral_data_t   > (rename.c_str());
    79   //sc_signal<Tspecial_data_t   > *   in_MEMORY_IN_DATA_RC               = new sc_signal<Tspecial_data_t   > (rename.c_str());
    80 //   sc_signal<Tcontrol_t        > *   in_MEMORY_IN_WRITE_RD              = new sc_signal<Tcontrol_t        > (rename.c_str());
     79  sc_signal<Tspecial_data_t   > *   in_MEMORY_IN_DATA_RC               = new sc_signal<Tspecial_data_t   > (rename.c_str());
     80  sc_signal<Tcontrol_t        > *   in_MEMORY_IN_WRITE_RD              = new sc_signal<Tcontrol_t        > (rename.c_str());
    8181  sc_signal<Tgeneral_address_t> *   in_MEMORY_IN_NUM_REG_RD            = new sc_signal<Tgeneral_address_t> (rename.c_str());
    82   //sc_signal<Tcontrol_t        > *   in_MEMORY_IN_WRITE_RE              = new sc_signal<Tcontrol_t        > (rename.c_str());
    83   //sc_signal<Tspecial_address_t> *   in_MEMORY_IN_NUM_REG_RE            = new sc_signal<Tspecial_address_t> (rename.c_str());
     82  sc_signal<Tcontrol_t        > *   in_MEMORY_IN_WRITE_RE              = new sc_signal<Tcontrol_t        > (rename.c_str());
     83  sc_signal<Tspecial_address_t> *   in_MEMORY_IN_NUM_REG_RE            = new sc_signal<Tspecial_address_t> (rename.c_str());
    8484
    8585  sc_signal<Tcontrol_t        > *  out_MEMORY_OUT_VAL           = new sc_signal<Tcontrol_t        >(rename.c_str());
    … …  
    8989  sc_signal<Tcontext_t        > *  out_MEMORY_OUT_OOO_ENGINE_ID = new sc_signal<Tcontext_t        >(rename.c_str());
    9090  sc_signal<Tpacket_t         > *  out_MEMORY_OUT_PACKET_ID     = new sc_signal<Tpacket_t         >(rename.c_str());
     91//   sc_signal<Toperation_t      > *  out_MEMORY_OUT_OPERATION     = new sc_signal<Toperation_t      >(rename.c_str());
     92  sc_signal<Ttype_t           > *  out_MEMORY_OUT_TYPE          = new sc_signal<Ttype_t           >(rename.c_str());
    9193  sc_signal<Tcontrol_t        > *  out_MEMORY_OUT_WRITE_RD      = new sc_signal<Tcontrol_t        >(rename.c_str());
    9294  sc_signal<Tgeneral_address_t> *  out_MEMORY_OUT_NUM_REG_RD    = new sc_signal<Tgeneral_address_t>(rename.c_str());
    9395  sc_signal<Tgeneral_data_t   > *  out_MEMORY_OUT_DATA_RD       = new sc_signal<Tgeneral_data_t   >(rename.c_str());
    94   //sc_signal<Tcontrol_t        > *  out_MEMORY_OUT_WRITE_RE      = new sc_signal<Tcontrol_t        >(rename.c_str());
    95   //sc_signal<Tspecial_address_t> *  out_MEMORY_OUT_NUM_REG_RE    = new sc_signal<Tspecial_address_t>(rename.c_str());
    96   //sc_signal<Tspecial_data_t   > *  out_MEMORY_OUT_DATA_RE       = new sc_signal<Tspecial_data_t   >(rename.c_str());
     96  sc_signal<Tcontrol_t        > *  out_MEMORY_OUT_WRITE_RE      = new sc_signal<Tcontrol_t        >(rename.c_str());
     97  sc_signal<Tspecial_address_t> *  out_MEMORY_OUT_NUM_REG_RE    = new sc_signal<Tspecial_address_t>(rename.c_str());
     98  sc_signal<Tspecial_data_t   > *  out_MEMORY_OUT_DATA_RE       = new sc_signal<Tspecial_data_t   >(rename.c_str());
    9799  sc_signal<Texception_t      > *  out_MEMORY_OUT_EXCEPTION     = new sc_signal<Texception_t      >(rename.c_str());
     100  sc_signal<Tcontrol_t        > *  out_MEMORY_OUT_NO_SEQUENCE   = new sc_signal<Tcontrol_t        >(rename.c_str());
     101  sc_signal<Tgeneral_data_t   > *  out_MEMORY_OUT_ADDRESS       = new sc_signal<Tgeneral_data_t   >(rename.c_str());
    98102
    99103  sc_signal<Tcontrol_t        > * out_DCACHE_REQ_VAL        = new sc_signal<Tcontrol_t        >(rename.c_str());
    … …  
    112116  sc_signal<Tdcache_error_t   > *  in_DCACHE_RSP_ERROR      = new sc_signal<Tdcache_error_t   >(rename.c_str());
    113117 
    114   sc_signal<Tcontrol_t        > ** out_BYPASS_MEMORY_VAL           = new sc_signal<Tcontrol_t        > * [_param->_size_load_queue];
    115   sc_signal<Tcontext_t        > ** out_BYPASS_MEMORY_OOO_ENGINE_ID = new sc_signal<Tcontext_t        > * [_param->_size_load_queue];
    116   sc_signal<Tgeneral_address_t> ** out_BYPASS_MEMORY_NUM_REG       = new sc_signal<Tgeneral_address_t> * [_param->_size_load_queue];
    117   sc_signal<Tgeneral_data_t   > ** out_BYPASS_MEMORY_DATA          = new sc_signal<Tgeneral_data_t   > * [_param->_size_load_queue];
     118  sc_signal<Tcontrol_t        > ** out_BYPASS_MEMORY_VAL           = new sc_signal<Tcontrol_t        > * [_param->_nb_bypass_memory];
     119  sc_signal<Tcontext_t        > ** out_BYPASS_MEMORY_OOO_ENGINE_ID = new sc_signal<Tcontext_t        > * [_param->_nb_bypass_memory];
     120  sc_signal<Tgeneral_address_t> ** out_BYPASS_MEMORY_NUM_REG       = new sc_signal<Tgeneral_address_t> * [_param->_nb_bypass_memory];
     121  sc_signal<Tgeneral_data_t   > ** out_BYPASS_MEMORY_DATA          = new sc_signal<Tgeneral_data_t   > * [_param->_nb_bypass_memory];
    118122   
    119   for (uint32_t i=0; i<_param->_size_load_queue; i++)
     123  for (uint32_t i=0; i<_param->_nb_bypass_memory; i++)
    120124    {
    121125      out_BYPASS_MEMORY_VAL           [i] = new sc_signal<Tcontrol_t        >(rename.c_str());
    … …  
    137141  (*(_Load_store_unit->out_MEMORY_IN_ACK                  ))(*(out_MEMORY_IN_ACK                  ));
    138142  if (_param->_have_port_context_id)
    139     (*(_Load_store_unit-> in_MEMORY_IN_CONTEXT_ID           ))(*( in_MEMORY_IN_CONTEXT_ID           ));
     143  (*(_Load_store_unit-> in_MEMORY_IN_CONTEXT_ID           ))(*( in_MEMORY_IN_CONTEXT_ID           ));
    140144  if (_param->_have_port_front_end_id)
    141     (*(_Load_store_unit-> in_MEMORY_IN_FRONT_END_ID         ))(*( in_MEMORY_IN_FRONT_END_ID         ));
     145  (*(_Load_store_unit-> in_MEMORY_IN_FRONT_END_ID         ))(*( in_MEMORY_IN_FRONT_END_ID         ));
    142146  if (_param->_have_port_ooo_engine_id)
    143     (*(_Load_store_unit-> in_MEMORY_IN_OOO_ENGINE_ID        ))(*( in_MEMORY_IN_OOO_ENGINE_ID        ));
     147  (*(_Load_store_unit-> in_MEMORY_IN_OOO_ENGINE_ID        ))(*( in_MEMORY_IN_OOO_ENGINE_ID        ));
    144148  if (_param->_have_port_packet_id)
    145     (*(_Load_store_unit-> in_MEMORY_IN_PACKET_ID            ))(*( in_MEMORY_IN_PACKET_ID            ));
     149  (*(_Load_store_unit-> in_MEMORY_IN_PACKET_ID            ))(*( in_MEMORY_IN_PACKET_ID            ));
    146150  (*(_Load_store_unit-> in_MEMORY_IN_OPERATION            ))(*( in_MEMORY_IN_OPERATION            ));
     151  (*(_Load_store_unit-> in_MEMORY_IN_TYPE                 ))(*( in_MEMORY_IN_TYPE                 ));
    147152  (*(_Load_store_unit-> in_MEMORY_IN_STORE_QUEUE_PTR_WRITE))(*( in_MEMORY_IN_STORE_QUEUE_PTR_WRITE));
     153  if (_param->_have_port_load_queue_ptr)
    148154  (*(_Load_store_unit-> in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE ))(*( in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE ));
    149   //(*(_Load_store_unit-> in_MEMORY_IN_HAS_IMMEDIAT         ))(*( in_MEMORY_IN_HAS_IMMEDIAT         ));
     155  (*(_Load_store_unit-> in_MEMORY_IN_HAS_IMMEDIAT         ))(*( in_MEMORY_IN_HAS_IMMEDIAT         ));
    150156  (*(_Load_store_unit-> in_MEMORY_IN_IMMEDIAT             ))(*( in_MEMORY_IN_IMMEDIAT             ));
    151157  (*(_Load_store_unit-> in_MEMORY_IN_DATA_RA              ))(*( in_MEMORY_IN_DATA_RA              ));
    152158  (*(_Load_store_unit-> in_MEMORY_IN_DATA_RB              ))(*( in_MEMORY_IN_DATA_RB              ));
    153   //(*(_Load_store_unit-> in_MEMORY_IN_DATA_RC              ))(*( in_MEMORY_IN_DATA_RC              ));
    154 //   (*(_Load_store_unit-> in_MEMORY_IN_WRITE_RD             ))(*( in_MEMORY_IN_WRITE_RD             ));
     159  (*(_Load_store_unit-> in_MEMORY_IN_DATA_RC              ))(*( in_MEMORY_IN_DATA_RC              ));
     160  (*(_Load_store_unit-> in_MEMORY_IN_WRITE_RD             ))(*( in_MEMORY_IN_WRITE_RD             ));
    155161  (*(_Load_store_unit-> in_MEMORY_IN_NUM_REG_RD           ))(*( in_MEMORY_IN_NUM_REG_RD           ));
    156   //(*(_Load_store_unit-> in_MEMORY_IN_WRITE_RE             ))(*( in_MEMORY_IN_WRITE_RE             ));
    157   //(*(_Load_store_unit-> in_MEMORY_IN_NUM_REG_RE           ))(*( in_MEMORY_IN_NUM_REG_RE           ));
     162  (*(_Load_store_unit-> in_MEMORY_IN_WRITE_RE             ))(*( in_MEMORY_IN_WRITE_RE             ));
     163  (*(_Load_store_unit-> in_MEMORY_IN_NUM_REG_RE           ))(*( in_MEMORY_IN_NUM_REG_RE           ));
    158164 
    159165  (*(_Load_store_unit->out_MEMORY_OUT_VAL           ))(*(out_MEMORY_OUT_VAL           ));
    160166  (*(_Load_store_unit-> in_MEMORY_OUT_ACK           ))(*( in_MEMORY_OUT_ACK           ));
    161167  if (_param->_have_port_context_id)
    162     (*(_Load_store_unit->out_MEMORY_OUT_CONTEXT_ID    ))(*(out_MEMORY_OUT_CONTEXT_ID    ));
     168  (*(_Load_store_unit->out_MEMORY_OUT_CONTEXT_ID    ))(*(out_MEMORY_OUT_CONTEXT_ID    ));
    163169  if (_param->_have_port_front_end_id)
    164     (*(_Load_store_unit->out_MEMORY_OUT_FRONT_END_ID  ))(*(out_MEMORY_OUT_FRONT_END_ID  ));
     170  (*(_Load_store_unit->out_MEMORY_OUT_FRONT_END_ID  ))(*(out_MEMORY_OUT_FRONT_END_ID  ));
    165171  if (_param->_have_port_ooo_engine_id)
    166     (*(_Load_store_unit->out_MEMORY_OUT_OOO_ENGINE_ID ))(*(out_MEMORY_OUT_OOO_ENGINE_ID ));
     172  (*(_Load_store_unit->out_MEMORY_OUT_OOO_ENGINE_ID ))(*(out_MEMORY_OUT_OOO_ENGINE_ID ));
    167173  if (_param->_have_port_packet_id)
    168     (*(_Load_store_unit->out_MEMORY_OUT_PACKET_ID     ))(*(out_MEMORY_OUT_PACKET_ID     ));
     174  (*(_Load_store_unit->out_MEMORY_OUT_PACKET_ID     ))(*(out_MEMORY_OUT_PACKET_ID     ));
     175//   (*(_Load_store_unit->out_MEMORY_OUT_OPERATION     ))(*(out_MEMORY_OUT_OPERATION     ));
     176  (*(_Load_store_unit->out_MEMORY_OUT_TYPE          ))(*(out_MEMORY_OUT_TYPE          ));
    169177  (*(_Load_store_unit->out_MEMORY_OUT_WRITE_RD      ))(*(out_MEMORY_OUT_WRITE_RD      ));
    170178  (*(_Load_store_unit->out_MEMORY_OUT_NUM_REG_RD    ))(*(out_MEMORY_OUT_NUM_REG_RD    ));
    171179  (*(_Load_store_unit->out_MEMORY_OUT_DATA_RD       ))(*(out_MEMORY_OUT_DATA_RD       ));
    172   //(*(_Load_store_unit->out_MEMORY_OUT_WRITE_RE      ))(*(out_MEMORY_OUT_WRITE_RE      ));
    173   //(*(_Load_store_unit->out_MEMORY_OUT_NUM_REG_RE    ))(*(out_MEMORY_OUT_NUM_REG_RE    ));
    174   //(*(_Load_store_unit->out_MEMORY_OUT_DATA_RE       ))(*(out_MEMORY_OUT_DATA_RE       ));
     180  (*(_Load_store_unit->out_MEMORY_OUT_WRITE_RE      ))(*(out_MEMORY_OUT_WRITE_RE      ));
     181  (*(_Load_store_unit->out_MEMORY_OUT_NUM_REG_RE    ))(*(out_MEMORY_OUT_NUM_REG_RE    ));
     182  (*(_Load_store_unit->out_MEMORY_OUT_DATA_RE       ))(*(out_MEMORY_OUT_DATA_RE       ));
    175183  (*(_Load_store_unit->out_MEMORY_OUT_EXCEPTION     ))(*(out_MEMORY_OUT_EXCEPTION     ));
     184  (*(_Load_store_unit->out_MEMORY_OUT_NO_SEQUENCE   ))(*(out_MEMORY_OUT_NO_SEQUENCE   ));
     185  (*(_Load_store_unit->out_MEMORY_OUT_ADDRESS       ))(*(out_MEMORY_OUT_ADDRESS       ));
    176186
    177187  (*(_Load_store_unit->out_DCACHE_REQ_VAL       ))(*(out_DCACHE_REQ_VAL       ));
    … …  
    192202  (*(_Load_store_unit-> in_DCACHE_RSP_ERROR     ))(*( in_DCACHE_RSP_ERROR     ));
    193203
    194   if (_param->_speculative_load == SPECULATIVE_LOAD_BYPASS)
    195204    {
    196       for (uint32_t i=0; i<_param->_size_load_queue; i++)
     205      for (uint32_t i=0; i<_param->_nb_bypass_memory; i++)
    197206        {
    198207          (*(_Load_store_unit->out_BYPASS_MEMORY_VAL           [i]))(*(out_BYPASS_MEMORY_VAL           [i]));
    … …  
    486495              in_MEMORY_IN_TYPE                 ->write (fifo_request.top()._type                 );
    487496              in_MEMORY_IN_STORE_QUEUE_PTR_WRITE->write (fifo_request.top()._store_queue_ptr_write);
     497              if (_param->_have_port_load_queue_ptr)
    488498              in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE ->write (fifo_request.top()._load_queue_ptr_write );
    489499              in_MEMORY_IN_IMMEDIAT             ->write (fifo_request.top()._immediat             );
    … …  
    563573                  TEST(Tcontext_t        , out_MEMORY_OUT_OOO_ENGINE_ID->read(), tab_request[packet_id]._ooo_engine_id);
    564574                  TEST(Tpacket_t         , out_MEMORY_OUT_PACKET_ID    ->read(), tab_request[packet_id]._packet_id    );
     575//                TEST(Toperation_t      , out_MEMORY_OUT_OPERATION    ->read(), tab_request[packet_id]._operation    );
     576                  TEST(Ttype_t           , out_MEMORY_OUT_TYPE         ->read(), TYPE_MEMORY                          );
    565577                  TEST(Tcontrol_t        , out_MEMORY_OUT_WRITE_RD     ->read(), tab_request[packet_id]._write_rd     );
    566578                  TEST(Tgeneral_address_t, out_MEMORY_OUT_NUM_REG_RD   ->read(), tab_request[packet_id]._num_reg_rd   );
    … …  
    682694  delete     in_MEMORY_IN_STORE_QUEUE_PTR_WRITE;
    683695  delete     in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE ;
    684   //delete     in_MEMORY_IN_HAS_IMMEDIAT;
     696  delete     in_MEMORY_IN_HAS_IMMEDIAT;
    685697  delete     in_MEMORY_IN_IMMEDIAT    ;
    686698  delete     in_MEMORY_IN_DATA_RA     ;
    687699  delete     in_MEMORY_IN_DATA_RB     ;
    688   //delete     in_MEMORY_IN_DATA_RC     ;
    689 //   delete     in_MEMORY_IN_WRITE_RD    ;
     700  delete     in_MEMORY_IN_DATA_RC     ;
     701  delete     in_MEMORY_IN_WRITE_RD    ;
    690702  delete     in_MEMORY_IN_NUM_REG_RD  ;
    691   //delete     in_MEMORY_IN_WRITE_RE    ;
    692   //delete     in_MEMORY_IN_NUM_REG_RE  ;
     703  delete     in_MEMORY_IN_WRITE_RE    ;
     704  delete     in_MEMORY_IN_NUM_REG_RE  ;
    693705   
    694706  delete    out_MEMORY_OUT_VAL       ;
    … …  
    698710  delete    out_MEMORY_OUT_OOO_ENGINE_ID;
    699711  delete    out_MEMORY_OUT_PACKET_ID ;
     712//   delete    out_MEMORY_OUT_OPERATION ;
     713  delete    out_MEMORY_OUT_TYPE      ;
    700714  delete    out_MEMORY_OUT_WRITE_RD  ;
    701715  delete    out_MEMORY_OUT_NUM_REG_RD;
    702716  delete    out_MEMORY_OUT_DATA_RD   ;
    703   //delete    out_MEMORY_OUT_WRITE_RE  ;
    704   //delete    out_MEMORY_OUT_NUM_REG_RE;
    705   //delete    out_MEMORY_OUT_DATA_RE   ;
     717  delete    out_MEMORY_OUT_WRITE_RE  ;
     718  delete    out_MEMORY_OUT_NUM_REG_RE;
     719  delete    out_MEMORY_OUT_DATA_RE   ;
    706720  delete    out_MEMORY_OUT_EXCEPTION ;
     721  delete    out_MEMORY_OUT_NO_SEQUENCE;
     722  delete    out_MEMORY_OUT_ADDRESS   ;
    707723 
    708724  delete    out_DCACHE_REQ_VAL       ;
    … …  
    721737  delete     in_DCACHE_RSP_ERROR     ;
    722738 
    723   if (_param->_speculative_load == SPECULATIVE_LOAD_BYPASS)
    724739    {
    725740      delete [] out_BYPASS_MEMORY_VAL       ;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/SelfTest/src/test2.cpp

    r77 r78  
    5252         2,  //_nb_port_check         
    5353         SPECULATIVE_LOAD_COMMIT,  //_speculative_load       
     54         0,  //_nb_bypass_memory
    5455         1,  //_nb_context             
    5556         1,  //_nb_front_end           
    … …  
    5758         128,//_nb_packet             
    5859         32, //_size_general_data     
    59          64  //_nb_general_register   
     60         2 , //_size_special_data     
     61         64, //_nb_general_register   
     62         16  //_nb_special_register   
    6063        );
    6164
    … …  
    8992  sc_signal<Tlsq_ptr_t        > *   in_MEMORY_IN_STORE_QUEUE_PTR_WRITE = new sc_signal<Tlsq_ptr_t        > (rename.c_str());
    9093  sc_signal<Tlsq_ptr_t        > *   in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE  = new sc_signal<Tlsq_ptr_t        > (rename.c_str());
    91   //sc_signal<Tcontrol_t        > *   in_MEMORY_IN_HAS_IMMEDIAT          = new sc_signal<Tcontrol_t        > (rename.c_str());
     94  sc_signal<Tcontrol_t        > *   in_MEMORY_IN_HAS_IMMEDIAT          = new sc_signal<Tcontrol_t        > (rename.c_str());
    9295  sc_signal<Tgeneral_data_t   > *   in_MEMORY_IN_IMMEDIAT              = new sc_signal<Tgeneral_data_t   > (rename.c_str());
    9396  sc_signal<Tgeneral_data_t   > *   in_MEMORY_IN_DATA_RA               = new sc_signal<Tgeneral_data_t   > (rename.c_str());
    9497  sc_signal<Tgeneral_data_t   > *   in_MEMORY_IN_DATA_RB               = new sc_signal<Tgeneral_data_t   > (rename.c_str());
    95   //sc_signal<Tspecial_data_t   > *   in_MEMORY_IN_DATA_RC               = new sc_signal<Tspecial_data_t   > (rename.c_str());
    96 //   sc_signal<Tcontrol_t        > *   in_MEMORY_IN_WRITE_RD              = new sc_signal<Tcontrol_t        > (rename.c_str());
     98  sc_signal<Tspecial_data_t   > *   in_MEMORY_IN_DATA_RC               = new sc_signal<Tspecial_data_t   > (rename.c_str());
     99  sc_signal<Tcontrol_t        > *   in_MEMORY_IN_WRITE_RD              = new sc_signal<Tcontrol_t        > (rename.c_str());
    97100  sc_signal<Tgeneral_address_t> *   in_MEMORY_IN_NUM_REG_RD            = new sc_signal<Tgeneral_address_t> (rename.c_str());
    98   //sc_signal<Tcontrol_t        > *   in_MEMORY_IN_WRITE_RE              = new sc_signal<Tcontrol_t        > (rename.c_str());
    99   //sc_signal<Tspecial_address_t> *   in_MEMORY_IN_NUM_REG_RE            = new sc_signal<Tspecial_address_t> (rename.c_str());
     101  sc_signal<Tcontrol_t        > *   in_MEMORY_IN_WRITE_RE              = new sc_signal<Tcontrol_t        > (rename.c_str());
     102  sc_signal<Tspecial_address_t> *   in_MEMORY_IN_NUM_REG_RE            = new sc_signal<Tspecial_address_t> (rename.c_str());
    100103
    101104  sc_signal<Tcontrol_t        > *  out_MEMORY_OUT_VAL           = new sc_signal<Tcontrol_t        >(rename.c_str());
    … …  
    105108  sc_signal<Tcontext_t        > *  out_MEMORY_OUT_OOO_ENGINE_ID = new sc_signal<Tcontext_t        >(rename.c_str());
    106109  sc_signal<Tpacket_t         > *  out_MEMORY_OUT_PACKET_ID     = new sc_signal<Tpacket_t         >(rename.c_str());
     110//   sc_signal<Toperation_t      > *  out_MEMORY_OUT_OPERATION     = new sc_signal<Toperation_t      >(rename.c_str());
     111  sc_signal<Ttype_t           > *  out_MEMORY_OUT_TYPE          = new sc_signal<Ttype_t           >(rename.c_str());
    107112  sc_signal<Tcontrol_t        > *  out_MEMORY_OUT_WRITE_RD      = new sc_signal<Tcontrol_t        >(rename.c_str());
    108113  sc_signal<Tgeneral_address_t> *  out_MEMORY_OUT_NUM_REG_RD    = new sc_signal<Tgeneral_address_t>(rename.c_str());
    109114  sc_signal<Tgeneral_data_t   > *  out_MEMORY_OUT_DATA_RD       = new sc_signal<Tgeneral_data_t   >(rename.c_str());
    110   //sc_signal<Tcontrol_t        > *  out_MEMORY_OUT_WRITE_RE      = new sc_signal<Tcontrol_t        >(rename.c_str());
    111   //sc_signal<Tspecial_address_t> *  out_MEMORY_OUT_NUM_REG_RE    = new sc_signal<Tspecial_address_t>(rename.c_str());
    112   //sc_signal<Tspecial_data_t   > *  out_MEMORY_OUT_DATA_RE       = new sc_signal<Tspecial_data_t   >(rename.c_str());
     115  sc_signal<Tcontrol_t        > *  out_MEMORY_OUT_WRITE_RE      = new sc_signal<Tcontrol_t        >(rename.c_str());
     116  sc_signal<Tspecial_address_t> *  out_MEMORY_OUT_NUM_REG_RE    = new sc_signal<Tspecial_address_t>(rename.c_str());
     117  sc_signal<Tspecial_data_t   > *  out_MEMORY_OUT_DATA_RE       = new sc_signal<Tspecial_data_t   >(rename.c_str());
    113118  sc_signal<Texception_t      > *  out_MEMORY_OUT_EXCEPTION     = new sc_signal<Texception_t      >(rename.c_str());
     119  sc_signal<Tcontrol_t        > *  out_MEMORY_OUT_NO_SEQUENCE   = new sc_signal<Tcontrol_t        >(rename.c_str());
     120  sc_signal<Tgeneral_data_t   > *  out_MEMORY_OUT_ADDRESS       = new sc_signal<Tgeneral_data_t   >(rename.c_str());
    114121
    115122  sc_signal<Tcontrol_t        > * out_DCACHE_REQ_VAL        = new sc_signal<Tcontrol_t        >(rename.c_str());
    … …  
    128135  sc_signal<Tdcache_error_t   > *  in_DCACHE_RSP_ERROR      = new sc_signal<Tdcache_error_t   >(rename.c_str());
    129136 
    130   sc_signal<Tcontrol_t        > ** out_BYPASS_MEMORY_VAL           = new sc_signal<Tcontrol_t        > * [_param->_size_load_queue];
    131   sc_signal<Tcontext_t        > ** out_BYPASS_MEMORY_OOO_ENGINE_ID = new sc_signal<Tcontext_t        > * [_param->_size_load_queue];
    132   sc_signal<Tgeneral_address_t> ** out_BYPASS_MEMORY_NUM_REG       = new sc_signal<Tgeneral_address_t> * [_param->_size_load_queue];
    133   sc_signal<Tgeneral_data_t   > ** out_BYPASS_MEMORY_DATA          = new sc_signal<Tgeneral_data_t   > * [_param->_size_load_queue];
     137  sc_signal<Tcontrol_t        > ** out_BYPASS_MEMORY_VAL           = new sc_signal<Tcontrol_t        > * [_param->_nb_bypass_memory];
     138  sc_signal<Tcontext_t        > ** out_BYPASS_MEMORY_OOO_ENGINE_ID = new sc_signal<Tcontext_t        > * [_param->_nb_bypass_memory];
     139  sc_signal<Tgeneral_address_t> ** out_BYPASS_MEMORY_NUM_REG       = new sc_signal<Tgeneral_address_t> * [_param->_nb_bypass_memory];
     140  sc_signal<Tgeneral_data_t   > ** out_BYPASS_MEMORY_DATA          = new sc_signal<Tgeneral_data_t   > * [_param->_nb_bypass_memory];
    134141   
    135   for (uint32_t i=0; i<_param->_size_load_queue; i++)
     142  for (uint32_t i=0; i<_param->_nb_bypass_memory; i++)
    136143    {
    137144      out_BYPASS_MEMORY_VAL           [i] = new sc_signal<Tcontrol_t        >(rename.c_str());
    … …  
    161168    (*(_Load_store_unit-> in_MEMORY_IN_PACKET_ID            ))(*( in_MEMORY_IN_PACKET_ID            ));
    162169  (*(_Load_store_unit-> in_MEMORY_IN_OPERATION            ))(*( in_MEMORY_IN_OPERATION            ));
     170  (*(_Load_store_unit-> in_MEMORY_IN_TYPE                 ))(*( in_MEMORY_IN_TYPE                 ));
    163171  (*(_Load_store_unit-> in_MEMORY_IN_STORE_QUEUE_PTR_WRITE))(*( in_MEMORY_IN_STORE_QUEUE_PTR_WRITE));
     172  if (_param->_have_port_load_queue_ptr)
    164173  (*(_Load_store_unit-> in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE ))(*( in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE ));
    165   //(*(_Load_store_unit-> in_MEMORY_IN_HAS_IMMEDIAT         ))(*( in_MEMORY_IN_HAS_IMMEDIAT         ));
     174  (*(_Load_store_unit-> in_MEMORY_IN_HAS_IMMEDIAT         ))(*( in_MEMORY_IN_HAS_IMMEDIAT         ));
    166175  (*(_Load_store_unit-> in_MEMORY_IN_IMMEDIAT             ))(*( in_MEMORY_IN_IMMEDIAT             ));
    167176  (*(_Load_store_unit-> in_MEMORY_IN_DATA_RA              ))(*( in_MEMORY_IN_DATA_RA              ));
    168177  (*(_Load_store_unit-> in_MEMORY_IN_DATA_RB              ))(*( in_MEMORY_IN_DATA_RB              ));
    169   //(*(_Load_store_unit-> in_MEMORY_IN_DATA_RC              ))(*( in_MEMORY_IN_DATA_RC              ));
    170 //   (*(_Load_store_unit-> in_MEMORY_IN_WRITE_RD             ))(*( in_MEMORY_IN_WRITE_RD             ));
     178  (*(_Load_store_unit-> in_MEMORY_IN_DATA_RC              ))(*( in_MEMORY_IN_DATA_RC              ));
     179  (*(_Load_store_unit-> in_MEMORY_IN_WRITE_RD             ))(*( in_MEMORY_IN_WRITE_RD             ));
    171180  (*(_Load_store_unit-> in_MEMORY_IN_NUM_REG_RD           ))(*( in_MEMORY_IN_NUM_REG_RD           ));
    172   //(*(_Load_store_unit-> in_MEMORY_IN_WRITE_RE             ))(*( in_MEMORY_IN_WRITE_RE             ));
    173   //(*(_Load_store_unit-> in_MEMORY_IN_NUM_REG_RE           ))(*( in_MEMORY_IN_NUM_REG_RE           ));
     181  (*(_Load_store_unit-> in_MEMORY_IN_WRITE_RE             ))(*( in_MEMORY_IN_WRITE_RE             ));
     182  (*(_Load_store_unit-> in_MEMORY_IN_NUM_REG_RE           ))(*( in_MEMORY_IN_NUM_REG_RE           ));
    174183 
    175184  (*(_Load_store_unit->out_MEMORY_OUT_VAL           ))(*(out_MEMORY_OUT_VAL           ));
    … …  
    183192  if (_param->_have_port_packet_id)
    184193    (*(_Load_store_unit->out_MEMORY_OUT_PACKET_ID     ))(*(out_MEMORY_OUT_PACKET_ID     ));
     194//   (*(_Load_store_unit->out_MEMORY_OUT_OPERATION     ))(*(out_MEMORY_OUT_OPERATION     ));
     195  (*(_Load_store_unit->out_MEMORY_OUT_TYPE          ))(*(out_MEMORY_OUT_TYPE          ));
    185196  (*(_Load_store_unit->out_MEMORY_OUT_WRITE_RD      ))(*(out_MEMORY_OUT_WRITE_RD      ));
    186197  (*(_Load_store_unit->out_MEMORY_OUT_NUM_REG_RD    ))(*(out_MEMORY_OUT_NUM_REG_RD    ));
    187198  (*(_Load_store_unit->out_MEMORY_OUT_DATA_RD       ))(*(out_MEMORY_OUT_DATA_RD       ));
    188   //(*(_Load_store_unit->out_MEMORY_OUT_WRITE_RE      ))(*(out_MEMORY_OUT_WRITE_RE      ));
    189   //(*(_Load_store_unit->out_MEMORY_OUT_NUM_REG_RE    ))(*(out_MEMORY_OUT_NUM_REG_RE    ));
    190   //(*(_Load_store_unit->out_MEMORY_OUT_DATA_RE       ))(*(out_MEMORY_OUT_DATA_RE       ));
     199  (*(_Load_store_unit->out_MEMORY_OUT_WRITE_RE      ))(*(out_MEMORY_OUT_WRITE_RE      ));
     200  (*(_Load_store_unit->out_MEMORY_OUT_NUM_REG_RE    ))(*(out_MEMORY_OUT_NUM_REG_RE    ));
     201  (*(_Load_store_unit->out_MEMORY_OUT_DATA_RE       ))(*(out_MEMORY_OUT_DATA_RE       ));
    191202  (*(_Load_store_unit->out_MEMORY_OUT_EXCEPTION     ))(*(out_MEMORY_OUT_EXCEPTION     ));
     203  (*(_Load_store_unit->out_MEMORY_OUT_NO_SEQUENCE   ))(*(out_MEMORY_OUT_NO_SEQUENCE   ));
     204  (*(_Load_store_unit->out_MEMORY_OUT_ADDRESS       ))(*(out_MEMORY_OUT_ADDRESS       ));
    192205
    193206  (*(_Load_store_unit->out_DCACHE_REQ_VAL       ))(*(out_DCACHE_REQ_VAL       ));
    … …  
    208221  (*(_Load_store_unit-> in_DCACHE_RSP_ERROR     ))(*( in_DCACHE_RSP_ERROR     ));
    209222
    210   if (_param->_speculative_load == SPECULATIVE_LOAD_BYPASS)
    211223    {
    212       for (uint32_t i=0; i<_param->_size_load_queue; i++)
     224      for (uint32_t i=0; i<_param->_nb_bypass_memory; i++)
    213225        {
    214226          (*(_Load_store_unit->out_BYPASS_MEMORY_VAL           [i]))(*(out_BYPASS_MEMORY_VAL           [i]));
    … …  
    448460                  in_MEMORY_IN_TYPE                 ->write (fifo_request.top()._type                 );
    449461                  in_MEMORY_IN_STORE_QUEUE_PTR_WRITE->write (fifo_request.top()._store_queue_ptr_write);
     462                  if (_param->_have_port_load_queue_ptr)
    450463                  in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE ->write (fifo_request.top()._load_queue_ptr_write );
    451464                  in_MEMORY_IN_IMMEDIAT             ->write (fifo_request.top()._immediat             );
    … …  
    533546                  TEST(Tcontext_t        , out_MEMORY_OUT_FRONT_END_ID ->read(), tab_request[packet_id]._front_end_id );
    534547                  TEST(Tcontext_t        , out_MEMORY_OUT_OOO_ENGINE_ID->read(), tab_request[packet_id]._ooo_engine_id);
     548//                TEST(Toperation_t      , out_MEMORY_OUT_OPERATION    ->read(), tab_request[packet_id]._operation    );
     549                  TEST(Ttype_t           , out_MEMORY_OUT_TYPE         ->read(), TYPE_MEMORY                          );
    535550
    536551                  if (is_operation_memory_load (tab_request[packet_id]._operation))
    … …  
    721736  delete     in_MEMORY_IN_STORE_QUEUE_PTR_WRITE;
    722737  delete     in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE ;
    723   //delete     in_MEMORY_IN_HAS_IMMEDIAT;
     738  delete     in_MEMORY_IN_HAS_IMMEDIAT;
    724739  delete     in_MEMORY_IN_IMMEDIAT    ;
    725740  delete     in_MEMORY_IN_DATA_RA     ;
    726741  delete     in_MEMORY_IN_DATA_RB     ;
    727   //delete     in_MEMORY_IN_DATA_RC     ;
    728 //   delete     in_MEMORY_IN_WRITE_RD    ;
     742  delete     in_MEMORY_IN_DATA_RC     ;
     743  delete     in_MEMORY_IN_WRITE_RD    ;
    729744  delete     in_MEMORY_IN_NUM_REG_RD  ;
    730   //delete     in_MEMORY_IN_WRITE_RE    ;
    731   //delete     in_MEMORY_IN_NUM_REG_RE  ;
     745  delete     in_MEMORY_IN_WRITE_RE    ;
     746  delete     in_MEMORY_IN_NUM_REG_RE  ;
    732747   
    733748  delete    out_MEMORY_OUT_VAL       ;
    … …  
    737752  delete    out_MEMORY_OUT_OOO_ENGINE_ID;
    738753  delete    out_MEMORY_OUT_PACKET_ID ;
     754//   delete    out_MEMORY_OUT_OPERATION ;
     755  delete    out_MEMORY_OUT_TYPE      ;
    739756  delete    out_MEMORY_OUT_WRITE_RD  ;
    740757  delete    out_MEMORY_OUT_NUM_REG_RD;
    741758  delete    out_MEMORY_OUT_DATA_RD   ;
    742   //delete    out_MEMORY_OUT_WRITE_RE  ;
    743   //delete    out_MEMORY_OUT_NUM_REG_RE;
    744   //delete    out_MEMORY_OUT_DATA_RE   ;
     759  delete    out_MEMORY_OUT_WRITE_RE  ;
     760  delete    out_MEMORY_OUT_NUM_REG_RE;
     761  delete    out_MEMORY_OUT_DATA_RE   ;
    745762  delete    out_MEMORY_OUT_EXCEPTION ;
     763  delete    out_MEMORY_OUT_NO_SEQUENCE;
     764  delete    out_MEMORY_OUT_ADDRESS   ;
    746765 
    747766  delete    out_DCACHE_REQ_VAL       ;
    … …  
    760779  delete     in_DCACHE_RSP_ERROR     ;
    761780 
    762   if (_param->_speculative_load == SPECULATIVE_LOAD_BYPASS)
    763781    {
    764782      delete [] out_BYPASS_MEMORY_VAL       ;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/include/Load_store_unit.h

    r76 r78  
    55 * $Id$
    66 *
    7  * [ Description ]
     7 * [ Description ]
    88 *
    99 * Ce composant peut être amélioré en placant deux ptr de lecture au lieu d'un : un pour l'accès au cache et un pour le commit
    … …  
    4646#endif
    4747  {
    48     // -----[ fields ]----------------------------------------------------
     48    // -----[ fields ]----------------------------------------------------
    4949    // Parameters
    5050  protected : const std::string       _name;
    … …  
    5353
    5454#ifdef STATISTICS
    55   private   : Stat                           * _stat;
     55  public    : Stat                           * _stat;
    5656
    5757  private   : counter_t                      * _stat_use_store_queue;
    … …  
    8383
    8484#ifdef SYSTEMC
    85     // ~~~~~[ Interface ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     85    // ~~~~~[ Interface ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    8686    // Interface
    8787  public    : SC_CLOCK                      *  in_CLOCK        ;
    8888  public    : SC_IN (Tcontrol_t)            *  in_NRESET       ;
    8989
    90     // ~~~~~[ Interface "memory_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     90    // ~~~~~[ Interface "memory_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    9191  public    : SC_IN (Tcontrol_t        )    *  in_MEMORY_IN_VAL         ;
    9292  public    : SC_OUT(Tcontrol_t        )    * out_MEMORY_IN_ACK         ;
    … …  
    9696  public    : SC_IN (Tpacket_t         )    *  in_MEMORY_IN_PACKET_ID   ;
    9797  public    : SC_IN (Toperation_t      )    *  in_MEMORY_IN_OPERATION   ;
    98 //public    : SC_IN (Ttype_t           )    *  in_MEMORY_IN_TYPE        ;
     98  public    : SC_IN (Ttype_t           )    *  in_MEMORY_IN_TYPE        ;
    9999  public    : SC_IN (Tlsq_ptr_t        )    *  in_MEMORY_IN_STORE_QUEUE_PTR_WRITE;
    100100  public    : SC_IN (Tlsq_ptr_t        )    *  in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE ;
    101 //public    : SC_IN (Tcontrol_t        )    *  in_MEMORY_IN_HAS_IMMEDIAT;
     101  public    : SC_IN (Tcontrol_t        )    *  in_MEMORY_IN_HAS_IMMEDIAT;
    102102  public    : SC_IN (Tgeneral_data_t   )    *  in_MEMORY_IN_IMMEDIAT    ; // memory address
    103103  public    : SC_IN (Tgeneral_data_t   )    *  in_MEMORY_IN_DATA_RA     ; // memory address
    104104  public    : SC_IN (Tgeneral_data_t   )    *  in_MEMORY_IN_DATA_RB     ; // data        (store)
    105 //public    : SC_IN (Tspecial_data_t   )    *  in_MEMORY_IN_DATA_RC     ;
    106 //public    : SC_IN (Tcontrol_t        )    *  in_MEMORY_IN_WRITE_RD    ; // = (operation==load)
     105  public    : SC_IN (Tspecial_data_t   )    *  in_MEMORY_IN_DATA_RC     ;
     106  public    : SC_IN (Tcontrol_t        )    *  in_MEMORY_IN_WRITE_RD    ; // = (operation==load)
    107107  public    : SC_IN (Tgeneral_address_t)    *  in_MEMORY_IN_NUM_REG_RD  ; // destination (load)
    108 //public    : SC_IN (Tcontrol_t        )    *  in_MEMORY_IN_WRITE_RE    ;
    109 //public    : SC_IN (Tspecial_address_t)    *  in_MEMORY_IN_NUM_REG_RE  ;
    110 
    111     // ~~~~~[ Interface "memory_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     108  public    : SC_IN (Tcontrol_t        )    *  in_MEMORY_IN_WRITE_RE    ;
     109  public    : SC_IN (Tspecial_address_t)    *  in_MEMORY_IN_NUM_REG_RE  ;
     110
     111    // ~~~~~[ Interface "memory_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    112112  public    : SC_OUT(Tcontrol_t        )    * out_MEMORY_OUT_VAL       ;
    113113  public    : SC_IN (Tcontrol_t        )    *  in_MEMORY_OUT_ACK       ;
    … …  
    116116  public    : SC_OUT(Tcontext_t        )    * out_MEMORY_OUT_OOO_ENGINE_ID;
    117117  public    : SC_OUT(Tpacket_t         )    * out_MEMORY_OUT_PACKET_ID ;
     118//public    : SC_OUT(Toperation_t      )    * out_MEMORY_OUT_OPERATION ;
     119  public    : SC_OUT(Ttype_t           )    * out_MEMORY_OUT_TYPE      ;
    118120  public    : SC_OUT(Tcontrol_t        )    * out_MEMORY_OUT_WRITE_RD  ; // = (operation==load)
    119121  public    : SC_OUT(Tgeneral_address_t)    * out_MEMORY_OUT_NUM_REG_RD; // destination (load)
    120122  public    : SC_OUT(Tgeneral_data_t   )    * out_MEMORY_OUT_DATA_RD   ; // data        (load)
    121 //public    : SC_OUT(Tcontrol_t        )    * out_MEMORY_OUT_WRITE_RE  ;
    122 //public    : SC_OUT(Tspecial_address_t)    * out_MEMORY_OUT_NUM_REG_RE;
    123 //public    : SC_OUT(Tspecial_data_t   )    * out_MEMORY_OUT_DATA_RE   ;
     123  public    : SC_OUT(Tcontrol_t        )    * out_MEMORY_OUT_WRITE_RE  ;
     124  public    : SC_OUT(Tspecial_address_t)    * out_MEMORY_OUT_NUM_REG_RE;
     125  public    : SC_OUT(Tspecial_data_t   )    * out_MEMORY_OUT_DATA_RE   ;
    124126  public    : SC_OUT(Texception_t      )    * out_MEMORY_OUT_EXCEPTION ;
    125 
    126     // ~~~~~[ Interface "dcache_req" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     127  public    : SC_OUT(Tcontrol_t        )    * out_MEMORY_OUT_NO_SEQUENCE;
     128  public    : SC_OUT(Tgeneral_data_t   )    * out_MEMORY_OUT_ADDRESS   ;
     129   
     130
     131    // ~~~~~[ Interface "dcache_req" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    127132  public    : SC_OUT(Tcontrol_t        )    * out_DCACHE_REQ_VAL       ;
    128133  public    : SC_IN (Tcontrol_t        )    *  in_DCACHE_REQ_ACK       ;
    … …  
    133138  public    : SC_OUT(Tdcache_data_t    )    * out_DCACHE_REQ_WDATA     ;
    134139
    135     // ~~~~~[ Interface "dcache_rsp" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     140    // ~~~~~[ Interface "dcache_rsp" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    136141  public    : SC_IN (Tcontrol_t        )    *  in_DCACHE_RSP_VAL       ;
    137142  public    : SC_OUT(Tcontrol_t        )    * out_DCACHE_RSP_ACK       ;
    … …  
    141146  public    : SC_IN (Tdcache_error_t   )    *  in_DCACHE_RSP_ERROR     ;
    142147
    143     // ~~~~~[ Interface "bypass_memory" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     148    // ~~~~~[ Interface "bypass_memory" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    144149  public    : SC_OUT(Tcontrol_t        )   ** out_BYPASS_MEMORY_VAL       ;
    145150  public    : SC_OUT(Tcontext_t        )   ** out_BYPASS_MEMORY_OOO_ENGINE_ID;
    … …  
    147152  public    : SC_OUT(Tgeneral_data_t   )   ** out_BYPASS_MEMORY_DATA      ;
    148153
    149     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
     154    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    150155  protected : Tstore_queue_entry_t                                        * _store_queue;
    151156  protected : Tload_queue_entry_t                                         * _load_queue;
    … …  
    160165  public    : void (morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::Load_store_unit::*function_genMealy_retire) (void);
    161166
    162     // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    163 
    164     // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     167    // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
     168
     169    // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    165170
    166171    // Registers
    … …  
    182187#endif
    183188
    184     // -----[ methods ]---------------------------------------------------
     189    // -----[ methods ]---------------------------------------------------
    185190
    186191#ifdef SYSTEMC

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/include/Parameters.h

    r77 r78  
    3232  public : const uint32_t            _nb_port_check                ;
    3333  public : const Tspeculative_load_t _speculative_load             ;
     34  public : const uint32_t            _nb_bypass_memory             ;
    3435//public : const uint32_t            _nb_cache_port                ;
    3536  public : const uint32_t            _nb_context                   ;
    … …  
    3839  public : const uint32_t            _nb_packet                    ;
    3940  public : const uint32_t            _size_general_data            ;
     41  public : const uint32_t            _size_special_data            ;
    4042  public : const uint32_t            _nb_general_register          ;
     43  public : const uint32_t            _nb_special_register          ;
    4144
    4245  public : const uint32_t            _size_address_store_queue             ;
    … …  
    4851  public : const uint32_t            _size_packet_id                       ;
    4952  public : const uint32_t            _size_general_register                ;
     53  public : const uint32_t            _size_special_register                ;
    5054  public : const uint32_t            _size_dcache_context_id               ;
    5155  public : const uint32_t            _size_dcache_packet_id                ;
    … …  
    5660  public : const bool                _have_port_packet_id                  ;
    5761  public : const bool                _have_port_dcache_context_id          ;
     62  public : const bool                _have_port_load_queue_ptr             ;
    5863
    5964  public : const Tdcache_address_t   _mask_address_lsb                     ;
    … …  
    6671                        uint32_t            nb_port_check          ,
    6772                        Tspeculative_load_t speculative_load       ,
     73                        uint32_t            nb_bypass_memory       ,
    6874                        uint32_t            nb_context             ,
    6975                        uint32_t            nb_front_end           ,
    … …  
    7177                        uint32_t            nb_packet              ,
    7278                        uint32_t            size_general_data      ,
    73                         uint32_t            nb_general_register    );
     79                        uint32_t            size_special_data      ,
     80                        uint32_t            nb_general_register    ,
     81                        uint32_t            nb_special_register    );
    7482
    7583  public : Parameters  (Parameters & param) ;
    7684  public : ~Parameters () ;
    7785
    78   public : std::string msg_error (void);
     86  public : Parameters_test msg_error (void);
    7987
    8088  public :        std::string   print      (uint32_t depth);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/include/Types.h

    r71 r78  
    3333  typedef enum
    3434    {
    35       NO_SPECULATIVE_LOAD    , //each load wait all previous store before the data cache access
    36       SPECULATIVE_LOAD_ACCESS, //each load wait all previous store before the commiting
    37       SPECULATIVE_LOAD_COMMIT, //each load commit the result before the end of dependence's check
    38       SPECULATIVE_LOAD_BYPASS //each load bypass the result before the end of dependence's check
     35       NO_SPECULATIVE_LOAD    //each load wait all previous store before the data cache access
     36      ,SPECULATIVE_LOAD_ACCESS //each load wait all previous store before the commiting
     37      ,SPECULATIVE_LOAD_COMMIT //each load commit the result before the end of dependence's check
     38    //,SPECULATIVE_LOAD_BYPASS //each load bypass the result before the end of dependence's check
    3939    } Tspeculative_load_t;
    4040 
    … …  
    212212      case morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::SPECULATIVE_LOAD_ACCESS : return "speculative_load_access"; break;
    213213      case morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::SPECULATIVE_LOAD_COMMIT : return "speculative_load_commit"; break;
    214       case morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::SPECULATIVE_LOAD_BYPASS : return "speculative_load_bypass"; break;
     214//       case morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::SPECULATIVE_LOAD_BYPASS : return "speculative_load_bypass"; break;
    215215      default    : return ""      ; break;
    216216      }
    … …  
    228228         (x.compare("speculative_load_commit") == 0))
    229229      return morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::SPECULATIVE_LOAD_COMMIT;
    230     if ( (x.compare("3")                       == 0) or
    231          (x.compare("speculative_load_bypass") == 0))
    232       return morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::SPECULATIVE_LOAD_BYPASS;
     230//     if ( (x.compare("3")                       == 0) or
     231//          (x.compare("speculative_load_bypass") == 0))
     232//       return morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::SPECULATIVE_LOAD_BYPASS;
    233233   
    234234    throw (ErrorMorpheo ("<fromString> : Unknow string : \""+x+"\""));

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Load_store_unit.cpp

    r71 r78  
    6969      case NO_SPECULATIVE_LOAD     :
    7070      case SPECULATIVE_LOAD_ACCESS :
    71       case SPECULATIVE_LOAD_BYPASS :
     71        //case SPECULATIVE_LOAD_BYPASS :
    7272      default                      :
    7373        {

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Load_store_unit_allocation.cpp

    r75 r78  
    7272   in_MEMORY_IN_PACKET_ID             = interface->set_signal_in  <Tpacket_t         > ("packet_id"    ,_param->_size_packet_id       );
    7373   in_MEMORY_IN_OPERATION             = interface->set_signal_in  <Toperation_t      > ("operation"   ,_param->_size_operation        );
     74   in_MEMORY_IN_TYPE                  = interface->set_signal_in  <Ttype_t           > ("type"        ,_param->_size_type             );
    7475   in_MEMORY_IN_STORE_QUEUE_PTR_WRITE = interface->set_signal_in  <Tlsq_ptr_t        > ("store_queue_ptr_write" ,_param->_size_address_store_queue+1); // +1 cf load_queue usage
     76   if (_param->_have_port_load_queue_ptr)
    7577   in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE  = interface->set_signal_in  <Tlsq_ptr_t        > ("load_queue_ptr_write"  ,_param->_size_address_load_queue );
    76 // in_MEMORY_IN_HAS_IMMEDIAT          = interface->set_signal_in  <Tcontrol_t        > ("has_immediat",1                              );
     78  in_MEMORY_IN_HAS_IMMEDIAT          = interface->set_signal_in  <Tcontrol_t        > ("has_immediat",1                              );
    7779   in_MEMORY_IN_IMMEDIAT              = interface->set_signal_in  <Tgeneral_data_t   > ("immediat"    ,_param->_size_general_data     );
    7880   in_MEMORY_IN_DATA_RA               = interface->set_signal_in  <Tgeneral_data_t   > ("data_ra"     ,_param->_size_general_data     );
    7981   in_MEMORY_IN_DATA_RB               = interface->set_signal_in  <Tgeneral_data_t   > ("data_rb"     ,_param->_size_general_data     );
    80 // in_MEMORY_IN_DATA_RC               = interface->set_signal_in  <Tspecial_data_t   > ("data_rc"     ,_param->_size_special_data     );
    81 //    in_MEMORY_IN_WRITE_RD              = interface->set_signal_in  <Tcontrol_t        > ("write_rd"    ,1                              );
     82  in_MEMORY_IN_DATA_RC               = interface->set_signal_in  <Tspecial_data_t   > ("data_rc"     ,_param->_size_special_data     );
     83   in_MEMORY_IN_WRITE_RD              = interface->set_signal_in  <Tcontrol_t        > ("write_rd"    ,1                              );
    8284   in_MEMORY_IN_NUM_REG_RD            = interface->set_signal_in  <Tgeneral_address_t> ("num_reg_rd"  ,1                              );
    83 // in_MEMORY_IN_WRITE_RE              = interface->set_signal_in  <Tcontrol_t        > ("write_re"    ,1                              );
    84 // in_MEMORY_IN_NUM_REG_RE            = interface->set_signal_in  <Tspecial_address_t> ("num_reg_re"  ,1                              );
     85  in_MEMORY_IN_WRITE_RE              = interface->set_signal_in  <Tcontrol_t        > ("write_re"    ,1                              );
     86  in_MEMORY_IN_NUM_REG_RE            = interface->set_signal_in  <Tspecial_address_t> ("num_reg_re"  ,1                              );
    8587    }
    8688
    … …  
    105107      if (_param->_have_port_packet_id)       
    106108      out_MEMORY_OUT_PACKET_ID     = interface->set_signal_out <Tpacket_t         > ("packet_id"     ,_param->_size_packet_id        );
     109//    out_MEMORY_OUT_OPERATION     = interface->set_signal_out <Toperation_t      > ("operation"     ,_param->_size_operation        );
     110      out_MEMORY_OUT_TYPE          = interface->set_signal_out <Ttype_t           > ("type"          ,_param->_size_type             );
    107111      out_MEMORY_OUT_WRITE_RD      = interface->set_signal_out <Tcontrol_t        > ("write_rd"      ,1                              );
    108112      out_MEMORY_OUT_NUM_REG_RD    = interface->set_signal_out <Tgeneral_address_t> ("num_reg_rd"    ,_param->_size_general_register );
    109113      out_MEMORY_OUT_DATA_RD       = interface->set_signal_out <Tgeneral_data_t   > ("data_rd"       ,_param->_size_general_data     );
    110 //    out_MEMORY_OUT_WRITE_RE      = interface->set_signal_out <Tcontrol_t        > ("write_rd"      ,1                              );
    111 //    out_MEMORY_OUT_NUM_REG_RE    = interface->set_signal_out <Tspecial_address_t> ("num_reg_re"    ,_param->_size_general_register );
    112 //    out_MEMORY_OUT_DATA_RE       = interface->set_signal_out <Tspecial_data_t   > ("data_re"       ,_param->_size_general_data     );
     114      out_MEMORY_OUT_WRITE_RE      = interface->set_signal_out <Tcontrol_t        > ("write_re"      ,1                              );
     115      out_MEMORY_OUT_NUM_REG_RE    = interface->set_signal_out <Tspecial_address_t> ("num_reg_re"    ,_param->_size_general_register );
     116      out_MEMORY_OUT_DATA_RE       = interface->set_signal_out <Tspecial_data_t   > ("data_re"       ,_param->_size_general_data     );
    113117      out_MEMORY_OUT_EXCEPTION     = interface->set_signal_out <Texception_t      > ("exception"     ,_param->_size_exception        );
     118      out_MEMORY_OUT_NO_SEQUENCE   = interface->set_signal_out <Tcontrol_t        > ("no_sequence"   ,1                              );
     119      out_MEMORY_OUT_ADDRESS       = interface->set_signal_out <Tgeneral_data_t   > ("address"       ,_param->_size_general_data     );
    114120    }
    115121
    … …  
    153159    // ~~~~~[ Interface "bypass_memory" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    154160
    155     if (_param->_speculative_load == SPECULATIVE_LOAD_BYPASS)
     161//  if (_param->_speculative_load == SPECULATIVE_LOAD_BYPASS)
    156162      {
    157         out_BYPASS_MEMORY_VAL          = new SC_OUT(Tcontrol_t        ) * [_param->_size_load_queue];
     163        out_BYPASS_MEMORY_VAL          = new SC_OUT(Tcontrol_t        ) * [_param->_nb_bypass_memory];
    158164        if (_param->_have_port_ooo_engine_id)   
    159         out_BYPASS_MEMORY_OOO_ENGINE_ID= new SC_OUT(Tcontext_t        ) * [_param->_size_load_queue];
    160         out_BYPASS_MEMORY_NUM_REG      = new SC_OUT(Tgeneral_address_t) * [_param->_size_load_queue];
    161         out_BYPASS_MEMORY_DATA         = new SC_OUT(Tgeneral_data_t   ) * [_param->_size_load_queue];
     165        out_BYPASS_MEMORY_OOO_ENGINE_ID= new SC_OUT(Tcontext_t        ) * [_param->_nb_bypass_memory];
     166        out_BYPASS_MEMORY_NUM_REG      = new SC_OUT(Tgeneral_address_t) * [_param->_nb_bypass_memory];
     167        out_BYPASS_MEMORY_DATA         = new SC_OUT(Tgeneral_data_t   ) * [_param->_nb_bypass_memory];
    162168       
    163         for (uint32_t i=0; i<_param->_size_load_queue; i++)
     169        for (uint32_t i=0; i<_param->_nb_bypass_memory; i++)
    164170          {
    165171            Interface_fifo * interface = _interfaces->set_interface("memory_out"

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Load_store_unit_deallocation.cpp

    r71 r78  
    4444    delete     in_MEMORY_IN_PACKET_ID   ;
    4545    delete     in_MEMORY_IN_OPERATION   ;
     46    delete     in_MEMORY_IN_TYPE        ;
    4647    delete     in_MEMORY_IN_STORE_QUEUE_PTR_WRITE;
     48    if (_param->_have_port_load_queue_ptr)
    4749    delete     in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE ;
    48 //  delete     in_MEMORY_IN_HAS_IMMEDIAT;
     50    delete     in_MEMORY_IN_HAS_IMMEDIAT;
    4951    delete     in_MEMORY_IN_IMMEDIAT    ;
    5052    delete     in_MEMORY_IN_DATA_RA     ;
    5153    delete     in_MEMORY_IN_DATA_RB     ;
    52 //  delete     in_MEMORY_IN_DATA_RC     ;
    53 //  delete     in_MEMORY_IN_WRITE_RD    ;
     54    delete     in_MEMORY_IN_DATA_RC     ;
     55    delete     in_MEMORY_IN_WRITE_RD    ;
    5456    delete     in_MEMORY_IN_NUM_REG_RD  ;
    55 //  delete     in_MEMORY_IN_WRITE_RE    ;
    56 //  delete     in_MEMORY_IN_NUM_REG_RE  ;
     57    delete     in_MEMORY_IN_WRITE_RE    ;
     58    delete     in_MEMORY_IN_NUM_REG_RE  ;
    5759   
    5860    delete    out_MEMORY_OUT_VAL       ;
    … …  
    6668    if (_param->_have_port_packet_id)
    6769    delete    out_MEMORY_OUT_PACKET_ID ;
     70//  delete    out_MEMORY_OUT_OPERATION ;
     71    delete    out_MEMORY_OUT_TYPE      ;
    6872    delete    out_MEMORY_OUT_WRITE_RD  ;
    6973    delete    out_MEMORY_OUT_NUM_REG_RD;
    7074    delete    out_MEMORY_OUT_DATA_RD   ;
    71 //  delete    out_MEMORY_OUT_WRITE_RE  ;
    72 //  delete    out_MEMORY_OUT_NUM_REG_RE;
    73 //  delete    out_MEMORY_OUT_DATA_RE   ;
     75    delete    out_MEMORY_OUT_WRITE_RE  ;
     76    delete    out_MEMORY_OUT_NUM_REG_RE;
     77    delete    out_MEMORY_OUT_DATA_RE   ;
    7478    delete    out_MEMORY_OUT_EXCEPTION ;
     79    delete    out_MEMORY_OUT_NO_SEQUENCE;
     80    delete    out_MEMORY_OUT_ADDRESS   ;
    7581   
    7682    delete    out_DCACHE_REQ_VAL       ;
    … …  
    9197    delete     in_DCACHE_RSP_ERROR     ;
    9298   
    93     if (_param->_speculative_load == SPECULATIVE_LOAD_BYPASS)
    94       {
    95         delete [] out_BYPASS_MEMORY_VAL       ;
    96         if (_param->_have_port_ooo_engine_id)   
    97         delete [] out_BYPASS_MEMORY_OOO_ENGINE_ID;
    98         delete [] out_BYPASS_MEMORY_NUM_REG   ;
    99         delete [] out_BYPASS_MEMORY_DATA      ;
    100       }
     99    delete [] out_BYPASS_MEMORY_VAL       ;
     100    if (_param->_have_port_ooo_engine_id)   
     101    delete [] out_BYPASS_MEMORY_OOO_ENGINE_ID;
     102    delete [] out_BYPASS_MEMORY_NUM_REG   ;
     103    delete [] out_BYPASS_MEMORY_DATA      ;
    101104    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    102105

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Load_store_unit_function_speculative_load_commit_genMoore.cpp

    r71 r78  
    120120    if (_param->_have_port_packet_id)
    121121    PORT_WRITE(out_MEMORY_OUT_PACKET_ID    , memory_out_packet_id    );
     122//  PORT_WRITE(out_MEMORY_OUT_OPERATION    , memory_out_operation    );
     123    PORT_WRITE(out_MEMORY_OUT_TYPE         , TYPE_MEMORY             );
    122124    PORT_WRITE(out_MEMORY_OUT_WRITE_RD     , memory_out_write_rd     );
    123125    PORT_WRITE(out_MEMORY_OUT_NUM_REG_RD   , memory_out_num_reg_rd   );
    … …  
    126128//  PORT_WRITE(out_MEMORY_OUT_NUM_REG_RE   , memory_out_num_reg_re   );
    127129//  PORT_WRITE(out_MEMORY_OUT_DATA_RE      , memory_out_data_re      );
     130    PORT_WRITE(out_MEMORY_OUT_WRITE_RE     , 0);
     131    PORT_WRITE(out_MEMORY_OUT_NUM_REG_RE   , 0);
     132    PORT_WRITE(out_MEMORY_OUT_DATA_RE      , 0);
    128133    PORT_WRITE(out_MEMORY_OUT_EXCEPTION    , memory_out_exception    );
    129 
     134    PORT_WRITE(out_MEMORY_OUT_NO_SEQUENCE  , 0);
     135    PORT_WRITE(out_MEMORY_OUT_ADDRESS      , 0);
    130136    // ~~~~~[ Interface "dache_req" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    131137

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Load_store_unit_function_speculative_load_commit_transition.cpp

    r75 r78  
    265265            //  others in speculation_access_queue
    266266
     267#ifdef DEBUG_TEST
     268            if (PORT_READ(in_MEMORY_IN_TYPE) != TYPE_MEMORY)
     269              throw ERRORMORPHEO(FUNCTION,"The type is different at 'TYPE_MEMORY'");
     270#endif
    267271            Toperation_t    operation            = PORT_READ(in_MEMORY_IN_OPERATION);
    268272            Tgeneral_data_t address              = (PORT_READ(in_MEMORY_IN_IMMEDIAT) +
    … …  
    376380                    _store_queue [index]._packet_id            = (not _param->_have_port_packet_id    )?0:PORT_READ(in_MEMORY_IN_PACKET_ID   );
    377381                    _store_queue [index]._operation            = operation;
    378                     _store_queue [index]._load_queue_ptr_write = PORT_READ(in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE);
     382                    _store_queue [index]._load_queue_ptr_write = (not _param->_have_port_load_queue_ptr)?0:PORT_READ(in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE);
    379383                    _store_queue [index]._address              = address;
    380384
    … …  
    415419
    416420                _speculative_access_queue [index]._operation            = operation;
    417                 _speculative_access_queue [index]._load_queue_ptr_write = PORT_READ(in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE);
     421                _speculative_access_queue [index]._load_queue_ptr_write = (not _param->_have_port_load_queue_ptr)?0:PORT_READ(in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE);
    418422                _speculative_access_queue [index]._store_queue_ptr_write= PORT_READ(in_MEMORY_IN_STORE_QUEUE_PTR_WRITE);
    419423                _speculative_access_queue [index]._address              = address;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Parameters.cpp

    r77 r78  
    2525                          uint32_t            nb_port_check          ,
    2626                          Tspeculative_load_t speculative_load       ,
     27                          uint32_t            nb_bypass_memory       ,
    2728                          uint32_t            nb_context             ,
    2829                          uint32_t            nb_front_end           ,
    … …  
    3031                          uint32_t            nb_packet              ,
    3132                          uint32_t            size_general_data      ,
    32                           uint32_t            nb_general_register    ):
     33                          uint32_t            size_special_data      ,
     34                          uint32_t            nb_general_register    ,
     35                          uint32_t            nb_special_register    ):
    3336    _size_store_queue        (size_store_queue       ),
    3437    _size_load_queue         (size_load_queue        ),
    … …  
    3639    _nb_port_check           (nb_port_check          ),
    3740    _speculative_load        (speculative_load       ),
     41    _nb_bypass_memory        (nb_bypass_memory       ),
    3842    _nb_context              (nb_context             ),
    3943    _nb_front_end            (nb_front_end           ),
    … …  
    4145    _nb_packet               (nb_packet              ),
    4246    _size_general_data       (size_general_data      ),
     47    _size_special_data       (size_special_data      ),
    4348    _nb_general_register     (nb_general_register    ),
     49    _nb_special_register     (nb_special_register    ),
    4450   
    4551    _size_address_store_queue              (log2(size_store_queue             )),
    … …  
    5258    _size_packet_id          (log2(nb_packet          )),
    5359    _size_general_register   (log2(nb_general_register)),
     60    _size_special_register   (log2(nb_special_register)),
    5461    _size_dcache_context_id  (_size_context_id + _size_front_end_id + _size_ooo_engine_id),
    5562    _size_dcache_packet_id   ((log2((size_store_queue>size_load_queue)?size_store_queue:size_load_queue))+1),
    … …  
    6067    _have_port_packet_id         (_size_packet_id    >0),
    6168    _have_port_dcache_context_id (_size_dcache_context_id>0),
     69    _have_port_load_queue_ptr    (_size_load_queue>1),
    6270
    6371    _mask_address_lsb            (gen_mask<Tdcache_address_t>(log2(size_general_data/8))),
    … …  
    7785    _nb_port_check           (param._nb_port_check          ),
    7886    _speculative_load        (param._speculative_load       ),
     87    _nb_bypass_memory        (param._nb_bypass_memory       ),
    7988    _nb_context              (param._nb_context             ),
    8089    _nb_front_end            (param._nb_front_end           ),
    … …  
    8291    _nb_packet               (param._nb_packet              ),
    8392    _size_general_data       (param._size_general_data      ),
     93    _size_special_data       (param._size_special_data      ),
    8494    _nb_general_register     (param._nb_general_register    ),
     95    _nb_special_register     (param._nb_special_register    ),
    8596
    8697    _size_address_store_queue              (param._size_address_store_queue             ),
    … …  
    93104    _size_packet_id          (param._size_packet_id         ),
    94105    _size_general_register   (param._size_general_register  ),
     106    _size_special_register   (param._size_special_register  ),
    95107    _size_dcache_context_id  (param._size_dcache_context_id ),
    96108    _size_dcache_packet_id   (param._size_dcache_packet_id  ),
    … …  
    100112    _have_port_ooo_engine_id (param._have_port_ooo_engine_id),
    101113    _have_port_packet_id     (param._have_port_packet_id    ),
    102 
    103114    _have_port_dcache_context_id(param._have_port_dcache_context_id),
     115    _have_port_load_queue_ptr(param._have_port_load_queue_ptr),
    104116
    105117    _mask_address_lsb        (param._mask_address_lsb),

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Parameters_msg_error.cpp

    r71 r78  
    2121#undef  FUNCTION
    2222#define FUNCTION "Load_store_unit::msg_error"
    23   std::string Parameters::msg_error(void)
     23  Parameters_test Parameters::msg_error(void)
    2424  {
    2525    log_printf(FUNC,Load_store_unit,FUNCTION,"Begin");
    2626   
    27     std::string msg = "";
     27    Parameters_test test("Load_store_unit");
    2828
    2929    switch (_speculative_load)
    … …  
    3131      case SPECULATIVE_LOAD_COMMIT :
    3232        {
     33          if (not (_nb_bypass_memory == 0))
     34            test.error("Bypass memory is not supported. Please wait a next revision.");
     35 
    3336          break;
    3437        }
    3538      case NO_SPECULATIVE_LOAD     :
    3639      case SPECULATIVE_LOAD_ACCESS :
    37       case SPECULATIVE_LOAD_BYPASS :
     40      // case SPECULATIVE_LOAD_BYPASS :
    3841      default                      :
    3942        {
    40           msg += "  - Speculative load scheme is not supported : " +toString(_speculative_load);
     43          if (not (_nb_bypass_memory == 0))
     44            test.error("In the load scheme '"+toString(_speculative_load)+"', they have none bypass.");
     45
     46          test.error("Speculative load scheme '"+toString(_speculative_load)+"' is not supported. Please wait a next revision.");
    4147          break;
    4248        }
    4349      }
    4450
    45     return msg;
     51    if (not (_size_store_queue >= 2))
     52      test.error("Store queue must have at less two slot.");
     53
     54    if (not (_nb_bypass_memory <= _size_load_queue))
     55      test.error("Bypass number must be less than load_queue's size.");
    4656
    4757    log_printf(FUNC,Load_store_unit,FUNCTION,"End");
     58
     59    return test;
     60
    4861  };
    4962

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Parameters_print.cpp

    r77 r78  
    3333    xml.singleton_begin("nb_port_check                "); xml.attribut("value",toString(_nb_port_check                )); xml.singleton_end();
    3434    xml.singleton_begin("speculative_load             "); xml.attribut("value",toString(_speculative_load             )); xml.singleton_end();
     35    xml.singleton_begin("nb_bypass_memory             "); xml.attribut("value",toString(_nb_bypass_memory             )); xml.singleton_end();
    3536    xml.singleton_begin("nb_context                   "); xml.attribut("value",toString(_nb_context                   )); xml.singleton_end();
    3637    xml.singleton_begin("nb_front_end                 "); xml.attribut("value",toString(_nb_front_end                 )); xml.singleton_end();
Note: See TracChangeset for help on using the changeset viewer.