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
Files:
1057 added
2 deleted
83 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();

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/SelfTest/config0.cfg

    r77 r78  
    12122       2       *2      # nb_spr_write
    13134       4       *2      # size_store_queue
    14 4       4       *2      # size_load_queue   
     141       4       *4      # size_load_queue   

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/SelfTest/src/test.cpp

    r76 r78  
    231231  (*(_Read_queue-> in_READ_QUEUE_IN_TYPE           )) (*(READ_QUEUE_IN_TYPE           ));
    232232  (*(_Read_queue-> in_READ_QUEUE_IN_STORE_QUEUE_PTR_WRITE)) (*(READ_QUEUE_IN_STORE_QUEUE_PTR_WRITE));
     233  if (_param->_have_port_load_queue_ptr)
    233234  (*(_Read_queue-> in_READ_QUEUE_IN_LOAD_QUEUE_PTR_WRITE )) (*(READ_QUEUE_IN_LOAD_QUEUE_PTR_WRITE ));
    234235  (*(_Read_queue-> in_READ_QUEUE_IN_HAS_IMMEDIAT   )) (*(READ_QUEUE_IN_HAS_IMMEDIAT   ));
    … …  
    258259  (*(_Read_queue->out_READ_QUEUE_OUT_TYPE          )) (*(READ_QUEUE_OUT_TYPE          ));
    259260  (*(_Read_queue->out_READ_QUEUE_OUT_STORE_QUEUE_PTR_WRITE)) (*(READ_QUEUE_OUT_STORE_QUEUE_PTR_WRITE));
     261  if (_param->_have_port_load_queue_ptr)
    260262  (*(_Read_queue->out_READ_QUEUE_OUT_LOAD_QUEUE_PTR_WRITE )) (*(READ_QUEUE_OUT_LOAD_QUEUE_PTR_WRITE ));
    261263  (*(_Read_queue->out_READ_QUEUE_OUT_HAS_IMMEDIAT  )) (*(READ_QUEUE_OUT_HAS_IMMEDIAT  ));
    … …  
    417419              READ_QUEUE_IN_TYPE        ->write(0);
    418420              READ_QUEUE_IN_STORE_QUEUE_PTR_WRITE->write(0);
     421              if (_param->_have_port_load_queue_ptr)
    419422              READ_QUEUE_IN_LOAD_QUEUE_PTR_WRITE ->write(0);
    420423              READ_QUEUE_IN_HAS_IMMEDIAT->write(0);
    … …  
    592595   delete    READ_QUEUE_IN_TYPE         ;
    593596   delete    READ_QUEUE_IN_STORE_QUEUE_PTR_WRITE;
     597   if (_param->_have_port_load_queue_ptr)
    594598   delete    READ_QUEUE_IN_LOAD_QUEUE_PTR_WRITE ;
    595599   delete    READ_QUEUE_IN_HAS_IMMEDIAT ;
    … …  
    619623   delete    READ_QUEUE_OUT_TYPE        ;
    620624   delete    READ_QUEUE_OUT_STORE_QUEUE_PTR_WRITE;
     625   if (_param->_have_port_load_queue_ptr)
    621626   delete    READ_QUEUE_OUT_LOAD_QUEUE_PTR_WRITE ;
    622627   delete    READ_QUEUE_OUT_HAS_IMMEDIAT;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/include/Parameters.h

    r77 r78  
    5555  public : const bool        _have_port_ooo_engine_id;
    5656  public : const bool        _have_port_rob_id       ;
     57  public : const bool        _have_port_load_queue_ptr;
    5758
    5859  public : const uint32_t    _size_internal_queue;
    … …  
    7677  public : ~Parameters () ;
    7778
    78   public : std::string          msg_error (void);
     79  public : Parameters_test      msg_error (void);
    7980
    8081  public :        std::string   print      (uint32_t depth);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Parameters.cpp

    r77 r78  
    5858    _have_port_ooo_engine_id (_size_ooo_engine_id > 0),
    5959    _have_port_rob_id        (_size_rob_id        > 0),
     60    _have_port_load_queue_ptr(_size_load_queue    > 1),
    6061
    6162    _size_internal_queue     (  _size_context_id       //_context_id   
    … …  
    116117    _have_port_ooo_engine_id (param._have_port_ooo_engine_id),
    117118    _have_port_rob_id        (param._have_port_rob_id       ),
     119    _have_port_load_queue_ptr(param._have_port_load_queue_ptr),
    118120
    119121    _size_internal_queue     (param._size_internal_queue    )

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Parameters_msg_error.cpp

    r75 r78  
    1919
    2020
    21   std::string Parameters::msg_error(void)
     21  Parameters_test Parameters::msg_error(void)
    2222  {
    2323    log_printf(FUNC,Read_queue,"msg_error","Begin");
    2424
    25     std::string msg = "";
    26 
    27 //     if (_size_queue < 2)
    28 //       {
    29 //         msg += "  - The read_queue must be have less a depth of 2";
    30 //         msg += "    * size_queue                      : " + toString(_size_queue)    + "\n";
    31 //       }
     25    Parameters_test test ("Read_queue");
    3226
    3327    if (_nb_type < 2)
    34       {
    35         msg += "  - The number of type must be > 1";
    36       }
     28      test.error("The number of type must be > 1");
     29
    3730    if (_nb_operation < 2)
    38       {
    39         msg += "  - The number of operation must be > 1";
    40       }
    41    
    42 
    43     return msg;
     31      test.error("The number of operation must be > 1");
    4432
    4533    log_printf(FUNC,Read_queue,"msg_error","End");
     34
     35    return test;
    4636  };
    4737

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_allocation.cpp

    r76 r78  
    7171       in_READ_QUEUE_IN_TYPE           = interface->set_signal_in  <Ttype_t           > ("type"        ,_param->_size_type             );
    7272       in_READ_QUEUE_IN_STORE_QUEUE_PTR_WRITE = interface->set_signal_in  <Tlsq_ptr_t> ("store_queue_ptr_write", log2(_param->_size_store_queue));
     73       if (_param->_have_port_load_queue_ptr)
    7374       in_READ_QUEUE_IN_LOAD_QUEUE_PTR_WRITE  = interface->set_signal_in  <Tlsq_ptr_t> ("load_queue_ptr_write" , log2(_param->_size_load_queue ));
    7475       in_READ_QUEUE_IN_HAS_IMMEDIAT   = interface->set_signal_in  <Tcontrol_t        > ("has_immediat",1                             );
    … …  
    110111      out_READ_QUEUE_OUT_TYPE           = interface->set_signal_out <Ttype_t           > ("type"        ,_param->_size_type             );
    111112      out_READ_QUEUE_OUT_STORE_QUEUE_PTR_WRITE = interface->set_signal_out <Tlsq_ptr_t> ("store_queue_ptr_write", log2(_param->_size_store_queue));
     113      if (_param->_have_port_load_queue_ptr)
    112114      out_READ_QUEUE_OUT_LOAD_QUEUE_PTR_WRITE  = interface->set_signal_out <Tlsq_ptr_t> ("load_queue_ptr_write" , log2(_param->_size_load_queue ));
    113115      out_READ_QUEUE_OUT_HAS_IMMEDIAT   = interface->set_signal_out <Tcontrol_t        > ("has_immediat",1                             );

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_deallocation.cpp

    r76 r78  
    4242    delete     in_READ_QUEUE_IN_TYPE           ;
    4343    delete     in_READ_QUEUE_IN_STORE_QUEUE_PTR_WRITE;
     44    if (_param->_have_port_load_queue_ptr)
    4445    delete     in_READ_QUEUE_IN_LOAD_QUEUE_PTR_WRITE ;
    4546    delete     in_READ_QUEUE_IN_HAS_IMMEDIAT   ;
    … …  
    7172    delete    out_READ_QUEUE_OUT_TYPE           ;
    7273    delete    out_READ_QUEUE_OUT_STORE_QUEUE_PTR_WRITE;
     74    if (_param->_have_port_load_queue_ptr)
    7375    delete    out_READ_QUEUE_OUT_LOAD_QUEUE_PTR_WRITE ;
    7476    delete    out_READ_QUEUE_OUT_HAS_IMMEDIAT   ;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_genMoore.cpp

    r76 r78  
    4444    PORT_WRITE (out_READ_QUEUE_OUT_TYPE        , _queue_head->_type        );
    4545    PORT_WRITE (out_READ_QUEUE_OUT_STORE_QUEUE_PTR_WRITE, _queue_head->_store_queue_ptr_write);
     46    if (_param->_have_port_load_queue_ptr)
    4647    PORT_WRITE (out_READ_QUEUE_OUT_LOAD_QUEUE_PTR_WRITE , _queue_head->_load_queue_ptr_write );
    4748    PORT_WRITE (out_READ_QUEUE_OUT_HAS_IMMEDIAT, _queue_head->_has_immediat);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_transition.cpp

    r76 r78  
    6767            entry->_type         = PORT_READ(in_READ_QUEUE_IN_TYPE        );
    6868            entry->_store_queue_ptr_write = PORT_READ(in_READ_QUEUE_IN_STORE_QUEUE_PTR_WRITE);
     69            if (_param->_have_port_load_queue_ptr)
    6970            entry->_load_queue_ptr_write  = PORT_READ(in_READ_QUEUE_IN_LOAD_QUEUE_PTR_WRITE );
    7071            entry->_has_immediat = PORT_READ(in_READ_QUEUE_IN_HAS_IMMEDIAT);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/SelfTest/configuration_multi_port_write.cfg

    r77 r78  
    15150       0       *2      # nb_bypass_memory
    16164       4       *2      # size_store_queue
    17 4       4       *2      # size_load_queue
     171       4       *4      # size_load_queue

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/SelfTest/src/test.cpp

    r76 r78  
    216216  (*(_Reservation_station-> in_INSERT_TYPE             )) (*( in_INSERT_TYPE             ));
    217217  (*(_Reservation_station-> in_INSERT_STORE_QUEUE_PTR_WRITE)) (*( in_INSERT_STORE_QUEUE_PTR_WRITE));
     218  if (_param->_have_port_load_queue_ptr)
    218219  (*(_Reservation_station-> in_INSERT_LOAD_QUEUE_PTR_WRITE )) (*( in_INSERT_LOAD_QUEUE_PTR_WRITE ));
    219220  (*(_Reservation_station-> in_INSERT_HAS_IMMEDIAT     )) (*( in_INSERT_HAS_IMMEDIAT     ));
    … …  
    251252  (*(_Reservation_station->out_RETIRE_TYPE           [i])) (*(out_RETIRE_TYPE           [i]));
    252253  (*(_Reservation_station->out_RETIRE_STORE_QUEUE_PTR_WRITE [i])) (*(out_RETIRE_STORE_QUEUE_PTR_WRITE [i]));
     254  if (_param->_have_port_load_queue_ptr)
    253255  (*(_Reservation_station->out_RETIRE_LOAD_QUEUE_PTR_WRITE  [i])) (*(out_RETIRE_LOAD_QUEUE_PTR_WRITE  [i]));
    254256  (*(_Reservation_station->out_RETIRE_HAS_IMMEDIAT   [i])) (*(out_RETIRE_HAS_IMMEDIAT   [i]));
    … …  
    446448              in_INSERT_TYPE        ->write(0);
    447449              in_INSERT_STORE_QUEUE_PTR_WRITE->write(0);
     450              if (_param->_have_port_load_queue_ptr)
    448451              in_INSERT_LOAD_QUEUE_PTR_WRITE ->write(0);
    449452              in_INSERT_HAS_IMMEDIAT->write(0);
    … …  
    692695  delete     in_INSERT_TYPE        ;
    693696  delete     in_INSERT_STORE_QUEUE_PTR_WRITE;
     697  if (_param->_have_port_load_queue_ptr)
    694698  delete     in_INSERT_LOAD_QUEUE_PTR_WRITE ;
    695699  delete     in_INSERT_HAS_IMMEDIAT;
    … …  
    725729  delete [] out_RETIRE_TYPE        ;
    726730  delete [] out_RETIRE_STORE_QUEUE_PTR_WRITE;
     731  if (_param->_have_port_load_queue_ptr)
    727732  delete [] out_RETIRE_LOAD_QUEUE_PTR_WRITE ;
    728733  delete [] out_RETIRE_HAS_IMMEDIAT;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/include/Parameters.h

    r77 r78  
    6262  public : const bool        _have_port_ooo_engine_id;
    6363  public : const bool        _have_port_rob_id       ;
     64  public : const bool        _have_port_load_queue_ptr;
    6465
    6566    //-----[ methods ]-----------------------------------------------------------
    … …  
    8485  public : ~Parameters () ;
    8586
    86   public :        std::string  msg_error  (void);
     87  public :        Parameters_test msg_error  (void);
    8788
    8889  public :        std::string   print      (uint32_t depth);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/src/Parameters.cpp

    r77 r78  
    6363    _have_port_front_end_id  (_size_front_end_id  > 0),
    6464    _have_port_ooo_engine_id (_size_ooo_engine_id > 0),
    65     _have_port_rob_id        (_size_rob_id        > 0)
     65    _have_port_rob_id        (_size_rob_id        > 0),
     66    _have_port_load_queue_ptr(_size_load_queue    > 1)
    6667  {
    6768    log_printf(FUNC,Reservation_station,FUNCTION,"Begin");
    … …  
    100101    _have_port_front_end_id  (param._have_port_front_end_id ),
    101102    _have_port_ooo_engine_id (param._have_port_ooo_engine_id),
    102     _have_port_rob_id        (param._have_port_rob_id       )
     103    _have_port_rob_id        (param._have_port_rob_id       ),
     104    _have_port_load_queue_ptr(param._have_port_load_queue_ptr)
    103105  {
    104106    log_printf(FUNC,Reservation_station,FUNCTION,"Begin");

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/src/Parameters_msg_error.cpp

    r75 r78  
    2121#undef  FUNCTION
    2222#define FUNCTION "Reservation_station::msg_error"
    23   std::string Parameters::msg_error(void)
     23  Parameters_test Parameters::msg_error(void)
    2424  {
    2525    log_printf(FUNC,Reservation_station,FUNCTION,"Begin");
    2626
    27     std::string msg = "";
    28 
    29 //     if (_size_queue < 2)
    30 //       {
    31 //         msg += "  - The reservation_station must be have less a depth of 2";
    32 //         msg += "    * size_queue                      : " + toString(_size_queue)    + "\n";
    33 //       }
     27    Parameters_test test ("Reservation_station");
    3428
    3529    if (_size_queue < _nb_inst_retire)
    36       {
    37         msg += "  - The reservation_station can't have more retire port than entry in the queue.";
    38       }
    39    
    40     return msg;
     30      test.error("The reservation_station can't have more retire port than entry in the queue.");
    4131
    4232    log_printf(FUNC,Reservation_station,FUNCTION,"End");
     33
     34    return test;
    4335  };
    4436

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/src/Reservation_station_allocation.cpp

    r76 r78  
    7373       in_INSERT_TYPE           = interface->set_signal_in <Ttype_t           > ("type"           ,_param->_size_type             );
    7474       in_INSERT_STORE_QUEUE_PTR_WRITE = interface->set_signal_in <Tlsq_ptr_t> ("store_queue_ptr_write" ,log2(_param->_size_store_queue));
     75       if (_param->_have_port_load_queue_ptr)
    7576       in_INSERT_LOAD_QUEUE_PTR_WRITE  = interface->set_signal_in <Tlsq_ptr_t> ("load_queue_ptr_write"  ,log2(_param->_size_load_queue) );
    7677       in_INSERT_HAS_IMMEDIAT   = interface->set_signal_in <Tcontrol_t        > ("has_immediat"   ,1                             );
    … …  
    108109    out_RETIRE_TYPE           = new SC_OUT(Ttype_t           ) * [_param->_nb_inst_retire];
    109110    out_RETIRE_STORE_QUEUE_PTR_WRITE = new SC_OUT(Tlsq_ptr_t ) * [_param->_nb_inst_retire];
     111    if (_param->_have_port_load_queue_ptr)
    110112    out_RETIRE_LOAD_QUEUE_PTR_WRITE  = new SC_OUT(Tlsq_ptr_t ) * [_param->_nb_inst_retire];
    111113    out_RETIRE_HAS_IMMEDIAT   = new SC_OUT(Tcontrol_t        ) * [_param->_nb_inst_retire];
    … …  
    141143        out_RETIRE_TYPE         [i] = interface->set_signal_out<Ttype_t           > ("type"         ,_param->_size_type);
    142144        out_RETIRE_STORE_QUEUE_PTR_WRITE [i] = interface->set_signal_out<Tlsq_ptr_t> ("store_queue_ptr_write" ,log2(_param->_size_store_queue));
     145        if (_param->_have_port_load_queue_ptr)
    143146        out_RETIRE_LOAD_QUEUE_PTR_WRITE  [i] = interface->set_signal_out<Tlsq_ptr_t> ("load_queue_ptr_write"  ,log2(_param->_size_load_queue) );
    144147

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/src/Reservation_station_deallocation.cpp

    r76 r78  
    4444    delete     in_INSERT_TYPE          ;
    4545    delete     in_INSERT_STORE_QUEUE_PTR_WRITE;
     46    if (_param->_have_port_load_queue_ptr)
    4647    delete     in_INSERT_LOAD_QUEUE_PTR_WRITE ;
    4748    delete     in_INSERT_HAS_IMMEDIAT  ;
    … …  
    7778    delete [] out_RETIRE_TYPE          ;
    7879    delete [] out_RETIRE_STORE_QUEUE_PTR_WRITE;
     80    if (_param->_have_port_load_queue_ptr)
    7981    delete [] out_RETIRE_LOAD_QUEUE_PTR_WRITE ;
    8082    delete [] out_RETIRE_HAS_IMMEDIAT  ;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/src/Reservation_station_genMoore.cpp

    r76 r78  
    102102            PORT_WRITE(out_RETIRE_TYPE          [i],_queue[index_find]._type);
    103103            PORT_WRITE(out_RETIRE_STORE_QUEUE_PTR_WRITE [i],_queue[index_find]._store_queue_ptr_write);
     104            if (_param->_have_port_load_queue_ptr)
    104105            PORT_WRITE(out_RETIRE_LOAD_QUEUE_PTR_WRITE  [i],_queue[index_find]._load_queue_ptr_write );
    105106            PORT_WRITE(out_RETIRE_HAS_IMMEDIAT  [i],_queue[index_find]._has_immediat);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/src/Reservation_station_transition.cpp

    r76 r78  
    259259            _queue[index]._type            = PORT_READ(in_INSERT_TYPE           );
    260260            _queue[index]._store_queue_ptr_write = PORT_READ(in_INSERT_STORE_QUEUE_PTR_WRITE);
     261            if (_param->_have_port_load_queue_ptr)
    261262            _queue[index]._load_queue_ptr_write  = PORT_READ(in_INSERT_LOAD_QUEUE_PTR_WRITE );
    262263            _queue[index]._has_immediat    = PORT_READ(in_INSERT_HAS_IMMEDIAT   );

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/SelfTest/configuration.cfg

    r77 r78  
    13132       2       *2      # nb_spr_write           
    14144       4       *2      # size_store_queue       
    15 4       4       *2      # size_load_queue         
     151       4       *4      # size_load_queue         
    16162       2       *2      # nb_inst_retire         
    17172       2       *2      # nb_bypass_write         

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/SelfTest/src/test.cpp

    r76 r78  
    161161  INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_TYPE                  );
    162162  INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_STORE_QUEUE_PTR_WRITE );
     163  if (_param->_have_port_load_queue_ptr)
    163164  INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_LOAD_QUEUE_PTR_WRITE  );
    164165  INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_HAS_IMMEDIAT          );
    … …  
    187188  INSTANCE1_SC_SIGNAL(_Read_unit,out_READ_UNIT_OUT_TYPE                 ,_param->_nb_inst_retire);
    188189  INSTANCE1_SC_SIGNAL(_Read_unit,out_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE,_param->_nb_inst_retire);
     190  if (_param->_have_port_load_queue_ptr)
    189191  INSTANCE1_SC_SIGNAL(_Read_unit,out_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ,_param->_nb_inst_retire);
    190192  INSTANCE1_SC_SIGNAL(_Read_unit,out_READ_UNIT_OUT_HAS_IMMEDIAT         ,_param->_nb_inst_retire);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/include/Parameters.h

    r77 r78  
    5757  public : const bool        _have_port_ooo_engine_id ;
    5858  public : const bool        _have_port_packet_id     ;
     59  public : const bool        _have_port_load_queue_ptr;
    5960
    6061  public : morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_read_unit::read_unit::read_queue         ::Parameters * _param_read_queue;
    … …  
    8283  public : ~Parameters () ;
    8384
    84   public :        std::string  msg_error  (void);
     85  public :        Parameters_test msg_error  (void);
    8586
    8687  public :        std::string   print      (uint32_t depth);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/src/Parameters.cpp

    r77 r78  
    6666    _have_port_front_end_id   (_size_front_end_id >0),
    6767    _have_port_ooo_engine_id  (_size_ooo_engine_id>0),
    68     _have_port_packet_id      (_size_packet_id    >0)
     68    _have_port_packet_id      (_size_packet_id    >0),
     69    _have_port_load_queue_ptr (_size_load_queue   >1)
    6970  {
    7071    log_printf(FUNC,Read_unit,FUNCTION,"Begin");
    … …  
    144145    _have_port_front_end_id   (param._have_port_front_end_id  ),
    145146    _have_port_ooo_engine_id  (param._have_port_ooo_engine_id ),
    146     _have_port_packet_id      (param._have_port_packet_id     )
     147    _have_port_packet_id      (param._have_port_packet_id     ),
     148    _have_port_load_queue_ptr (param._have_port_load_queue_ptr)
    147149  {
    148150    log_printf(FUNC,Read_unit,FUNCTION,"Begin");

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/src/Parameters_msg_error.cpp

    r76 r78  
    2121#undef  FUNCTION
    2222#define FUNCTION "Read_unit::msg_error"
    23   std::string Parameters::msg_error(void)
     23  Parameters_test Parameters::msg_error(void)
    2424  {
    2525    log_printf(FUNC,Read_unit,FUNCTION,"Begin");
    2626
    27     std::string msg = "";
    28 
    29     return msg;
     27    Parameters_test test ("Read_unit");
    3028
    3129    log_printf(FUNC,Read_unit,FUNCTION,"End");
     30
     31    return test;
    3232  };
    3333

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/src/Read_unit_allocation.cpp

    r76 r78  
    5959       ALLOC_INTERFACE("read_unit_in", IN, WEST, "Enter of new operation");
    6060
    61        ALLOC_VAL_IN    ( in_READ_UNIT_IN_VAL);
    62        ALLOC_ACK_OUT   (out_READ_UNIT_IN_ACK);
     61       ALLOC_VALACK_IN    ( in_READ_UNIT_IN_VAL,VAL);
     62       ALLOC_VALACK_OUT   (out_READ_UNIT_IN_ACK,ACK);
    6363       ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_CONTEXT_ID           ,"context_id"           ,Tcontext_t        ,_param->_size_context_id   );
    6464       ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_FRONT_END_ID         ,"front_end_id"         ,Tcontext_t        ,_param->_size_front_end_id );
    … …  
    6767       ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_OPERATION            ,"operation"            ,Toperation_t      ,_param->_size_operation    );
    6868       ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_TYPE                 ,"type"                 ,Ttype_t           ,_param->_size_type         );
    69        ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_STORE_QUEUE_PTR_WRITE,"store_queue_ptr_write",Tlsq_ptr_t        ,_param->_size_store_queue  );
    70        ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,"load_queue_ptr_write" ,Tlsq_ptr_t        ,_param->_size_load_queue   );
     69       ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_STORE_QUEUE_PTR_WRITE,"store_queue_ptr_write",Tlsq_ptr_t        ,log2(_param->_size_store_queue));
     70       ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,"load_queue_ptr_write" ,Tlsq_ptr_t        ,log2(_param->_size_load_queue));
    7171       ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_HAS_IMMEDIAT         ,"has_immediat"         ,Tcontrol_t        ,1);
    7272       ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_IMMEDIAT             ,"immediat"             ,Tgeneral_data_t   ,_param->_size_general_data);
    … …  
    8787       ALLOC1_INTERFACE("read_unit_out", OUT, EAST, "Output of operation. All operand is valid.", _param->_nb_inst_retire);
    8888
    89        ALLOC1_VAL_OUT   (out_READ_UNIT_OUT_VAL);
    90        ALLOC1_ACK_IN    ( in_READ_UNIT_OUT_ACK);
     89       ALLOC1_VALACK_OUT   (out_READ_UNIT_OUT_VAL,VAL);
     90       ALLOC1_VALACK_IN    ( in_READ_UNIT_OUT_ACK,ACK);
    9191       ALLOC1_SIGNAL_OUT(out_READ_UNIT_OUT_CONTEXT_ID           ,"context_id"           ,Tcontext_t        ,_param->_size_context_id      );
    9292       ALLOC1_SIGNAL_OUT(out_READ_UNIT_OUT_FRONT_END_ID         ,"front_end_id"         ,Tcontext_t        ,_param->_size_front_end_id    );
    … …  
    9595       ALLOC1_SIGNAL_OUT(out_READ_UNIT_OUT_OPERATION            ,"operation"            ,Toperation_t      ,_param->_size_operation       );
    9696       ALLOC1_SIGNAL_OUT(out_READ_UNIT_OUT_TYPE                 ,"type"                 ,Ttype_t           ,_param->_size_type            );
    97        ALLOC1_SIGNAL_OUT(out_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE,"store_queue_ptr_write",Tlsq_ptr_t        ,_param->_size_store_queue     );
    98        ALLOC1_SIGNAL_OUT(out_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ,"load_queue_ptr_write" ,Tlsq_ptr_t        ,_param->_size_load_queue      );
     97       ALLOC1_SIGNAL_OUT(out_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE,"store_queue_ptr_write",Tlsq_ptr_t        ,log2(_param->_size_store_queue));
     98       ALLOC1_SIGNAL_OUT(out_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ,"load_queue_ptr_write" ,Tlsq_ptr_t        ,log2(_param->_size_load_queue ));
    9999       ALLOC1_SIGNAL_OUT(out_READ_UNIT_OUT_HAS_IMMEDIAT         ,"has_immediat"         ,Tcontrol_t        ,1                             );
    100100       ALLOC1_SIGNAL_OUT(out_READ_UNIT_OUT_IMMEDIAT             ,"immediat"             ,Tgeneral_data_t   ,_param->_size_general_data    );
    … …  
    112112       ALLOC1_INTERFACE("gpr_read", OUT, SOUTH, "Read port.", _param->_nb_gpr_read);
    113113
    114        ALLOC1_VAL_OUT   (out_GPR_READ_VAL);
    115        ALLOC1_ACK_IN    ( in_GPR_READ_ACK);
     114       ALLOC1_VALACK_OUT   (out_GPR_READ_VAL,VAL);
     115       ALLOC1_VALACK_IN    ( in_GPR_READ_ACK,ACK);
    116116       ALLOC1_SIGNAL_OUT(out_GPR_READ_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id   );
    117117       ALLOC1_SIGNAL_OUT(out_GPR_READ_NUM_REG      ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_data    );
    … …  
    124124       ALLOC1_INTERFACE("spr_read", OUT, SOUTH, "Read port.", _param->_nb_spr_read);
    125125
    126        ALLOC1_VAL_OUT   (out_SPR_READ_VAL);
    127        ALLOC1_ACK_IN    ( in_SPR_READ_ACK);
     126       ALLOC1_VALACK_OUT   (out_SPR_READ_VAL,VAL);
     127       ALLOC1_VALACK_IN    ( in_SPR_READ_ACK,ACK);
    128128       ALLOC1_SIGNAL_OUT(out_SPR_READ_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id   );
    129129       ALLOC1_SIGNAL_OUT(out_SPR_READ_NUM_REG      ,"num_reg"      ,Tspecial_address_t,_param->_size_special_data    );
    … …  
    136136       ALLOC1_INTERFACE("gpr_write", IN , SOUTH, "Write port.", _param->_nb_gpr_write);
    137137
    138        ALLOC1_VAL_IN    ( in_GPR_WRITE_VAL);
     138       ALLOC1_VALACK_IN    ( in_GPR_WRITE_VAL,VAL);
    139139       ALLOC1_SIGNAL_IN ( in_GPR_WRITE_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id   );
    140140       ALLOC1_SIGNAL_IN ( in_GPR_WRITE_NUM_REG      ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_data    );
    … …  
    146146       ALLOC1_INTERFACE("spr_write", IN , SOUTH, "Write port.", _param->_nb_spr_write);
    147147
    148        ALLOC1_VAL_IN    ( in_SPR_WRITE_VAL);
     148       ALLOC1_VALACK_IN    ( in_SPR_WRITE_VAL,VAL);
    149149       ALLOC1_SIGNAL_IN ( in_SPR_WRITE_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id   );
    150150       ALLOC1_SIGNAL_IN ( in_SPR_WRITE_NUM_REG      ,"num_reg"      ,Tspecial_address_t,_param->_size_special_data    );
    … …  
    216216       name = _name+"_read_queue";
    217217       std::cout << "Instance : " << name << std::endl;
    218        
    219218       {
    220219#ifdef POSITION
    … …  
    248247         _component->port_map(name, "in_READ_QUEUE_IN_TYPE"                 ,dest, "in_READ_UNIT_IN_TYPE"                 );
    249248         _component->port_map(name, "in_READ_QUEUE_IN_STORE_QUEUE_PTR_WRITE",dest, "in_READ_UNIT_IN_STORE_QUEUE_PTR_WRITE");
     249         if (_param->_have_port_load_queue_ptr)
    250250         _component->port_map(name, "in_READ_QUEUE_IN_LOAD_QUEUE_PTR_WRITE" ,dest, "in_READ_UNIT_IN_LOAD_QUEUE_PTR_WRITE" );
    251251         _component->port_map(name, "in_READ_QUEUE_IN_HAS_IMMEDIAT"         ,dest, "in_READ_UNIT_IN_HAS_IMMEDIAT"         );
    … …  
    284284         _component->port_map(name,"out_READ_QUEUE_OUT_TYPE"                 ,dest, "in_INSERT_TYPE"                 );
    285285         _component->port_map(name,"out_READ_QUEUE_OUT_STORE_QUEUE_PTR_WRITE",dest, "in_INSERT_STORE_QUEUE_PTR_WRITE");
     286         if (_param->_have_port_load_queue_ptr)
    286287         _component->port_map(name,"out_READ_QUEUE_OUT_LOAD_QUEUE_PTR_WRITE" ,dest, "in_INSERT_LOAD_QUEUE_PTR_WRITE" );
    287288         _component->port_map(name,"out_READ_QUEUE_OUT_HAS_IMMEDIAT"         ,dest, "in_INSERT_HAS_IMMEDIAT"         );
    … …  
    375376       name = _name+"_reservation_station";
    376377       std::cout << "Instance : " << name << std::endl;
    377        
    378378       {
    379379#ifdef POSITION
    … …  
    408408         _component->port_map(name, "in_INSERT_TYPE"                 ,dest,"out_READ_QUEUE_OUT_TYPE"                 );
    409409         _component->port_map(name, "in_INSERT_STORE_QUEUE_PTR_WRITE",dest,"out_READ_QUEUE_OUT_STORE_QUEUE_PTR_WRITE");
     410         if (_param->_have_port_load_queue_ptr)
    410411         _component->port_map(name, "in_INSERT_LOAD_QUEUE_PTR_WRITE" ,dest,"out_READ_QUEUE_OUT_LOAD_QUEUE_PTR_WRITE" );
    411412         _component->port_map(name, "in_INSERT_HAS_IMMEDIAT"         ,dest,"out_READ_QUEUE_OUT_HAS_IMMEDIAT"         );
    … …  
    452453           _component->port_map(name,"out_RETIRE_"+toString(i)+"_TYPE"                 ,dest,"out_READ_UNIT_OUT_"+toString(i)+"_TYPE"                 );
    453454           _component->port_map(name,"out_RETIRE_"+toString(i)+"_STORE_QUEUE_PTR_WRITE",dest,"out_READ_UNIT_OUT_"+toString(i)+"_STORE_QUEUE_PTR_WRITE");
     455           if (_param->_have_port_load_queue_ptr)
    454456           _component->port_map(name,"out_RETIRE_"+toString(i)+"_LOAD_QUEUE_PTR_WRITE" ,dest,"out_READ_UNIT_OUT_"+toString(i)+"_LOAD_QUEUE_PTR_WRITE" );
    455457           _component->port_map(name,"out_RETIRE_"+toString(i)+"_HAS_IMMEDIAT"         ,dest,"out_READ_UNIT_OUT_"+toString(i)+"_HAS_IMMEDIAT"         );
    … …  
    528530         }       
    529531     }
     532     
    530533
    531534#ifdef POSITION

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/src/Read_unit_deallocation.cpp

    r76 r78  
    4242        delete     in_READ_UNIT_IN_TYPE                 ;
    4343        delete     in_READ_UNIT_IN_STORE_QUEUE_PTR_WRITE;
     44        if (_param->_have_port_load_queue_ptr)
    4445        delete     in_READ_UNIT_IN_LOAD_QUEUE_PTR_WRITE ;
    4546        delete     in_READ_UNIT_IN_HAS_IMMEDIAT         ;
    … …  
    7071        delete [] out_READ_UNIT_OUT_TYPE                 ;
    7172        delete [] out_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE;
     73        if (_param->_have_port_load_queue_ptr)
    7274        delete [] out_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ;
    7375        delete [] out_READ_UNIT_OUT_HAS_IMMEDIAT         ;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue/include/Parameters.h

    r77 r78  
    5555  public : ~Parameters () ;
    5656
    57   public :        std::string  msg_error  (void);
     57  public :        Parameters_test msg_error  (void);
    5858
    5959  public :        std::string   print      (uint32_t depth);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue/src/Execute_queue_allocation.cpp

    r75 r78  
    5454       ALLOC_INTERFACE ("execute_queue_in", IN, WEST, "Input of execute_queue");
    5555       
    56        ALLOC_VAL_IN    ( in_EXECUTE_QUEUE_IN_VAL);
    57        ALLOC_ACK_OUT   (out_EXECUTE_QUEUE_IN_ACK);
     56       ALLOC_VALACK_IN ( in_EXECUTE_QUEUE_IN_VAL,VAL);
     57       ALLOC_VALACK_OUT(out_EXECUTE_QUEUE_IN_ACK,ACK);
    5858       if(_param->_have_port_context_id)
    5959       ALLOC_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_CONTEXT_ID   ,"context_id"   ,Tcontext_t        ,_param->_size_context_id       );
    … …  
    7676       ALLOC_INTERFACE ("execute_queue_out", OUT, EAST, "Output of execute_queue");
    7777       
    78        ALLOC_VAL_OUT   (out_EXECUTE_QUEUE_OUT_VAL);
    79        ALLOC_ACK_IN    ( in_EXECUTE_QUEUE_OUT_ACK);
     78       ALLOC_VALACK_OUT(out_EXECUTE_QUEUE_OUT_VAL,VAL);
     79       ALLOC_VALACK_IN ( in_EXECUTE_QUEUE_OUT_ACK,ACK);
    8080       if(_param->_have_port_context_id)
    8181       ALLOC_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_CONTEXT_ID   ,"context_id"   ,Tcontext_t     ,_param->_size_context_id   );

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue/src/Parameters_msg_error.cpp

    r73 r78  
    2222#undef  FUNCTION
    2323#define FUNCTION "Execute_queue::msg_error"
    24   std::string Parameters::msg_error(void)
     24  Parameters_test Parameters::msg_error(void)
    2525  {
    2626    log_printf(FUNC,Execute_queue,FUNCTION,"Begin");
    2727
    28     std::string msg = "";
    29 
    30     return msg;
     28    Parameters_test test ("Execute_queue");
    3129
    3230    log_printf(FUNC,Execute_queue,FUNCTION,"End");
     31
     32    return test;
    3333  };
    3434

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/include/Parameters.h

    r77 r78  
    6666  public : ~Parameters () ;
    6767
    68   public :        std::string  msg_error  (void);
     68  public :        Parameters_test msg_error  (void);
    6969
    7070  public :        std::string   print      (uint32_t depth);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/src/Parameters_msg_error.cpp

    r74 r78  
    2222#undef  FUNCTION
    2323#define FUNCTION "Write_queue::msg_error"
    24   std::string Parameters::msg_error(void)
     24  Parameters_test Parameters::msg_error(void)
    2525  {
    2626    log_printf(FUNC,Write_queue,FUNCTION,"Begin");
    2727
    28     std::string msg = "";
     28    Parameters_test test ("Write_queue");
    2929
    3030    if (_nb_bypass_write > _size_queue)
    31       msg += " * The write_queue can't have more bypass_write than entry in the queue.";
    32 
    33     return msg;
     31      test.error("The write_queue can't have more bypass_write than entry in the queue.");
    3432
    3533    log_printf(FUNC,Write_queue,FUNCTION,"End");
     34
     35    return test;
    3636  };
    3737

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/src/Write_queue_allocation.cpp

    r77 r78  
    5353       ALLOC_INTERFACE ("write_queue_in", IN, WEST, "Input of write_queue");
    5454       
    55        ALLOC_VAL_IN    ( in_WRITE_QUEUE_IN_VAL);
    56        ALLOC_ACK_OUT   (out_WRITE_QUEUE_IN_ACK);
     55       ALLOC_VALACK_IN ( in_WRITE_QUEUE_IN_VAL,VAL);
     56       ALLOC_VALACK_OUT(out_WRITE_QUEUE_IN_ACK,ACK);
    5757       ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_CONTEXT_ID   ,"context_id"   ,Tcontext_t        ,_param->_size_context_id       );
    5858       ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_FRONT_END_ID ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id     );
    … …  
    7676       ALLOC_INTERFACE ("write_queue_out", OUT, EAST, "Output of write_queue");
    7777       
    78        ALLOC_VAL_OUT   (out_WRITE_QUEUE_OUT_VAL);
    79        ALLOC_ACK_IN    ( in_WRITE_QUEUE_OUT_ACK);
     78       ALLOC_VALACK_OUT(out_WRITE_QUEUE_OUT_VAL,VAL);
     79       ALLOC_VALACK_IN ( in_WRITE_QUEUE_OUT_ACK,ACK);
    8080       ALLOC_SIGNAL_OUT(out_WRITE_QUEUE_OUT_CONTEXT_ID   ,"context_id"   ,Tcontext_t     ,_param->_size_context_id   );
    8181       ALLOC_SIGNAL_OUT(out_WRITE_QUEUE_OUT_FRONT_END_ID ,"front_end_id" ,Tcontext_t     ,_param->_size_front_end_id );
    … …  
    9494       ALLOC1_INTERFACE("gpr_write", OUT, SOUTH ,"Output of write_queue", _param->_nb_gpr_write);
    9595
    96        ALLOC1_VAL_OUT   (out_GPR_WRITE_VAL);
    97        ALLOC1_ACK_IN    ( in_GPR_WRITE_ACK);
     96       ALLOC1_VALACK_OUT(out_GPR_WRITE_VAL,VAL);
     97       ALLOC1_VALACK_IN ( in_GPR_WRITE_ACK,ACK);
    9898       ALLOC1_SIGNAL_OUT(out_GPR_WRITE_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id   );
    9999       ALLOC1_SIGNAL_OUT(out_GPR_WRITE_NUM_REG      ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
    … …  
    105105       ALLOC1_INTERFACE("spr_write", OUT, SOUTH ,"Output of write_queue", _param->_nb_spr_write);
    106106
    107        ALLOC1_VAL_OUT   (out_SPR_WRITE_VAL);
    108        ALLOC1_ACK_IN    ( in_SPR_WRITE_ACK);
     107       ALLOC1_VALACK_OUT(out_SPR_WRITE_VAL,VAL);
     108       ALLOC1_VALACK_IN ( in_SPR_WRITE_ACK,ACK);
    109109       ALLOC1_SIGNAL_OUT(out_SPR_WRITE_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id   );
    110110       ALLOC1_SIGNAL_OUT(out_SPR_WRITE_NUM_REG      ,"num_reg"      ,Tspecial_address_t,_param->_size_special_register);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/include/Parameters.h

    r77 r78  
    7474  public : ~Parameters () ;
    7575
    76   public :        std::string  msg_error  (void);
     76  public :        Parameters_test msg_error  (void);
    7777
    7878  public :        std::string   print      (uint32_t depth);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/src/Parameters_msg_error.cpp

    r74 r78  
    2020#undef  FUNCTION
    2121#define FUNCTION "Write_unit::msg_error"
    22   std::string Parameters::msg_error(void)
     22  Parameters_test Parameters::msg_error(void)
    2323  {
    2424    log_printf(FUNC,Write_unit,FUNCTION,"Begin");
    2525
    26     std::string msg = "";
     26    Parameters_test test ("Write_unit");
    2727
    2828    if (_size_write_queue == 0)
    29       msg += " * Write queue must have a less one entry.";
    30 
    31     return msg;
     29      test.error("Write queue must have a less one entry.");
    3230
    3331    log_printf(FUNC,Write_unit,FUNCTION,"End");
     32
     33    return test;
    3434  };
    3535

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/src/Write_unit_allocation.cpp

    r77 r78  
    5959       ALLOC_INTERFACE ("write_unit_in", IN, WEST, "Input of write_unit");
    6060       
    61        ALLOC_VAL_IN    ( in_WRITE_UNIT_IN_VAL);
    62        ALLOC_ACK_OUT   (out_WRITE_UNIT_IN_ACK);
     61       ALLOC_VALACK_IN ( in_WRITE_UNIT_IN_VAL,VAL);
     62       ALLOC_VALACK_OUT(out_WRITE_UNIT_IN_ACK,ACK);
    6363       ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_CONTEXT_ID   ,"context_id"   ,Tcontext_t        ,_param->_size_context_id       );
    6464       ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_FRONT_END_ID ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id     );
    … …  
    8282       ALLOC_INTERFACE ("write_unit_out", OUT, EAST, "Output of write_unit");
    8383       
    84        ALLOC_VAL_OUT   (out_WRITE_UNIT_OUT_VAL);
    85        ALLOC_ACK_IN    ( in_WRITE_UNIT_OUT_ACK);
     84       ALLOC_VALACK_OUT(out_WRITE_UNIT_OUT_VAL,VAL);
     85       ALLOC_VALACK_IN ( in_WRITE_UNIT_OUT_ACK,ACK);
    8686       ALLOC_SIGNAL_OUT(out_WRITE_UNIT_OUT_CONTEXT_ID   ,"context_id"   ,Tcontext_t     ,_param->_size_context_id   );
    8787       ALLOC_SIGNAL_OUT(out_WRITE_UNIT_OUT_FRONT_END_ID ,"front_end_id" ,Tcontext_t     ,_param->_size_front_end_id );
    … …  
    100100       ALLOC1_INTERFACE("gpr_write", OUT, SOUTH ,"Output of write_unit", _param->_nb_gpr_write);
    101101
    102        ALLOC1_VAL_OUT   (out_GPR_WRITE_VAL);
    103        ALLOC1_ACK_IN    ( in_GPR_WRITE_ACK);
     102       ALLOC1_VALACK_OUT(out_GPR_WRITE_VAL,VAL);
     103       ALLOC1_VALACK_IN ( in_GPR_WRITE_ACK,ACK);
    104104       ALLOC1_SIGNAL_OUT(out_GPR_WRITE_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id   );
    105105       ALLOC1_SIGNAL_OUT(out_GPR_WRITE_NUM_REG      ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
    … …  
    111111       ALLOC1_INTERFACE("spr_write", OUT, SOUTH ,"Output of write_unit", _param->_nb_spr_write);
    112112
    113        ALLOC1_VAL_OUT   (out_SPR_WRITE_VAL);
    114        ALLOC1_ACK_IN    ( in_SPR_WRITE_ACK);
     113       ALLOC1_VALACK_OUT(out_SPR_WRITE_VAL,VAL);
     114       ALLOC1_VALACK_IN ( in_SPR_WRITE_ACK,ACK);
    115115       ALLOC1_SIGNAL_OUT(out_SPR_WRITE_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id   );
    116116       ALLOC1_SIGNAL_OUT(out_SPR_WRITE_NUM_REG      ,"num_reg"      ,Tspecial_address_t,_param->_size_special_register);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/src/test.cpp

    r77 r78  
    5252  public : Tpacket_t          _packet_id      ;
    5353//public : Toperation_t       _operation      ;
    54 //public : Ttype_t            _type           ;
     54  public : Ttype_t            _type           ;
    5555  public : Tcontrol_t         _write_rd       ;
    5656  public : Tgeneral_address_t _num_reg_rd     ;
    … …  
    6868                  Tpacket_t          packet_id      ,
    6969//                Toperation_t       operation      ,
    70 //                Ttype_t            type           ,
     70                  Ttype_t            type           ,
    7171                  Tcontrol_t         write_rd       ,
    7272                  Tgeneral_address_t num_reg_rd     ,
    … …  
    8484    _packet_id      = packet_id    ;
    8585//  _operation      = operation    ;
    86 //  _type           = type         ;
     86    _type           = type         ;
    8787    _write_rd       = write_rd     ;
    8888    _num_reg_rd     = num_reg_rd   ;
    … …  
    128128  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_PACKET_ID    ," in_EXECUTE_UNIT_OUT_PACKET_ID    ",Tpacket_t         ,_param->_nb_execute_unit);
    129129//ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_OPERATION    ," in_EXECUTE_UNIT_OUT_OPERATION    ",Toperation_t      ,_param->_nb_execute_unit);
    130 //ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_TYPE         ," in_EXECUTE_UNIT_OUT_TYPE         ",Ttype_t           ,_param->_nb_execute_unit);
     130  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_TYPE         ," in_EXECUTE_UNIT_OUT_TYPE         ",Ttype_t           ,_param->_nb_execute_unit);
    131131  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_WRITE_RD     ," in_EXECUTE_UNIT_OUT_WRITE_RD     ",Tcontrol_t        ,_param->_nb_execute_unit);
    132132  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_NUM_REG_RD   ," in_EXECUTE_UNIT_OUT_NUM_REG_RD   ",Tgeneral_address_t,_param->_nb_execute_unit);
    … …  
    145145  ALLOC1_SC_SIGNAL(out_WRITE_UNIT_IN_PACKET_ID       ,"out_WRITE_UNIT_IN_PACKET_ID       ",Tpacket_t         ,_param->_nb_write_unit  );
    146146//ALLOC1_SC_SIGNAL(out_WRITE_UNIT_IN_OPERATION       ,"out_WRITE_UNIT_IN_OPERATION       ",Toperation_t      ,_param->_nb_write_unit  );
    147 //ALLOC1_SC_SIGNAL(out_WRITE_UNIT_IN_TYPE            ,"out_WRITE_UNIT_IN_TYPE            ",Ttype_t           ,_param->_nb_write_unit  );
     147  ALLOC1_SC_SIGNAL(out_WRITE_UNIT_IN_TYPE            ,"out_WRITE_UNIT_IN_TYPE            ",Ttype_t           ,_param->_nb_write_unit  );
    148148  ALLOC1_SC_SIGNAL(out_WRITE_UNIT_IN_WRITE_RD        ,"out_WRITE_UNIT_IN_WRITE_RD        ",Tcontrol_t        ,_param->_nb_write_unit  );
    149149  ALLOC1_SC_SIGNAL(out_WRITE_UNIT_IN_NUM_REG_RD      ,"out_WRITE_UNIT_IN_NUM_REG_RD      ",Tgeneral_address_t,_param->_nb_write_unit  );
    … …  
    176176  INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_PACKET_ID    ,_param->_nb_execute_unit);
    177177//INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_OPERATION    ,_param->_nb_execute_unit);
    178 //INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_TYPE         ,_param->_nb_execute_unit);
     178  INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_TYPE         ,_param->_nb_execute_unit);
    179179  INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_WRITE_RD     ,_param->_nb_execute_unit);
    180180  INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_NUM_REG_RD   ,_param->_nb_execute_unit);
    … …  
    198198  INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit,out_WRITE_UNIT_IN_PACKET_ID       ,_param->_nb_write_unit  );
    199199//INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit,out_WRITE_UNIT_IN_OPERATION       ,_param->_nb_write_unit  );
    200 //INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit,out_WRITE_UNIT_IN_TYPE            ,_param->_nb_write_unit  );
     200  INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit,out_WRITE_UNIT_IN_TYPE            ,_param->_nb_write_unit  );
    201201  INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit,out_WRITE_UNIT_IN_WRITE_RD        ,_param->_nb_write_unit  );
    202202  INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit,out_WRITE_UNIT_IN_NUM_REG_RD      ,_param->_nb_write_unit  );
    … …  
    282282                                          nb_request_in,
    283283                                          //range<Toperation_t      > (rand(), _param->_size_operation       ),
    284                                           //range<Ttype_t           > (rand(), _param->_size_type            ),
     284                                          range<Ttype_t           > (rand(), _param->_size_type            ),
    285285                                          range<Tcontrol_t        > (rand(), 2                             ),
    286286                                          range<Tgeneral_address_t> (rand(), _param->_size_general_register),
    … …  
    314314                  in_EXECUTE_UNIT_OUT_PACKET_ID            [i] ->write(request[i].front()._packet_id            );
    315315//                in_EXECUTE_UNIT_OUT_OPERATION            [i] ->write(request[i].front()._operation            );
    316 //                in_EXECUTE_UNIT_OUT_TYPE                 [i] ->write(request[i].front()._type                 );
     316                  in_EXECUTE_UNIT_OUT_TYPE                 [i] ->write(request[i].front()._type                 );
    317317                  in_EXECUTE_UNIT_OUT_WRITE_RD             [i] ->write(request[i].front()._write_rd             );
    318318                  in_EXECUTE_UNIT_OUT_NUM_REG_RD           [i] ->write(request[i].front()._num_reg_rd           );
    … …  
    368368                TEST(Tcontext_t        ,out_WRITE_UNIT_IN_OOO_ENGINE_ID        [i]->read(), request[execute_unit].front()._ooo_engine_id        );
    369369//              TEST(Toperation_t      ,out_WRITE_UNIT_IN_OPERATION            [i]->read(), request[execute_unit].front()._operation            );
    370 //              TEST(Ttype_t           ,out_WRITE_UNIT_IN_TYPE                 [i]->read(), request[execute_unit].front()._type                 );
     370                TEST(Ttype_t           ,out_WRITE_UNIT_IN_TYPE                 [i]->read(), request[execute_unit].front()._type                 );
    371371                TEST(Tcontrol_t        ,out_WRITE_UNIT_IN_WRITE_RD             [i]->read(), request[execute_unit].front()._write_rd             );
    372372                TEST(Tgeneral_address_t,out_WRITE_UNIT_IN_NUM_REG_RD           [i]->read(), request[execute_unit].front()._num_reg_rd           );
    … …  
    405405  delete []  in_EXECUTE_UNIT_OUT_PACKET_ID    ;
    406406//delete []  in_EXECUTE_UNIT_OUT_OPERATION    ;
    407 //delete []  in_EXECUTE_UNIT_OUT_TYPE         ;
     407  delete []  in_EXECUTE_UNIT_OUT_TYPE         ;
    408408  delete []  in_EXECUTE_UNIT_OUT_WRITE_RD     ;
    409409  delete []  in_EXECUTE_UNIT_OUT_NUM_REG_RD   ;
    … …  
    423423  delete [] out_WRITE_UNIT_IN_PACKET_ID       ;
    424424//delete [] out_WRITE_UNIT_IN_OPERATION       ;
    425 //delete [] out_WRITE_UNIT_IN_TYPE            ;
     425  delete [] out_WRITE_UNIT_IN_TYPE            ;
    426426  delete [] out_WRITE_UNIT_IN_WRITE_RD        ;
    427427  delete [] out_WRITE_UNIT_IN_NUM_REG_RD      ;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/include/Execution_unit_to_Write_unit.h

    r77 r78  
    1717#include "Common/include/ToString.h"
    1818#include "Common/include/Debug.h"
     19#include "Behavioural/include/Identification.h"
    1920
    20 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/include/Types.h"
     21#include "Behavioural/include/Types.h"
    2122#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/include/Parameters.h"
    2223#ifdef STATISTICS
    … …  
    7172  public    : SC_IN (Tpacket_t         )   **  in_EXECUTE_UNIT_OUT_PACKET_ID      ;
    7273//public    : SC_IN (Toperation_t      )   **  in_EXECUTE_UNIT_OUT_OPERATION      ;
    73 //public    : SC_IN (Ttype_t           )   **  in_EXECUTE_UNIT_OUT_TYPE           ;
     74  public    : SC_IN (Ttype_t           )   **  in_EXECUTE_UNIT_OUT_TYPE           ;
    7475  public    : SC_IN (Tcontrol_t        )   **  in_EXECUTE_UNIT_OUT_WRITE_RD       ;
    7576  public    : SC_IN (Tgeneral_address_t)   **  in_EXECUTE_UNIT_OUT_NUM_REG_RD     ;
    … …  
    9091  public    : SC_OUT(Tpacket_t         )   ** out_WRITE_UNIT_IN_PACKET_ID      ;
    9192//public    : SC_OUT(Toperation_t      )   ** out_WRITE_UNIT_IN_OPERATION      ;
    92 //public    : SC_OUT(Ttype_t           )   ** out_WRITE_UNIT_IN_TYPE           ;
     93  public    : SC_OUT(Ttype_t           )   ** out_WRITE_UNIT_IN_TYPE           ;
    9394  public    : SC_OUT(Tcontrol_t        )   ** out_WRITE_UNIT_IN_WRITE_RD       ;
    9495  public    : SC_OUT(Tgeneral_address_t)   ** out_WRITE_UNIT_IN_NUM_REG_RD     ;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/include/Parameters.h

    r77 r78  
    1010
    1111#include "Behavioural/include/Parameters.h"
     12#include "Behavioural/include/Types.h"
    1213#include "Common/include/Debug.h"
    13 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/include/Types.h"
     14#include "Behavioural/include/Identification.h"
    1415
    1516namespace morpheo {
    … …  
    7071  public : ~Parameters ();
    7172
    72   public :        std::string  msg_error  (void);
     73  public :        Parameters_test msg_error  (void);
    7374
    7475  public :        std::string   print      (uint32_t depth);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit_allocation.cpp

    r77 r78  
    6060       ALLOC1_INTERFACE("execute_unit_out", IN, EAST, "Output of execution_unit", _param->_nb_execute_unit);
    6161
    62        ALLOC1_VAL_IN    ( in_EXECUTE_UNIT_OUT_VAL);
    63        ALLOC1_ACK_OUT   (out_EXECUTE_UNIT_OUT_ACK);
     62       ALLOC1_VALACK_IN ( in_EXECUTE_UNIT_OUT_VAL,VAL);
     63       ALLOC1_VALACK_OUT(out_EXECUTE_UNIT_OUT_ACK,ACK);
    6464       ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_CONTEXT_ID   ,"context_id"   ,Tcontext_t        ,_param->_size_context_id      );
    6565       ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_FRONT_END_ID ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id    );
    … …  
    6767       ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_PACKET_ID    ,"packet_id"    ,Tpacket_t         ,_param->_size_packet_id       );
    6868     //ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_OPERATION    ,"operation"    ,Toperation_t      ,_param->_size_operation       );
    69      //ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_TYPE         ,"type"         ,Ttype_t           ,_param->_size_type            );
     69       ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_TYPE         ,"type"         ,Ttype_t           ,_param->_size_type            );
    7070       ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_WRITE_RD     ,"write_rd"     ,Tcontrol_t        ,1                             );
    7171       ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_NUM_REG_RD   ,"num_reg_rd"   ,Tgeneral_address_t,_param->_size_general_register);
    … …  
    8282       ALLOC1_INTERFACE("write_unit_in", OUT, WEST, "Input of write_unit", _param->_nb_write_unit);
    8383
    84        ALLOC1_VAL_OUT(out_WRITE_UNIT_IN_VAL);
    85        ALLOC1_ACK_IN ( in_WRITE_UNIT_IN_ACK);
     84       ALLOC1_VALACK_OUT(out_WRITE_UNIT_IN_VAL,VAL);
     85       ALLOC1_VALACK_IN ( in_WRITE_UNIT_IN_ACK,ACK);
    8686       ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_CONTEXT_ID   ,"context_id"   ,Tcontext_t        ,_param->_size_context_id      );
    8787       ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_FRONT_END_ID ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id    );
    … …  
    8989       ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_PACKET_ID    ,"packet_id"    ,Tpacket_t         ,_param->_size_packet_id       );
    9090     //ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_OPERATION    ,"operation"    ,Toperation_t      ,_param->_size_operation       );
    91      //ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_TYPE         ,"type"         ,Ttype_t           ,_param->_size_type            );
     91       ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_TYPE         ,"type"         ,Ttype_t           ,_param->_size_type            );
    9292       ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_WRITE_RD     ,"write_rd"     ,Tcontrol_t        ,1                             );
    9393       ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_NUM_REG_RD   ,"num_reg_rd"   ,Tgeneral_address_t,_param->_size_general_register);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit_deallocation.cpp

    r77 r78  
    3939        delete []  in_EXECUTE_UNIT_OUT_PACKET_ID    ;
    4040      //delete []  in_EXECUTE_UNIT_OUT_OPERATION    ;
    41       //delete []  in_EXECUTE_UNIT_OUT_TYPE         ;
     41        delete []  in_EXECUTE_UNIT_OUT_TYPE         ;
    4242        delete []  in_EXECUTE_UNIT_OUT_WRITE_RD     ;
    4343        delete []  in_EXECUTE_UNIT_OUT_NUM_REG_RD   ;
    … …  
    6161        delete [] out_WRITE_UNIT_IN_PACKET_ID    ;
    6262      //delete [] out_WRITE_UNIT_IN_OPERATION    ;
    63       //delete [] out_WRITE_UNIT_IN_TYPE         ;
     63        delete [] out_WRITE_UNIT_IN_TYPE         ;
    6464        delete [] out_WRITE_UNIT_IN_WRITE_RD     ;
    6565        delete [] out_WRITE_UNIT_IN_NUM_REG_RD   ;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit_genMealy.cpp

    r77 r78  
    7575                    PORT_WRITE(out_WRITE_UNIT_IN_PACKET_ID             [dest], PORT_READ(in_EXECUTE_UNIT_OUT_PACKET_ID             [i]));
    7676                  //PORT_WRITE(out_WRITE_UNIT_IN_OPERATION             [dest], PORT_READ(in_EXECUTE_UNIT_OUT_OPERATION             [i]));
    77                   //PORT_WRITE(out_WRITE_UNIT_IN_TYPE                  [dest], PORT_READ(in_EXECUTE_UNIT_OUT_TYPE                  [i]));
     77                    PORT_WRITE(out_WRITE_UNIT_IN_TYPE                  [dest], PORT_READ(in_EXECUTE_UNIT_OUT_TYPE                  [i]));
    7878                    PORT_WRITE(out_WRITE_UNIT_IN_WRITE_RD              [dest], PORT_READ(in_EXECUTE_UNIT_OUT_WRITE_RD              [i]));
    7979                    PORT_WRITE(out_WRITE_UNIT_IN_NUM_REG_RD            [dest], PORT_READ(in_EXECUTE_UNIT_OUT_NUM_REG_RD            [i]));

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Parameters_msg_error.cpp

    r77 r78  
    2121#undef  FUNCTION
    2222#define FUNCTION "Execution_unit_to_Write_unit::msg_error"
    23   std::string Parameters::msg_error(void)
     23  Parameters_test Parameters::msg_error(void)
    2424  {
    2525    log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"Begin");
    2626
    27     std::string msg = "";
     27    Parameters_test test("Execution_unit_to_Write_unit");
    2828
    2929    for (uint32_t i=0; i<_nb_execute_unit; i++)
    … …  
    3535
    3636        if (j == _nb_write_unit)
    37           msg += "  - The execute_unit ["+toString(i)+"] is link with none write_unit.\n";
     37          test.error("The execute_unit ["+toString(i)+"] is link with none write_unit.");
    3838      }   
    3939
    … …  
    4646
    4747        if (j == _nb_thread)
    48           msg += "  - The write_unit ["+toString(i)+"] have none source's thread.\n";
     48          test.error("The write_unit ["+toString(i)+"] have none source's thread.");
    4949      }   
    5050
    51     return msg;
     51    if ( (_priority != PRIORITY_STATIC     ) and
     52         (_priority != PRIORITY_ROUND_ROBIN))
     53      test.error("Unsupported priority scheme. It must be Static or Round Robin.");
    5254
    5355    log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"End");
     56
     57    return test;
    5458  };
    5559

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/config_multi_execute-mono_thread.cfg

    r77 r78  
    111116      16      *2      # nb_special_register   
    12124       4       *2      # size_store_queue       
    13 4       4       *2      # size_load_queue       
     131       4       *4      # size_load_queue       
    14140       1       +1      # priority
    15151       1       +1      # table_routing        [0][0]

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/src/test.cpp

    r77 r78  
    190190  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_TYPE                 ,_param->_nb_read_unit);
    191191  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE,_param->_nb_read_unit);
     192  if (_param->_have_port_load_queue_ptr)
    192193  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ,_param->_nb_read_unit);
    193194  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_HAS_IMMEDIAT         ,_param->_nb_read_unit);
    … …  
    214215  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_TYPE                 ,_param->_nb_execute_unit);
    215216  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE,_param->_nb_execute_unit);
     217  if (_param->_have_port_load_queue_ptr)
    216218  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,_param->_nb_execute_unit);
    217219  INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ,_param->_nb_execute_unit);
    … …  
    352354                  in_READ_UNIT_OUT_TYPE                 [i] ->write(request[i].front()._type                 );
    353355                  in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE[i] ->write(request[i].front()._store_queue_ptr_write);
     356                  if (_param->_have_port_load_queue_ptr)
    354357                  in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE [i] ->write(request[i].front()._load_queue_ptr_write );
    355358                  in_READ_UNIT_OUT_HAS_IMMEDIAT         [i] ->write(request[i].front()._has_immediat         );
    … …  
    408411                TEST(Ttype_t           ,out_EXECUTE_UNIT_IN_TYPE                 [i]->read(), request[read_unit].front()._type                 );
    409412                TEST(Tlsq_ptr_t        ,out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE[i]->read(), request[read_unit].front()._store_queue_ptr_write);
     413                if (_param->_have_port_load_queue_ptr)
    410414                TEST(Tlsq_ptr_t        ,out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i]->read(), request[read_unit].front()._load_queue_ptr_write );
    411415                TEST(Tcontrol_t        ,out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         [i]->read(), request[read_unit].front()._has_immediat         );

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_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/Network/Read_unit_to_Execution_unit/include/Types.h"
     13#include "Behavioural/include/Types.h"
     14#include "Behavioural/include/Identification.h"
    1415
    1516namespace morpheo {
    … …  
    3839  public : const uint32_t    _size_load_queue        ;
    3940  public : const Tpriority_t _priority               ;
    40   public :       bool     ** _table_routing          ; //array [nb_read_unit][nb_execute_unit]
    41   public :       bool     ** _table_execute_type     ; //array [nb_execute_unit][nb_type]
    42   public :       bool     ** _table_execute_thread   ; //array [nb_execute_unit][nb_thread]
     41  public :       bool     ** _table_routing          ; //[nb_read_unit][nb_execute_unit]
     42  public :       bool     ** _table_execute_type     ; //[nb_execute_unit][nb_type]
     43  public :       bool     ** _table_execute_thread   ; //[nb_execute_unit][nb_thread]
    4344
    4445  public : const uint32_t    _size_context_id        ;
    … …  
    5354  public : const bool        _have_port_ooo_engine_id;
    5455  public : const bool        _have_port_packet_id    ;
     56  public : const bool        _have_port_load_queue_ptr;
    5557
    5658  public : const uint32_t    _nb_thread              ;
    … …  
    7880  public : ~Parameters () ;
    7981
    80   public :        std::string  msg_error  (void);
     82  public :        Parameters_test msg_error  (void);
    8183
    8284  public :        std::string   print      (uint32_t depth);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/include/Read_unit_to_Execution_unit.h

    r77 r78  
    1717#include "Common/include/ToString.h"
    1818#include "Common/include/Debug.h"
    19 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/include/Types.h"
     19#include "Behavioural/include/Types.h"
     20#include "Behavioural/include/Identification.h"
    2021
    2122#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/include/Parameters.h"

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Parameters.cpp

    r77 r78  
    6060    _have_port_ooo_engine_id (_size_ooo_engine_id > 0),
    6161    _have_port_packet_id     (_size_packet_id     > 0),
     62    _have_port_load_queue_ptr(_size_load_queue    > 1),
    6263
    6364    _nb_thread               (get_nb_thread (nb_context, nb_front_end, nb_ooo_engine))
    … …  
    6869    _table_execute_type   = table_execute_type  ;
    6970    _table_execute_thread = table_execute_thread;
    70    
    71     _nb_load_store_unit = 0;
     71
     72    _nb_load_store_unit   = 0;
    7273
    7374    for (uint32_t i=0; i<nb_execute_unit; i++)
    74       if (table_execute_type[i][TYPE_MEMORY] == true)
    75         _nb_load_store_unit ++;
    76 
     75      {
     76        if (table_execute_type[i][TYPE_MEMORY] == true)
     77          _nb_load_store_unit ++;
     78      }
    7779    // a execution_unit can't be a load_store unit and a functionnal unit
    7880    _nb_functionnal_unit = nb_execute_unit-_nb_load_store_unit;
    … …  
    111113    _have_port_ooo_engine_id (param._have_port_ooo_engine_id),
    112114    _have_port_packet_id     (param._have_port_packet_id    ),
     115    _have_port_load_queue_ptr(param._have_port_load_queue_ptr),
    113116
    114117    _nb_thread               (param._nb_thread              )

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Parameters_msg_error.cpp

    r77 r78  
    2121#undef  FUNCTION
    2222#define FUNCTION "Read_unit_to_Execution_unit::msg_error"
    23   std::string Parameters::msg_error(void)
     23  Parameters_test Parameters::msg_error(void)
    2424  {
    2525    log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"Begin");
    2626
    27     std::string msg = "";
     27    Parameters_test test ("Read_unit_to_Execution_unit");
    2828
    2929    // TYPE         | multiple? | Optionnal? | Exclusive? | Comment
    … …  
    9090                // Test uniq type
    9191                if (type_present [j][k] and type_uniq[k])
    92                   msg += "  - The execute_unit '"+toString(i)+"' can execute operation of type '"+toString_type(k)+"' at the thread '"+toString(j)+"'. But an another execute_unit can be execute the same type for the same thread. And the type must be uniq !.\n";
     92                  test.error("The execute_unit '"+toString(i)+"' can execute operation of type '"+toString_type(k)+"' at the thread '"+toString(j)+"'. But an another execute_unit can be execute the same type for the same thread. And the type must be uniq !.");
    9393               
    9494                type_present [j][k] = true;
    … …  
    9999        for (uint32_t i=0; i<_nb_thread; i++)
    100100          if (not type_present [i][j])
    101             msg += "  - The thread '"+toString(i)+"' can't access at the execute_unit to execute the type's operation '"+toString_type(j)+"' (and this type is not optionnal !).\n";
     101            test.error("The thread '"+toString(i)+"' can't access at the execute_unit to execute the type's operation '"+toString_type(j)+"' (and this type is not optionnal !).");
    102102           
    103103    // Test all excluve type
    … …  
    108108            if ((j != k) and (_table_execute_type[i][k] == true))
    109109              {
    110                 msg += "  - The execute_unit ["+toString(i)+"] implement the type '"+toString_type(j)+"', and this type is exclusive with all others type.\n";
     110                test.error("The execute_unit ["+toString(i)+"] implement the type '"+toString_type(j)+"', and this type is exclusive with all others type.");
    111111                break;
    112112              }
    … …  
    120120
    121121        if (j == _nb_thread)
    122           msg += "  - The execute_unit ["+toString(i)+"] have none source's thread.\n";
     122          test.error("The execute_unit ["+toString(i)+"] have none source's thread.");
    123123      }   
    124    
    125     return msg;
    126124
     125    if ( (_priority != PRIORITY_STATIC     ) and
     126         (_priority != PRIORITY_ROUND_ROBIN))
     127      test.error("Unsupported priority scheme. It must be Static or Round Robin.");
     128       
    127129    log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"End");
     130
     131    return test;
    128132  };
    129133

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit.cpp

    r77 r78  
    8989                      << (*(in_READ_UNIT_OUT_OPERATION             [i]))
    9090                      << (*(in_READ_UNIT_OUT_TYPE                  [i]))
    91                       << (*(in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE [i]))
    92                       << (*(in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE  [i]))
    9391                      << (*(in_READ_UNIT_OUT_HAS_IMMEDIAT          [i]))
    9492                      << (*(in_READ_UNIT_OUT_IMMEDIAT              [i]))
    … …  
    9997                      << (*(in_READ_UNIT_OUT_NUM_REG_RD            [i]))
    10098                      << (*(in_READ_UNIT_OUT_WRITE_RE              [i]))
    101                       << (*(in_READ_UNIT_OUT_NUM_REG_RE            [i]));
    102 
     99                      << (*(in_READ_UNIT_OUT_NUM_REG_RE            [i]))
     100                      << (*(in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE [i]));
     101
     102            if (_param->_have_port_load_queue_ptr)
     103            sensitive  << (*(in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE  [i]));
    103104            if (_param->_have_port_context_id)
    104105            sensitive  << (*(in_READ_UNIT_OUT_CONTEXT_ID            [i]));
    … …  
    260261              }
    261262
     263            if (_param->_have_port_load_queue_ptr)
     264              {
    262265            (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
    263266
    … …  
    274277                (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID        [j]));
    275278              }
    276 
     279              }
     280           
    277281            (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
    278282
    … …  
    364368                (*(out_EXECUTE_UNIT_IN_WRITE_RD [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
    365369              }
    366 
     370           
    367371            (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
    368372

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit_allocation.cpp

    r77 r78  
    5959       ALLOC1_INTERFACE("read_unit_out", IN, EAST, "Output of read_unit", _param->_nb_read_unit);
    6060
    61        ALLOC1_VAL_IN ( in_READ_UNIT_OUT_VAL);
    62        ALLOC1_ACK_OUT(out_READ_UNIT_OUT_ACK);
     61       ALLOC1_VALACK_IN ( in_READ_UNIT_OUT_VAL,VAL);
     62       ALLOC1_VALACK_OUT(out_READ_UNIT_OUT_ACK,ACK);
    6363
    6464       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_CONTEXT_ID           ,"CONTEXT_ID"           ,Tcontext_t        ,_param->_size_context_id);
    … …  
    6868       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_OPERATION            ,"OPERATION"            ,Toperation_t      ,_param->_size_operation);
    6969       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_TYPE                 ,"TYPE"                 ,Ttype_t           ,_param->_size_type);
    70        ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE,"STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,_param->_size_store_queue);
    71        ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ,"LOAD_QUEUE_PTR_WRITE" ,Tlsq_ptr_t        ,_param->_size_load_queue);
     70       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE,"STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,log2(_param->_size_store_queue));
     71       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ,"LOAD_QUEUE_PTR_WRITE" ,Tlsq_ptr_t        ,log2(_param->_size_load_queue));
    7272       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_HAS_IMMEDIAT         ,"HAS_IMMEDIAT"         ,Tcontrol_t        ,1);
    7373       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_IMMEDIAT             ,"IMMEDIAT"             ,Tgeneral_data_t   ,_param->_size_general_data);
    … …  
    8282    // ~~~~~[ Interface "execute_unit_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    8383     {
    84        ALLOC1_INTERFACE("execute_unit_out", IN, EAST, "Output of execute_unit", _param->_nb_execute_unit);
    85 
    86        ALLOC1_VAL_OUT(out_EXECUTE_UNIT_IN_VAL);
    87        ALLOC1_ACK_IN ( in_EXECUTE_UNIT_IN_ACK);
     84       ALLOC1_INTERFACE("execute_unit_in", OUT, WEST, "Input of execute_unit", _param->_nb_execute_unit);
     85       
     86       ALLOC1_VALACK_OUT(out_EXECUTE_UNIT_IN_VAL,VAL);
     87       ALLOC1_VALACK_IN ( in_EXECUTE_UNIT_IN_ACK,ACK);
    8888
    8989       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_CONTEXT_ID           ,"CONTEXT_ID"           ,Tcontext_t        ,_param->_size_context_id);
    … …  
    9393       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_OPERATION            ,"OPERATION"            ,Toperation_t      ,_param->_size_operation);
    9494       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_TYPE                 ,"TYPE"                 ,Ttype_t           ,_param->_size_type);
    95        ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE,"STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,_param->_size_store_queue);
    96        ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,"LOAD_QUEUE_PTR_WRITE" ,Tlsq_ptr_t        ,_param->_size_load_queue);
    9795       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ,"HAS_IMMEDIAT"         ,Tcontrol_t        ,1);
     96       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_DATA_RC              ,"DATA_RC"              ,Tspecial_data_t   ,_param->_size_special_data);
     97       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_WRITE_RD             ,"WRITE_RD"             ,Tcontrol_t        ,1);
     98       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_WRITE_RE             ,"WRITE_RE"             ,Tcontrol_t        ,1);
     99       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_NUM_REG_RE           ,"NUM_REG_RE"           ,Tspecial_address_t,_param->_size_special_register);
     100       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE,"STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,log2(_param->_size_store_queue));
     101       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,"LOAD_QUEUE_PTR_WRITE" ,Tlsq_ptr_t        ,log2(_param->_size_load_queue));
    98102       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_IMMEDIAT             ,"IMMEDIAT"             ,Tgeneral_data_t   ,_param->_size_general_data);
    99103       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_DATA_RA              ,"DATA_RA"              ,Tgeneral_data_t   ,_param->_size_general_data);
    100104       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_DATA_RB              ,"DATA_RB"              ,Tgeneral_data_t   ,_param->_size_general_data);
    101        ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_DATA_RC              ,"DATA_RC"              ,Tspecial_data_t   ,_param->_size_special_data);
    102        ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_WRITE_RD             ,"WRITE_RD"             ,Tcontrol_t        ,1);
    103105       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_NUM_REG_RD           ,"NUM_REG_RD"           ,Tgeneral_address_t,_param->_size_general_register);
    104        ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_WRITE_RE             ,"WRITE_RE"             ,Tcontrol_t        ,1);
    105        ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_NUM_REG_RE           ,"NUM_REG_RE"           ,Tspecial_address_t,_param->_size_special_register);
    106106     }
    107107    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit_deallocation.cpp

    r77 r78  
    4242        delete [] in_READ_UNIT_OUT_TYPE                 ;
    4343        delete [] in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE;
     44        if (_param->_have_port_load_queue_ptr)
    4445        delete [] in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ;
    4546        delete [] in_READ_UNIT_OUT_HAS_IMMEDIAT         ;
    … …  
    6667        delete [] out_EXECUTE_UNIT_IN_OPERATION            ;
    6768        delete [] out_EXECUTE_UNIT_IN_TYPE                 ;
     69        delete [] out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ;
     70        delete [] out_EXECUTE_UNIT_IN_DATA_RC              ;
     71        delete [] out_EXECUTE_UNIT_IN_WRITE_RD             ;
     72        delete [] out_EXECUTE_UNIT_IN_WRITE_RE             ;
     73        delete [] out_EXECUTE_UNIT_IN_NUM_REG_RE           ;
    6874        delete [] out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE;
     75        if (_param->_have_port_load_queue_ptr)
    6976        delete [] out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ;
    70         delete [] out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ;
    7177        delete [] out_EXECUTE_UNIT_IN_IMMEDIAT             ;
    7278        delete [] out_EXECUTE_UNIT_IN_DATA_RA              ;
    7379        delete [] out_EXECUTE_UNIT_IN_DATA_RB              ;
    74         delete [] out_EXECUTE_UNIT_IN_DATA_RC              ;
    75         delete [] out_EXECUTE_UNIT_IN_WRITE_RD             ;
    7680        delete [] out_EXECUTE_UNIT_IN_NUM_REG_RD           ;
    77         delete [] out_EXECUTE_UNIT_IN_WRITE_RE             ;
    78         delete [] out_EXECUTE_UNIT_IN_NUM_REG_RE           ;
    7981      }
    8082    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit_genMealy.cpp

    r77 r78  
    7878                    PORT_WRITE(out_EXECUTE_UNIT_IN_OPERATION             [dest], PORT_READ(in_READ_UNIT_OUT_OPERATION             [i]));
    7979                    PORT_WRITE(out_EXECUTE_UNIT_IN_TYPE                  [dest], PORT_READ(in_READ_UNIT_OUT_TYPE                  [i]));
     80                    PORT_WRITE(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT          [dest], PORT_READ(in_READ_UNIT_OUT_HAS_IMMEDIAT          [i]));
     81                    PORT_WRITE(out_EXECUTE_UNIT_IN_DATA_RC               [dest], PORT_READ(in_READ_UNIT_OUT_DATA_RC               [i]));
     82                    PORT_WRITE(out_EXECUTE_UNIT_IN_WRITE_RD              [dest], PORT_READ(in_READ_UNIT_OUT_WRITE_RD              [i]));
     83                    PORT_WRITE(out_EXECUTE_UNIT_IN_WRITE_RE              [dest], PORT_READ(in_READ_UNIT_OUT_WRITE_RE              [i]));
     84                    PORT_WRITE(out_EXECUTE_UNIT_IN_NUM_REG_RE            [dest], PORT_READ(in_READ_UNIT_OUT_NUM_REG_RE            [i]));
    8085                    PORT_WRITE(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [dest], PORT_READ(in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE [i]));
     86                    if (_param->_have_port_load_queue_ptr)
    8187                    PORT_WRITE(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE  [dest], PORT_READ(in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE  [i]));
    82                     PORT_WRITE(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT          [dest], PORT_READ(in_READ_UNIT_OUT_HAS_IMMEDIAT          [i]));
    8388                    PORT_WRITE(out_EXECUTE_UNIT_IN_IMMEDIAT              [dest], PORT_READ(in_READ_UNIT_OUT_IMMEDIAT              [i]));
    8489                    PORT_WRITE(out_EXECUTE_UNIT_IN_DATA_RA               [dest], PORT_READ(in_READ_UNIT_OUT_DATA_RA               [i]));
    8590                    PORT_WRITE(out_EXECUTE_UNIT_IN_DATA_RB               [dest], PORT_READ(in_READ_UNIT_OUT_DATA_RB               [i]));
    86                     PORT_WRITE(out_EXECUTE_UNIT_IN_DATA_RC               [dest], PORT_READ(in_READ_UNIT_OUT_DATA_RC               [i]));
    87                     PORT_WRITE(out_EXECUTE_UNIT_IN_WRITE_RD              [dest], PORT_READ(in_READ_UNIT_OUT_WRITE_RD              [i]));
    8891                    PORT_WRITE(out_EXECUTE_UNIT_IN_NUM_REG_RD            [dest], PORT_READ(in_READ_UNIT_OUT_NUM_REG_RD            [i]));
    89                     PORT_WRITE(out_EXECUTE_UNIT_IN_WRITE_RE              [dest], PORT_READ(in_READ_UNIT_OUT_WRITE_RE              [i]));
    90                     PORT_WRITE(out_EXECUTE_UNIT_IN_NUM_REG_RE            [dest], PORT_READ(in_READ_UNIT_OUT_NUM_REG_RE            [i]));
    9192                  }
    9293              }

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/include/Parameters.h

    r75 r78  
    5050  public : ~Parameters () ;
    5151
    52   public :        std::string  msg_error  (void);
     52  public :        Parameters_test msg_error  (void);
    5353
    5454  public :        std::string   print      (uint32_t depth);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Parameters_msg_error.cpp

    r75 r78  
    2121#undef  FUNCTION
    2222#define FUNCTION "Register_unit_Glue::msg_error"
    23   std::string Parameters::msg_error(void)
     23  Parameters_test Parameters::msg_error(void)
    2424  {
    2525    log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
    2626
    27     std::string msg = "";
    28 
    29     return msg;
     27    Parameters_test test("Register_unit_Glue");
    3028
    3129    log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
     30
     31    return test;
    3232  };
    3333

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/include/Parameters.h

    r75 r78  
    7979  public : ~Parameters () ;
    8080
    81   public :        std::string  msg_error  (void);
     81  public :        Parameters_test msg_error  (void);
    8282  public :        std::string   print      (uint32_t depth);
    8383  public : friend std::ostream& operator<< (std::ostream& output_stream,

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/include/Register_unit.h

    r75 r78  
    55 * $Id$
    66 *
    7  * [ Description ]
     7 * [ Description ]
    88 *
    99 */
    … …  
    4545#endif
    4646  {
    47     // -----[ fields ]----------------------------------------------------
     47    // -----[ fields ]----------------------------------------------------
    4848    // Parameters
    4949  protected : const std::string       _name;
    … …  
    5959
    6060#ifdef SYSTEMC
    61     // ~~~~~[ Interface ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     61    // ~~~~~[ Interface ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    6262    // Interface
    6363  public    : SC_CLOCK                      *  in_CLOCK        ;
    6464  public    : SC_IN (Tcontrol_t)            *  in_NRESET       ;
    6565
    66     // ~~~~~[ Interface "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     66    // ~~~~~[ Interface "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    6767  public    : SC_IN (Tcontrol_t        )   **  in_GPR_READ_VAL                 ;
    6868  public    : SC_OUT(Tcontrol_t        )   ** out_GPR_READ_ACK                 ;
    … …  
    7272  public    : SC_OUT(Tcontrol_t        )   ** out_GPR_READ_DATA_VAL            ;
    7373
    74     // ~~~~~[ Interface "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     74    // ~~~~~[ Interface "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    7575  public    : SC_IN (Tcontrol_t        )   **  in_GPR_WRITE_VAL                ;
    7676  public    : SC_OUT(Tcontrol_t        )   ** out_GPR_WRITE_ACK                ;
    … …  
    7979  public    : SC_IN (Tgeneral_data_t   )   **  in_GPR_WRITE_DATA               ;
    8080
    81     // ~~~~~[ Interface "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     81    // ~~~~~[ Interface "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    8282  public    : SC_IN (Tcontrol_t        )   **  in_SPR_READ_VAL                 ;
    8383  public    : SC_OUT(Tcontrol_t        )   ** out_SPR_READ_ACK                 ;
    … …  
    8787  public    : SC_OUT(Tcontrol_t        )   ** out_SPR_READ_DATA_VAL            ;
    8888
    89     // ~~~~~[ Interface "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     89    // ~~~~~[ Interface "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    9090  public    : SC_IN (Tcontrol_t        )   **  in_SPR_WRITE_VAL                ;
    9191  public    : SC_OUT(Tcontrol_t        )   ** out_SPR_WRITE_ACK                ;
    … …  
    9494  public    : SC_IN (Tspecial_data_t   )   **  in_SPR_WRITE_DATA               ;
    9595   
    96     // ~~~~~[ Interface "insert_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     96    // ~~~~~[ Interface "insert_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    9797  public    : SC_IN (Tcontrol_t        )  ***  in_INSERT_ROB_VAL               ;
    9898  public    : SC_OUT(Tcontrol_t        )  *** out_INSERT_ROB_ACK               ;
    … …  
    102102  public    : SC_IN (Tspecial_address_t)  ***  in_INSERT_ROB_RE_NUM_REG        ;
    103103
    104     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     104    // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    105105  public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_VAL               ;
    106106  public    : SC_OUT(Tcontrol_t        )  *** out_RETIRE_ROB_ACK               ;
    … …  
    114114  public    : SC_IN (Tspecial_address_t)  ***  in_RETIRE_ROB_RE_NEW_NUM_REG    ;
    115115
    116     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
     116    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    117117  protected : morpheo::behavioural::generic::registerfile::RegisterFile::RegisterFile ** component_gpr       ;
    118118  protected : morpheo::behavioural::generic::registerfile::RegisterFile::RegisterFile ** component_gpr_status;
    … …  
    121121  protected : morpheo::behavioural::core::multi_execute_loop::execute_loop::register_unit::register_unit_glue::Register_unit_Glue::Register_unit_Glue      * component_glue      ;
    122122
    123     // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
     123    // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    124124
    125     // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     125    // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    126126#endif
    127127
    128     // -----[ methods ]---------------------------------------------------
     128    // -----[ methods ]---------------------------------------------------
    129129
    130130#ifdef SYSTEMC

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/src/Parameters_msg_error.cpp

    r75 r78  
    1818#undef  FUNCTION
    1919#define FUNCTION "Register_unit::msg_error"
    20   std::string Parameters::msg_error(void)
     20  Parameters_test Parameters::msg_error(void)
    2121  {
    2222    log_printf(FUNC,Register_unit,FUNCTION,"Begin");
    2323
    24     std::string msg = "";
    25 
    26     return msg;
     24    Parameters_test test("Register_unit");
    2725
    2826    log_printf(FUNC,Register_unit,FUNCTION,"End");
     27
     28    return test;
    2929  };
    3030

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/src/Register_unit_allocation.cpp

    r75 r78  
    240240
    241241            in_RETIRE_ROB_VAL            [i][j] = interface->set_signal_valack_in  (VAL);
    242             out_RETIRE_ROB_ACK            [i][j] = interface->set_signal_valack_out (ACK);
     242           out_RETIRE_ROB_ACK            [i][j] = interface->set_signal_valack_out (ACK);
    243243            in_RETIRE_ROB_RD_OLD_USE     [i][j] = interface->set_signal_in <Tcontrol_t        > ("rd_old_use"    , 1);
    244244            in_RETIRE_ROB_RD_OLD_NUM_REG [i][j] = interface->set_signal_in <Tgeneral_address_t> ("rd_old_num_reg", _param->_size_gpr_address);
    … …  
    470470                                   _name+"_glue",
    471471                                   "out_CONST_1");
     472
     473              _component->port_map(_name+"_glue",
     474                                   "out_CONST_1",
     475                                   name_component,
     476                                   "in_WRITE_"+toString(x)+"_DATA" );
     477
     478
    472479              _component->port_map(name_component,
    473480                                   "in_WRITE_"+toString(x++)+"_ADDRESS",
    … …  
    492499                                   "out_CONST_0"
    493500                                   );
     501              _component->port_map( _name+"_glue",
     502                                    "out_CONST_0",
     503                                    name_component,
     504                                   "in_WRITE_"+toString(x)+"_DATA");
    494505
    495506              _component->port_map(name_component,
    … …  
    515526                                   _name+"_glue",
    516527                                   "out_CONST_0");
     528              _component->port_map(_name+"_glue",
     529                                   "out_CONST_0",
     530                                   name_component,
     531                                   "in_WRITE_"+toString(x)+"_DATA" );
    517532
    518533              _component->port_map(name_component,
    … …  
    534549                                   _name+"_glue",
    535550                                   "out_CONST_1"
     551                                   );
     552              _component->port_map(_name+"_glue",
     553                                   "out_CONST_1",
     554                                   name_component,
     555                                   "in_WRITE_"+toString(x)+"_DATA"
    536556                                   );
    537557
    … …  
    651671                                   _name+"_glue",
    652672                                   "out_CONST_1");
     673              _component->port_map(_name+"_glue",
     674                                   "out_CONST_1",
     675                                   name_component,
     676                                   "in_WRITE_"+toString(x)+"_DATA"
     677                                   );
     678
    653679              _component->port_map(name_component,
    654680                                   "in_WRITE_"+toString(x++)+"_ADDRESS",
    … …  
    673699                                   "out_CONST_0"
    674700                                   );
     701              _component->port_map( _name+"_glue",
     702                                    "out_CONST_0",
     703                                   name_component,
     704                                   "in_WRITE_"+toString(x)+"_DATA"
     705                                   );
    675706
    676707              _component->port_map(name_component,
    … …  
    696727                                   _name+"_glue",
    697728                                   "out_CONST_0");
     729              _component->port_map(_name+"_glue",
     730                                   "out_CONST_0",
     731                                   name_component,
     732                                   "in_WRITE_"+toString(x)+"_DATA"
     733                                   );
    698734
    699735              _component->port_map(name_component,
    … …  
    715751                                   _name+"_glue",
    716752                                   "out_CONST_1"
     753                                   );
     754              _component->port_map(_name+"_glue",
     755                                   "out_CONST_1",
     756                                   name_component,
     757                                   "in_WRITE_"+toString(x)+"_DATA"
    717758                                   );
    718759
    … …  
    738779      _component->port_map(name_component,"in_CLOCK" , _name, "in_CLOCK" );
    739780      _component->port_map(name_component,"in_NRESET", _name, "in_NRESET");
    740       _component->port_map(name_component,"out_CONST_0");
    741       _component->port_map(name_component,"out_CONST_1");
     781//       _component->port_map(name_component,"out_CONST_0",_name,"out_CONST_0");
     782//       _component->port_map(name_component,"out_CONST_1",_name,"out_CONST_1");
    742783
    743784      for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
Note: See TracChangeset for help on using the changeset viewer.