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

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

Location:
trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop
Files:
32 edited

Legend:

Unmodified
Added
Removed

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Execute_loop_Glue/src/Execute_loop_Glue_allocation.cpp

    r88 r112  
    5858    // -----[ Interface "gpr_write_write_unit" ]--------------------------
    5959    {
    60       ALLOC1_INTERFACE("gpr_write_write_unit", IN, EAST, _("General register write (from write_unit)"), _param->_nb_gpr_write);
     60      ALLOC1_INTERFACE_BEGIN("gpr_write_write_unit", IN, EAST, _("General register write (from write_unit)"), _param->_nb_gpr_write);
    6161     
    6262      ALLOC1_VALACK_IN ( in_GPR_WRITE_WRITE_UNIT_VAL               ,VAL);
    … …  
    6565      ALLOC1_SIGNAL_IN ( in_GPR_WRITE_WRITE_UNIT_NUM_REG           ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
    6666      ALLOC1_SIGNAL_IN ( in_GPR_WRITE_WRITE_UNIT_DATA              ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data);
     67
     68      ALLOC1_INTERFACE_END(_param->_nb_gpr_write);
    6769    }
    6870
    6971    // -----[ Interface "gpr_write_register_file" ]-----------------------
    7072    {
    71       ALLOC1_INTERFACE("gpr_write_register_file",OUT,SOUTH, _("General register write (to register file)"), _param->_nb_gpr_write);
     73      ALLOC1_INTERFACE_BEGIN("gpr_write_register_file",OUT,SOUTH, _("General register write (to register file)"), _param->_nb_gpr_write);
    7274
    7375      ALLOC1_VALACK_OUT(out_GPR_WRITE_REGISTER_FILE_VAL            ,VAL);                                                         
    … …  
    7678      ALLOC1_SIGNAL_OUT(out_GPR_WRITE_REGISTER_FILE_NUM_REG        ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
    7779      ALLOC1_SIGNAL_OUT(out_GPR_WRITE_REGISTER_FILE_DATA           ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data);
     80
     81      ALLOC1_INTERFACE_END(_param->_nb_gpr_write);
    7882    }
    7983
    8084    // -----[ Interface "gpr_write_read_unit" ]---------------------------
    8185    {
    82       ALLOC1_INTERFACE("gpr_write_read_unit",OUT,SOUTH, _("General register write (to read unit)"), _param->_nb_gpr_write);
     86      ALLOC1_INTERFACE_BEGIN("gpr_write_read_unit",OUT,SOUTH, _("General register write (to read unit)"), _param->_nb_gpr_write);
    8387
    8488      ALLOC1_VALACK_OUT(out_GPR_WRITE_READ_UNIT_VAL                ,VAL);                                                         
    … …  
    8690      ALLOC1_SIGNAL_OUT(out_GPR_WRITE_READ_UNIT_NUM_REG            ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
    8791      ALLOC1_SIGNAL_OUT(out_GPR_WRITE_READ_UNIT_DATA               ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data);
     92
     93      ALLOC1_INTERFACE_END(_param->_nb_gpr_write);
    8894    }
    8995
    9096    // -----[ Interface "spr_write_write_unit" ]--------------------------
    9197    {
    92       ALLOC1_INTERFACE("spr_write_write_unit", IN, EAST, _("Special register write (from write_unit)"), _param->_nb_spr_write);
     98      ALLOC1_INTERFACE_BEGIN("spr_write_write_unit", IN, EAST, _("Special register write (from write_unit)"), _param->_nb_spr_write);
    9399     
    94100      ALLOC1_VALACK_IN ( in_SPR_WRITE_WRITE_UNIT_VAL               ,VAL);
    … …  
    97103      ALLOC1_SIGNAL_IN ( in_SPR_WRITE_WRITE_UNIT_NUM_REG           ,"num_reg"      ,Tspecial_address_t,_param->_size_special_register);
    98104      ALLOC1_SIGNAL_IN ( in_SPR_WRITE_WRITE_UNIT_DATA              ,"data"         ,Tspecial_data_t   ,_param->_size_special_data);
     105
     106      ALLOC1_INTERFACE_END(_param->_nb_spr_write);
    99107    }
    100108
    101109    // -----[ Interface "spr_write_register_file" ]-----------------------
    102110    {
    103       ALLOC1_INTERFACE("spr_write_register_file",OUT,SOUTH, _("Special register write (to register file)"), _param->_nb_spr_write);
     111      ALLOC1_INTERFACE_BEGIN("spr_write_register_file",OUT,SOUTH, _("Special register write (to register file)"), _param->_nb_spr_write);
    104112
    105113      ALLOC1_VALACK_OUT(out_SPR_WRITE_REGISTER_FILE_VAL            ,VAL);                                                         
    … …  
    108116      ALLOC1_SIGNAL_OUT(out_SPR_WRITE_REGISTER_FILE_NUM_REG        ,"num_reg"      ,Tspecial_address_t,_param->_size_special_register);
    109117      ALLOC1_SIGNAL_OUT(out_SPR_WRITE_REGISTER_FILE_DATA           ,"data"         ,Tspecial_data_t   ,_param->_size_special_data);
     118
     119      ALLOC1_INTERFACE_END(_param->_nb_spr_write);
    110120    }
    111121
    112122    // -----[ Interface "spr_write_read_unit" ]---------------------------
    113123    {
    114       ALLOC1_INTERFACE("spr_write_read_unit",OUT,SOUTH, _("Special register write (to read unit)"), _param->_nb_spr_write);
     124      ALLOC1_INTERFACE_BEGIN("spr_write_read_unit",OUT,SOUTH, _("Special register write (to read unit)"), _param->_nb_spr_write);
    115125
    116126      ALLOC1_VALACK_OUT(out_SPR_WRITE_READ_UNIT_VAL                ,VAL);                                                         
    … …  
    118128      ALLOC1_SIGNAL_OUT(out_SPR_WRITE_READ_UNIT_NUM_REG            ,"num_reg"      ,Tspecial_address_t,_param->_size_special_register);
    119129      ALLOC1_SIGNAL_OUT(out_SPR_WRITE_READ_UNIT_DATA               ,"data"         ,Tspecial_data_t   ,_param->_size_special_data);
     130
     131      ALLOC1_INTERFACE_END(_param->_nb_spr_write);
    120132    }
    121133

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

    r101 r112  
    77
    88#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/include/Functionnal_unit.h"
     9#include "Behavioural/include/Allocation.h"
    910
    1011namespace morpheo                    {
    … …  
    5051    // ~~~~~[ Interface : "execute_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    5152
    52      {
    53       Interface_fifo * interface = _interfaces->set_interface("execute_in"
    54 #ifdef POSITION
    55                                                               ,IN
    56                                                               ,WEST,
    57                                                               "Input of Functionnal Unit"
    58 #endif
    59                                                               );
    60 
    61        in_EXECUTE_IN_VAL           = interface->set_signal_valack_in  (VAL);
    62       out_EXECUTE_IN_ACK           = interface->set_signal_valack_out (ACK);
    63       if (_param->_have_port_context_id)
    64        in_EXECUTE_IN_CONTEXT_ID    = interface->set_signal_in <Tcontext_t        > ("context_id"   , _param->_size_context_id   );
    65       if (_param->_have_port_front_end_id)
    66        in_EXECUTE_IN_FRONT_END_ID  = interface->set_signal_in <Tcontext_t        > ("front_end_id" , _param->_size_front_end_id );
    67       if (_param->_have_port_ooo_engine_id)
    68        in_EXECUTE_IN_OOO_ENGINE_ID = interface->set_signal_in <Tcontext_t        > ("ooo_engine_id", _param->_size_ooo_engine_id);
    69       if (_param->_have_port_rob_ptr)
    70        in_EXECUTE_IN_PACKET_ID     = interface->set_signal_in <Tpacket_t         > ("packet_id"    , _param->_size_rob_ptr    );
    71        in_EXECUTE_IN_OPERATION     = interface->set_signal_in <Toperation_t      > ("operation"    , _param->_size_operation    );
    72        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",_param->_size_store_queue_ptr);
    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" ,_param->_size_load_queue_ptr);
    76        in_EXECUTE_IN_HAS_IMMEDIAT  = interface->set_signal_in <Tcontrol_t        > ("has_immediat" , 1);
    77        in_EXECUTE_IN_IMMEDIAT      = interface->set_signal_in <Tgeneral_data_t   > ("immediat"     , _param->_size_general_data);
    78        in_EXECUTE_IN_DATA_RA       = interface->set_signal_in <Tgeneral_data_t   > ("data_ra"      , _param->_size_general_data);
    79        in_EXECUTE_IN_DATA_RB       = interface->set_signal_in <Tgeneral_data_t   > ("data_rb"      , _param->_size_general_data);
    80        in_EXECUTE_IN_DATA_RC       = interface->set_signal_in <Tspecial_data_t   > ("data_rc"      , _param->_size_special_data);
    81        in_EXECUTE_IN_WRITE_RD      = interface->set_signal_in <Tcontrol_t        > ("write_rd"     , 1);
    82        in_EXECUTE_IN_NUM_REG_RD    = interface->set_signal_in <Tgeneral_address_t> ("num_reg_rd"   , _param->_size_general_register);
    83        in_EXECUTE_IN_WRITE_RE      = interface->set_signal_in <Tcontrol_t        > ("write_re"     , 1);
    84        in_EXECUTE_IN_NUM_REG_RE    = interface->set_signal_in <Tspecial_address_t> ("num_reg_re"   , _param->_size_special_register);
     53    {
     54      ALLOC0_INTERFACE_BEGIN("execute_in",IN,WEST,"Input of Functionnal Unit");
     55
     56      ALLOC0_VALACK_IN ( in_EXECUTE_IN_VAL                   ,VAL);
     57      ALLOC0_VALACK_OUT(out_EXECUTE_IN_ACK                   ,ACK);
     58      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_CONTEXT_ID            ,"context_id"           ,Tcontext_t        , _param->_size_context_id   );
     59      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_FRONT_END_ID          ,"front_end_id"         ,Tcontext_t        , _param->_size_front_end_id );
     60      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_OOO_ENGINE_ID         ,"ooo_engine_id"        ,Tcontext_t        , _param->_size_ooo_engine_id);
     61      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_PACKET_ID             ,"packet_id"            ,Tpacket_t         , _param->_size_rob_ptr    );
     62      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_OPERATION             ,"operation"            ,Toperation_t      , _param->_size_operation    );
     63      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_TYPE                  ,"type"                 ,Ttype_t           , _param->_size_type         );
     64      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_STORE_QUEUE_PTR_WRITE ,"store_queue_ptr_write",Tlsq_ptr_t        ,_param->_size_store_queue_ptr);
     65      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_LOAD_QUEUE_PTR_WRITE  ,"load_queue_ptr_write" ,Tlsq_ptr_t        ,_param->_size_load_queue_ptr);
     66      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_HAS_IMMEDIAT          ,"has_immediat"         ,Tcontrol_t        , 1);
     67      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_IMMEDIAT              ,"immediat"             ,Tgeneral_data_t   , _param->_size_general_data);
     68      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_DATA_RA               ,"data_ra"              ,Tgeneral_data_t   , _param->_size_general_data);
     69      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_DATA_RB               ,"data_rb"              ,Tgeneral_data_t   , _param->_size_general_data);
     70      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_DATA_RC               ,"data_rc"              ,Tspecial_data_t   , _param->_size_special_data);
     71      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_WRITE_RD              ,"write_rd"             ,Tcontrol_t        , 1);
     72      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_NUM_REG_RD            ,"num_reg_rd"           ,Tgeneral_address_t, _param->_size_general_register);
     73      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_WRITE_RE              ,"write_re"             ,Tcontrol_t        , 1);
     74      ALLOC0_SIGNAL_IN ( in_EXECUTE_IN_NUM_REG_RE            ,"num_reg_re"           ,Tspecial_address_t, _param->_size_special_register);
     75
     76      ALLOC0_INTERFACE_END();
    8577     }
    8678    // ~~~~~[ Interface : "execute_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~     
    8779     {
    88        Interface_fifo * interface = _interfaces->set_interface("execute_out"
    89 #ifdef POSITION
    90                                                                ,IN
    91                                                                ,EAST,
    92                                                                "Output of Functionnal Unit"
    93 #endif
    94                                                                );
    95 
    96        out_EXECUTE_OUT_VAL            = interface->set_signal_valack_out (VAL);
    97         in_EXECUTE_OUT_ACK            = interface->set_signal_valack_in  (ACK);
    98        if (_param->_have_port_context_id)
    99        out_EXECUTE_OUT_CONTEXT_ID     = interface->set_signal_out<Tcontext_t        > ("context_id"   ,_param->_size_context_id   );
    100        if (_param->_have_port_front_end_id)
    101        out_EXECUTE_OUT_FRONT_END_ID   = interface->set_signal_out<Tcontext_t        > ("front_end_id" ,_param->_size_front_end_id );
    102        if (_param->_have_port_ooo_engine_id)
    103        out_EXECUTE_OUT_OOO_ENGINE_ID  = interface->set_signal_out<Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id);
    104        if (_param->_have_port_rob_ptr)
    105        out_EXECUTE_OUT_PACKET_ID      = interface->set_signal_out<Tpacket_t         > ("packet_id"    ,_param->_size_rob_ptr    );
    106      //out_EXECUTE_OUT_OPERATION      = interface->set_signal_out<Toperation_t      > ("operation"    ,_param->_size_operation    );
    107      //out_EXECUTE_OUT_TYPE           = interface->set_signal_out<Ttype_t           > ("type"         ,_param->_size_type         );
    108        out_EXECUTE_OUT_WRITE_RD       = interface->set_signal_out<Tcontrol_t        > ("write_rd"     ,1);
    109        out_EXECUTE_OUT_NUM_REG_RD     = interface->set_signal_out<Tgeneral_address_t> ("num_reg_rd"   ,_param->_size_general_register);
    110        out_EXECUTE_OUT_DATA_RD        = interface->set_signal_out<Tgeneral_data_t   > ("data_rd"      ,_param->_size_general_data);
    111        out_EXECUTE_OUT_WRITE_RE       = interface->set_signal_out<Tcontrol_t        > ("write_re"     ,1);
    112        out_EXECUTE_OUT_NUM_REG_RE     = interface->set_signal_out<Tspecial_address_t> ("num_reg_re"   ,_param->_size_special_register);
    113        out_EXECUTE_OUT_DATA_RE        = interface->set_signal_out<Tspecial_data_t   > ("data_re"      ,_param->_size_special_data);
    114        out_EXECUTE_OUT_EXCEPTION      = interface->set_signal_out<Texception_t      > ("exception"    ,_param->_size_exception);
    115        out_EXECUTE_OUT_NO_SEQUENCE    = interface->set_signal_out<Tcontrol_t        > ("no_sequence"  ,1);
    116        out_EXECUTE_OUT_ADDRESS        = interface->set_signal_out<Taddress_t        > ("address"      ,_param->_size_instruction_address);
     80       ALLOC0_INTERFACE_BEGIN("execute_out",IN,EAST,"Output of Functionnal Unit");
     81
     82       ALLOC0_VALACK_OUT(out_EXECUTE_OUT_VAL            ,VAL);
     83       ALLOC0_VALACK_IN ( in_EXECUTE_OUT_ACK            ,ACK);
     84       ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_CONTEXT_ID     ,"context_id"   ,Tcontext_t        ,_param->_size_context_id   );
     85       ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_FRONT_END_ID   ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id );
     86       ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_OOO_ENGINE_ID  ,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id);
     87       ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_PACKET_ID      ,"packet_id"    ,Tpacket_t         ,_param->_size_rob_ptr    );
     88     //ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_OPERATION      ,"operation"    ,Toperation_t      ,_param->_size_operation    );
     89     //ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_TYPE           ,"type"         ,Ttype_t           ,_param->_size_type         );
     90       ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_WRITE_RD       ,"write_rd"     ,Tcontrol_t        ,1);
     91       ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_NUM_REG_RD     ,"num_reg_rd"   ,Tgeneral_address_t,_param->_size_general_register);
     92       ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_DATA_RD        ,"data_rd"      ,Tgeneral_data_t   ,_param->_size_general_data);
     93       ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_WRITE_RE       ,"write_re"     ,Tcontrol_t        ,1);
     94       ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_NUM_REG_RE     ,"num_reg_re"   ,Tspecial_address_t,_param->_size_special_register);
     95       ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_DATA_RE        ,"data_re"      ,Tspecial_data_t   ,_param->_size_special_data);
     96       ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_EXCEPTION      ,"exception"    ,Texception_t      ,_param->_size_exception);
     97       ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_NO_SEQUENCE    ,"no_sequence"  ,Tcontrol_t        ,1);
     98       ALLOC0_SIGNAL_OUT(out_EXECUTE_OUT_ADDRESS        ,"address"      ,Taddress_t        ,_param->_size_instruction_address);
     99
     100       ALLOC0_INTERFACE_END();
    117101     }
    118102

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

    r97 r112  
    77
    88#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/include/Functionnal_unit.h"
     9#include "Behavioural/include/Allocation.h"
    910
    1011namespace morpheo                    {
    … …  
    2930        delete    in_NRESET;
    3031       
    31         delete  in_EXECUTE_IN_VAL           ;
    32         delete out_EXECUTE_IN_ACK           ;
    33         if (_param->_have_port_context_id)
    34         delete  in_EXECUTE_IN_CONTEXT_ID    ;
    35         if (_param->_have_port_front_end_id)
    36         delete  in_EXECUTE_IN_FRONT_END_ID  ;
    37         if (_param->_have_port_ooo_engine_id)
    38         delete  in_EXECUTE_IN_OOO_ENGINE_ID ;
    39         if (_param->_have_port_rob_ptr)
    40         delete  in_EXECUTE_IN_PACKET_ID     ;
    41         delete  in_EXECUTE_IN_OPERATION     ;
    42         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 ;
    46         delete  in_EXECUTE_IN_HAS_IMMEDIAT  ;
    47         delete  in_EXECUTE_IN_IMMEDIAT      ;
    48         delete  in_EXECUTE_IN_DATA_RA       ;
    49         delete  in_EXECUTE_IN_DATA_RB       ;
    50         delete  in_EXECUTE_IN_DATA_RC       ;
    51         delete  in_EXECUTE_IN_WRITE_RD      ;
    52         delete  in_EXECUTE_IN_NUM_REG_RD    ;
    53         delete  in_EXECUTE_IN_WRITE_RE      ;
    54         delete  in_EXECUTE_IN_NUM_REG_RE    ;
     32        DELETE0_SIGNAL( in_EXECUTE_IN_VAL                   ,1);
     33        DELETE0_SIGNAL(out_EXECUTE_IN_ACK                   ,1);
     34        DELETE0_SIGNAL( in_EXECUTE_IN_CONTEXT_ID            , _param->_size_context_id   );
     35        DELETE0_SIGNAL( in_EXECUTE_IN_FRONT_END_ID          , _param->_size_front_end_id );
     36        DELETE0_SIGNAL( in_EXECUTE_IN_OOO_ENGINE_ID         , _param->_size_ooo_engine_id);
     37        DELETE0_SIGNAL( in_EXECUTE_IN_PACKET_ID             , _param->_size_rob_ptr    );
     38        DELETE0_SIGNAL( in_EXECUTE_IN_OPERATION             , _param->_size_operation    );
     39        DELETE0_SIGNAL( in_EXECUTE_IN_TYPE                  , _param->_size_type         );
     40        DELETE0_SIGNAL( in_EXECUTE_IN_STORE_QUEUE_PTR_WRITE ,_param->_size_store_queue_ptr);
     41        DELETE0_SIGNAL( in_EXECUTE_IN_LOAD_QUEUE_PTR_WRITE  ,_param->_size_load_queue_ptr);
     42        DELETE0_SIGNAL( in_EXECUTE_IN_HAS_IMMEDIAT          , 1);
     43        DELETE0_SIGNAL( in_EXECUTE_IN_IMMEDIAT              , _param->_size_general_data);
     44        DELETE0_SIGNAL( in_EXECUTE_IN_DATA_RA               , _param->_size_general_data);
     45        DELETE0_SIGNAL( in_EXECUTE_IN_DATA_RB               , _param->_size_general_data);
     46        DELETE0_SIGNAL( in_EXECUTE_IN_DATA_RC               , _param->_size_special_data);
     47        DELETE0_SIGNAL( in_EXECUTE_IN_WRITE_RD              , 1);
     48        DELETE0_SIGNAL( in_EXECUTE_IN_NUM_REG_RD            , _param->_size_general_register);
     49        DELETE0_SIGNAL( in_EXECUTE_IN_WRITE_RE              , 1);
     50        DELETE0_SIGNAL( in_EXECUTE_IN_NUM_REG_RE            , _param->_size_special_register);
    5551
    56         delete out_EXECUTE_OUT_VAL            ;
    57         delete  in_EXECUTE_OUT_ACK            ;
    58         if (_param->_have_port_context_id)
    59         delete out_EXECUTE_OUT_CONTEXT_ID     ;
    60         if (_param->_have_port_front_end_id)
    61         delete out_EXECUTE_OUT_FRONT_END_ID   ;
    62         if (_param->_have_port_ooo_engine_id)
    63         delete out_EXECUTE_OUT_OOO_ENGINE_ID  ;
    64         if (_param->_have_port_rob_ptr)
    65         delete out_EXECUTE_OUT_PACKET_ID      ;
    66 //      delete out_EXECUTE_OUT_OPERATION      ;
    67 //      delete out_EXECUTE_OUT_TYPE           ;
    68         delete out_EXECUTE_OUT_WRITE_RD       ;
    69         delete out_EXECUTE_OUT_NUM_REG_RD     ;
    70         delete out_EXECUTE_OUT_DATA_RD        ;
    71         delete out_EXECUTE_OUT_WRITE_RE       ;
    72         delete out_EXECUTE_OUT_NUM_REG_RE     ;
    73         delete out_EXECUTE_OUT_DATA_RE        ;
    74         delete out_EXECUTE_OUT_EXCEPTION      ;
    75         delete out_EXECUTE_OUT_NO_SEQUENCE    ;
    76         delete out_EXECUTE_OUT_ADDRESS        ;
     52        DELETE0_SIGNAL(out_EXECUTE_OUT_VAL            ,1);
     53        DELETE0_SIGNAL( in_EXECUTE_OUT_ACK            ,1);
     54        DELETE0_SIGNAL(out_EXECUTE_OUT_CONTEXT_ID     ,_param->_size_context_id   );
     55        DELETE0_SIGNAL(out_EXECUTE_OUT_FRONT_END_ID   ,_param->_size_front_end_id );
     56        DELETE0_SIGNAL(out_EXECUTE_OUT_OOO_ENGINE_ID  ,_param->_size_ooo_engine_id);
     57        DELETE0_SIGNAL(out_EXECUTE_OUT_PACKET_ID      ,_param->_size_rob_ptr    );
     58      //DELETE0_SIGNAL(out_EXECUTE_OUT_OPERATION      ,_param->_size_operation    );
     59      //DELETE0_SIGNAL(out_EXECUTE_OUT_TYPE           ,_param->_size_type         );
     60        DELETE0_SIGNAL(out_EXECUTE_OUT_WRITE_RD       ,1);
     61        DELETE0_SIGNAL(out_EXECUTE_OUT_NUM_REG_RD     ,_param->_size_general_register);
     62        DELETE0_SIGNAL(out_EXECUTE_OUT_DATA_RD        ,_param->_size_general_data);
     63        DELETE0_SIGNAL(out_EXECUTE_OUT_WRITE_RE       ,1);
     64        DELETE0_SIGNAL(out_EXECUTE_OUT_NUM_REG_RE     ,_param->_size_special_register);
     65        DELETE0_SIGNAL(out_EXECUTE_OUT_DATA_RE        ,_param->_size_special_data);
     66        DELETE0_SIGNAL(out_EXECUTE_OUT_EXCEPTION      ,_param->_size_exception);
     67        DELETE0_SIGNAL(out_EXECUTE_OUT_NO_SEQUENCE    ,1);
     68        DELETE0_SIGNAL(out_EXECUTE_OUT_ADDRESS        ,_param->_size_instruction_address);
    7769
    7870        // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   

  • 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

    r97 r112  
    5454    // ~~~~~[ Interface "memory_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    5555    {
    56       ALLOC1_INTERFACE("memory_in",IN,WEST,_("Instruction from Reservations station"),_param->_nb_inst_memory);
     56      ALLOC1_INTERFACE_BEGIN("memory_in",IN,WEST,_("Instruction from Reservations station"),_param->_nb_inst_memory);
    5757
    5858      ALLOC1_VALACK_IN ( in_MEMORY_IN_VAL                  ,VAL);
    … …  
    7575      ALLOC1_SIGNAL_IN ( in_MEMORY_IN_WRITE_RE             ,"write_re"             ,Tcontrol_t        ,1                                  );
    7676      ALLOC1_SIGNAL_IN ( in_MEMORY_IN_NUM_REG_RE           ,"num_reg_re"           ,Tspecial_address_t,_param->_size_special_register     );
     77   
     78      ALLOC1_INTERFACE_END(_param->_nb_inst_memory);
    7779    }
    7880
    7981    // ~~~~~[ Interface "memory_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    8082    {
    81       ALLOC1_INTERFACE("memory_out",OUT,EAST,_("Instruction to write queue"),_param->_nb_inst_memory);
     83      ALLOC1_INTERFACE_BEGIN("memory_out",OUT,EAST,_("Instruction to write queue"),_param->_nb_inst_memory);
    8284
    8385      ALLOC1_VALACK_OUT(out_MEMORY_OUT_VAL          ,VAL);
    … …  
    98100      ALLOC1_SIGNAL_OUT(out_MEMORY_OUT_NO_SEQUENCE  ,"no_sequence"   ,Tcontrol_t        ,1                              );
    99101      ALLOC1_SIGNAL_OUT(out_MEMORY_OUT_ADDRESS      ,"address"       ,Taddress_t        ,_param->_size_instruction_address);
     102   
     103      ALLOC1_INTERFACE_END(_param->_nb_inst_memory);
    100104    }
    101105
    102106    // ~~~~~[ Interface "dcache_req" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    103107    {
    104       ALLOC1_INTERFACE("dcache_req",OUT,NORTH,_("Request port to dcache"),_param->_nb_cache_port);
     108      ALLOC1_INTERFACE_BEGIN("dcache_req",OUT,NORTH,_("Request port to dcache"),_param->_nb_cache_port);
    105109
    106110      ALLOC1_VALACK_OUT(out_DCACHE_REQ_VAL        ,VAL);
    … …  
    111115      ALLOC1_SIGNAL_OUT(out_DCACHE_REQ_TYPE       ,"type"      ,Tdcache_type_t   ,_param->_size_dcache_type );
    112116      ALLOC1_SIGNAL_OUT(out_DCACHE_REQ_WDATA      ,"wdata"     ,Tdcache_data_t   ,_param->_size_general_data);
     117   
     118      ALLOC1_INTERFACE_END(_param->_nb_cache_port);
    113119    }
    114120
    115121    // ~~~~~[ Interface "dcache_rsp" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    116122    {
    117       ALLOC1_INTERFACE("dcache_rsp",IN,NORTH,_("Respons port from dcache"),_param->_nb_cache_port);
     123      ALLOC1_INTERFACE_BEGIN("dcache_rsp",IN,NORTH,_("Respons port from dcache"),_param->_nb_cache_port);
    118124
    119125      ALLOC1_VALACK_IN ( in_DCACHE_RSP_VAL        ,VAL);
    … …  
    123129      ALLOC1_SIGNAL_IN ( in_DCACHE_RSP_RDATA      ,"rdata"     ,Tdcache_data_t ,_param->_size_general_data);
    124130      ALLOC1_SIGNAL_IN ( in_DCACHE_RSP_ERROR      ,"error"     ,Tdcache_error_t,_param->_size_dcache_error);
     131
     132      ALLOC1_INTERFACE_END(_param->_nb_cache_port);
    125133    }
    126134    // ~~~~~[ Interface "bypass_memory" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    127135
    128136    {
    129       ALLOC1_INTERFACE("bypass_memory",OUT,NORTH,_("Bypass between the load queue and the reservation station"),_param->_nb_bypass_memory);
     137      ALLOC1_INTERFACE_BEGIN("bypass_memory",OUT,NORTH,_("Bypass between the load queue and the reservation station"),_param->_nb_bypass_memory);
    130138           
    131139      ALLOC1_VALACK_OUT(out_BYPASS_MEMORY_VAL           ,VAL);
    … …  
    133141      ALLOC1_SIGNAL_OUT(out_BYPASS_MEMORY_NUM_REG       ,"num_reg"      ,Tgeneral_address_t, _param->_size_general_register);
    134142      ALLOC1_SIGNAL_OUT(out_BYPASS_MEMORY_DATA          ,"data"         ,Tgeneral_data_t   , _param->_size_general_data    );
     143
     144      ALLOC1_INTERFACE_END(_param->_nb_bypass_memory);
    135145    }
    136146

  • 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

    r110 r112  
    596596
    597597                          // check find a bypass. A speculative load have been committed : report a speculation miss.
    598                           if ((_load_queue[index_load]._check_hit != 0)// and
    599 //                               (_load_queue[index_load]._write_rd  == 0)
     598                          if ((_load_queue[index_load]._check_hit != 0) and
     599                              (_load_queue[index_load]._write_rd  == 0) // is commit
    600600                              )
    601601                            {

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

    r88 r112  
    88
    99#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/include/Read_queue.h"
     10#include "Behavioural/include/Allocation.h"
    1011
    1112namespace morpheo                    {
    … …  
    5051    // ~~~~~[ Interface : "read_queue_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    5152    {
    52       Interface_fifo * interface = _interfaces->set_interface("read_queue_in"
    53 #ifdef POSITION
    54                                                               ,IN
    55                                                               ,EAST
    56                                                               ,"Input of read_queue"
    57 #endif
    58                                                               );
     53      ALLOC0_INTERFACE_BEGIN("read_queue_in",IN,EAST,"Input of read_queue");
    5954
    60        in_READ_QUEUE_IN_VAL            = interface->set_signal_valack_in        ("val"    , VAL);
    61       out_READ_QUEUE_IN_ACK            = interface->set_signal_valack_out       ("ack"    , ACK);
    62       if(_param->_have_port_context_id  )
    63        in_READ_QUEUE_IN_CONTEXT_ID     = interface->set_signal_in  <Tcontext_t        > ("context_id"   ,_param->_size_context_id       );
    64       if(_param->_have_port_front_end_id)
    65        in_READ_QUEUE_IN_FRONT_END_ID   = interface->set_signal_in  <Tcontext_t        > ("front_end_id" ,_param->_size_front_end_id     );
    66        if(_param->_have_port_ooo_engine_id)
    67          in_READ_QUEUE_IN_OOO_ENGINE_ID  = interface->set_signal_in  <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id    );
    68       if(_param->_have_port_rob_ptr      )
    69        in_READ_QUEUE_IN_ROB_ID         = interface->set_signal_in  <Tpacket_t         > ("rob_id"      ,_param->_size_rob_ptr           );
    70        in_READ_QUEUE_IN_OPERATION      = interface->set_signal_in  <Toperation_t      > ("operation"   ,_param->_size_operation        );
    71        in_READ_QUEUE_IN_TYPE           = interface->set_signal_in  <Ttype_t           > ("type"        ,_param->_size_type             );
    72        in_READ_QUEUE_IN_STORE_QUEUE_PTR_WRITE = interface->set_signal_in  <Tlsq_ptr_t> ("store_queue_ptr_write", _param->_size_store_queue_ptr);
    73        if (_param->_have_port_load_queue_ptr)
    74        in_READ_QUEUE_IN_LOAD_QUEUE_PTR_WRITE  = interface->set_signal_in  <Tlsq_ptr_t> ("load_queue_ptr_write" , _param->_size_load_queue_ptr);
    75        in_READ_QUEUE_IN_HAS_IMMEDIAT   = interface->set_signal_in  <Tcontrol_t        > ("has_immediat",1                             );
    76        in_READ_QUEUE_IN_IMMEDIAT       = interface->set_signal_in  <Tgeneral_data_t   > ("immediat"    ,_param->_size_general_data     );
    77        in_READ_QUEUE_IN_READ_RA        = interface->set_signal_in  <Tcontrol_t        > ("read_ra"     ,1                             );
    78        in_READ_QUEUE_IN_NUM_REG_RA     = interface->set_signal_in  <Tgeneral_address_t> ("num_reg_ra"  ,_param->_size_general_register );
    79        in_READ_QUEUE_IN_READ_RB        = interface->set_signal_in  <Tcontrol_t        > ("read_rb"     ,1                             );
    80        in_READ_QUEUE_IN_NUM_REG_RB     = interface->set_signal_in  <Tgeneral_address_t> ("num_reg_rb"  ,_param->_size_general_register );
    81        in_READ_QUEUE_IN_READ_RC        = interface->set_signal_in  <Tcontrol_t        > ("read_rc"     ,1                             );
    82        in_READ_QUEUE_IN_NUM_REG_RC     = interface->set_signal_in  <Tspecial_address_t> ("num_reg_rc"  ,_param->_size_special_register );
    83        in_READ_QUEUE_IN_WRITE_RD       = interface->set_signal_in  <Tcontrol_t        > ("write_rd"    ,1                             );
    84        in_READ_QUEUE_IN_NUM_REG_RD     = interface->set_signal_in  <Tgeneral_address_t> ("num_reg_rd"  ,_param->_size_general_register );
    85        in_READ_QUEUE_IN_WRITE_RE       = interface->set_signal_in  <Tcontrol_t        > ("write_re"    ,1                             );
    86        in_READ_QUEUE_IN_NUM_REG_RE     = interface->set_signal_in  <Tspecial_address_t> ("num_reg_re"  ,_param->_size_special_register );     
    87      }
     55      ALLOC0_VALACK_IN ( in_READ_QUEUE_IN_VAL                  ,VAL);
     56      ALLOC0_VALACK_OUT(out_READ_QUEUE_IN_ACK                  ,ACK);
     57      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_CONTEXT_ID           ,"context_id"           ,Tcontext_t        ,_param->_size_context_id      );
     58      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_FRONT_END_ID         ,"front_end_id"         ,Tcontext_t        ,_param->_size_front_end_id    );
     59      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_OOO_ENGINE_ID        ,"ooo_engine_id"        ,Tcontext_t        ,_param->_size_ooo_engine_id   );
     60      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_ROB_ID               ,"rob_id"               ,Tpacket_t         ,_param->_size_rob_ptr         );
     61      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_OPERATION            ,"operation"            ,Toperation_t      ,_param->_size_operation       );
     62      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_TYPE                 ,"type"                 ,Ttype_t           ,_param->_size_type            );
     63      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_STORE_QUEUE_PTR_WRITE,"store_queue_ptr_write",Tlsq_ptr_t        ,_param->_size_store_queue_ptr);
     64      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_LOAD_QUEUE_PTR_WRITE ,"load_queue_ptr_write" ,Tlsq_ptr_t        ,_param->_size_load_queue_ptr);
     65      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_HAS_IMMEDIAT         ,"has_immediat"         ,Tcontrol_t        ,1                             );
     66      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_IMMEDIAT             ,"immediat"             ,Tgeneral_data_t   ,_param->_size_general_data    );
     67      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_READ_RA              ,"read_ra"              ,Tcontrol_t        ,1                             );
     68      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_NUM_REG_RA           ,"num_reg_ra"           ,Tgeneral_address_t,_param->_size_general_register);
     69      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_READ_RB              ,"read_rb"              ,Tcontrol_t        ,1                             );
     70      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_NUM_REG_RB           ,"num_reg_rb"           ,Tgeneral_address_t,_param->_size_general_register);
     71      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_READ_RC              ,"read_rc"              ,Tcontrol_t        ,1                             );
     72      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_NUM_REG_RC           ,"num_reg_rc"           ,Tspecial_address_t,_param->_size_special_register);
     73      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_WRITE_RD             ,"write_rd"             ,Tcontrol_t        ,1                             );
     74      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_NUM_REG_RD           ,"num_reg_rd"           ,Tgeneral_address_t,_param->_size_general_register);
     75      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_WRITE_RE             ,"write_re"             ,Tcontrol_t        ,1                             );
     76      ALLOC0_SIGNAL_IN ( in_READ_QUEUE_IN_NUM_REG_RE           ,"num_reg_re"           ,Tspecial_address_t,_param->_size_special_register);     
     77     
     78      ALLOC0_INTERFACE_END();
     79    }
    8880
    8981    // ~~~~~[ Interface : "read_queue_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    9082    {
    91       Interface_fifo * interface = _interfaces->set_interface("read_queue_out"
    92 #ifdef POSITION
    93                                                                ,OUT
    94                                                                ,EAST
    95                                                                ,"Input of read_queue"
    96 #endif
    97                                                                );
     83      ALLOC0_INTERFACE_BEGIN("read_queue_out",OUT,EAST,"Input of read_queue");
    9884     
    99       out_READ_QUEUE_OUT_VAL            = interface->set_signal_valack_out       ("val"    , VAL);
    100        in_READ_QUEUE_OUT_ACK            = interface->set_signal_valack_in        ("ack"    , ACK);
    101 
    102       if(_param->_have_port_context_id  )
    103         out_READ_QUEUE_OUT_CONTEXT_ID     = interface->set_signal_out <Tcontext_t        > ("context_id"   ,_param->_size_context_id       );
    104       if(_param->_have_port_front_end_id)
    105         out_READ_QUEUE_OUT_FRONT_END_ID   = interface->set_signal_out <Tcontext_t        > ("front_end_id" ,_param->_size_front_end_id     );
    106       if(_param->_have_port_ooo_engine_id)
    107         out_READ_QUEUE_OUT_OOO_ENGINE_ID  = interface->set_signal_out <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id    );
    108       if(_param->_have_port_rob_ptr      )
    109         out_READ_QUEUE_OUT_ROB_ID         = interface->set_signal_out <Tpacket_t         > ("rob_id"      ,_param->_size_rob_ptr           );
    110       out_READ_QUEUE_OUT_OPERATION      = interface->set_signal_out <Toperation_t      > ("operation"   ,_param->_size_operation        );
    111       out_READ_QUEUE_OUT_TYPE           = interface->set_signal_out <Ttype_t           > ("type"        ,_param->_size_type             );
    112       out_READ_QUEUE_OUT_STORE_QUEUE_PTR_WRITE = interface->set_signal_out <Tlsq_ptr_t> ("store_queue_ptr_write", _param->_size_store_queue_ptr);
    113       if (_param->_have_port_load_queue_ptr)
    114       out_READ_QUEUE_OUT_LOAD_QUEUE_PTR_WRITE  = interface->set_signal_out <Tlsq_ptr_t> ("load_queue_ptr_write" , _param->_size_load_queue_ptr);
    115       out_READ_QUEUE_OUT_HAS_IMMEDIAT   = interface->set_signal_out <Tcontrol_t        > ("has_immediat",1                             );
    116       out_READ_QUEUE_OUT_IMMEDIAT       = interface->set_signal_out <Tgeneral_data_t   > ("immediat"    ,_param->_size_general_data     );
    117 //       out_READ_QUEUE_OUT_READ_RA        = interface->set_signal_out <Tcontrol_t        > ("read_ra"     ,1                             );
    118       out_READ_QUEUE_OUT_NUM_REG_RA     = interface->set_signal_out <Tgeneral_address_t> ("num_reg_ra"  ,_param->_size_general_register );
    119       out_READ_QUEUE_OUT_DATA_RA_VAL    = interface->set_signal_out <Tcontrol_t        > ("data_ra_val" ,1                             );
    120       out_READ_QUEUE_OUT_DATA_RA        = interface->set_signal_out <Tgeneral_data_t   > ("data_ra"     ,_param->_size_general_data     );
    121 //       out_READ_QUEUE_OUT_READ_RB        = interface->set_signal_out <Tcontrol_t        > ("read_rb"     ,1                             );
    122       out_READ_QUEUE_OUT_NUM_REG_RB     = interface->set_signal_out <Tgeneral_address_t> ("num_reg_rb"  ,_param->_size_general_register );
    123       out_READ_QUEUE_OUT_DATA_RB_VAL    = interface->set_signal_out <Tcontrol_t        > ("data_rb_val" ,1                             );
    124       out_READ_QUEUE_OUT_DATA_RB        = interface->set_signal_out <Tgeneral_data_t   > ("data_rb"     ,_param->_size_general_data     );
    125 //       out_READ_QUEUE_OUT_READ_RC        = interface->set_signal_out <Tcontrol_t        > ("read_rc"     ,1                             );
    126       out_READ_QUEUE_OUT_NUM_REG_RC     = interface->set_signal_out <Tspecial_address_t> ("num_reg_rc"  ,_param->_size_special_register );
    127       out_READ_QUEUE_OUT_DATA_RC_VAL    = interface->set_signal_out <Tcontrol_t        > ("data_rc_val" ,1                             );
    128       out_READ_QUEUE_OUT_DATA_RC        = interface->set_signal_out <Tspecial_data_t   > ("data_rc"     ,_param->_size_special_data     );
    129       out_READ_QUEUE_OUT_WRITE_RD       = interface->set_signal_out <Tcontrol_t        > ("write_rd"    ,1                             );
    130       out_READ_QUEUE_OUT_NUM_REG_RD     = interface->set_signal_out <Tgeneral_address_t> ("num_reg_rd"  ,_param->_size_general_register );
    131       out_READ_QUEUE_OUT_WRITE_RE       = interface->set_signal_out <Tcontrol_t        > ("write_re"    ,1                             );
    132       out_READ_QUEUE_OUT_NUM_REG_RE     = interface->set_signal_out <Tspecial_address_t> ("num_reg_re"  ,_param->_size_special_register );     
    133      }
     85      ALLOC0_VALACK_OUT(out_READ_QUEUE_OUT_VAL                   ,VAL);
     86      ALLOC0_VALACK_IN ( in_READ_QUEUE_OUT_ACK                   ,ACK);
     87      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_CONTEXT_ID            ,"context_id"           ,Tcontext_t        ,_param->_size_context_id       );
     88      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_FRONT_END_ID          ,"front_end_id"         ,Tcontext_t        ,_param->_size_front_end_id     );
     89      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_OOO_ENGINE_ID         ,"ooo_engine_id"        ,Tcontext_t        ,_param->_size_ooo_engine_id    );
     90      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_ROB_ID                ,"rob_id"               ,Tpacket_t         ,_param->_size_rob_ptr          );
     91      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_OPERATION             ,"operation"            ,Toperation_t      ,_param->_size_operation        );
     92      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_TYPE                  ,"type"                 ,Ttype_t           ,_param->_size_type             );
     93      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_STORE_QUEUE_PTR_WRITE ,"store_queue_ptr_write",Tlsq_ptr_t        , _param->_size_store_queue_ptr );
     94      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_LOAD_QUEUE_PTR_WRITE  ,"load_queue_ptr_write" ,Tlsq_ptr_t        , _param->_size_load_queue_ptr  );
     95      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_HAS_IMMEDIAT          ,"has_immediat"         ,Tcontrol_t        ,1                              );
     96      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_IMMEDIAT              ,"immediat"             ,Tgeneral_data_t   ,_param->_size_general_data     );
     97//    ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_READ_RA               ,"read_ra"              ,Tcontrol_t        ,1                              );
     98      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_NUM_REG_RA            ,"num_reg_ra"           ,Tgeneral_address_t,_param->_size_general_register );
     99      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_DATA_RA_VAL           ,"data_ra_val"          ,Tcontrol_t        ,1                              );
     100      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_DATA_RA               ,"data_ra"              ,Tgeneral_data_t   ,_param->_size_general_data     );
     101//    ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_READ_RB               ,"read_rb"              ,Tcontrol_t        ,1                              );
     102      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_NUM_REG_RB            ,"num_reg_rb"           ,Tgeneral_address_t,_param->_size_general_register );
     103      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_DATA_RB_VAL           ,"data_rb_val"          ,Tcontrol_t        ,1                              );
     104      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_DATA_RB               ,"data_rb"              ,Tgeneral_data_t   ,_param->_size_general_data     );
     105//    ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_READ_RC               ,"read_rc"              ,Tcontrol_t        ,1                              );
     106      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_NUM_REG_RC            ,"num_reg_rc"           ,Tspecial_address_t,_param->_size_special_register );
     107      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_DATA_RC_VAL           ,"data_rc_val"          ,Tcontrol_t        ,1                              );
     108      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_DATA_RC               ,"data_rc"              ,Tspecial_data_t   ,_param->_size_special_data     );
     109      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_WRITE_RD              ,"write_rd"             ,Tcontrol_t        ,1                              );
     110      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_NUM_REG_RD            ,"num_reg_rd"           ,Tgeneral_address_t,_param->_size_general_register );
     111      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_WRITE_RE              ,"write_re"             ,Tcontrol_t        ,1                              );
     112      ALLOC0_SIGNAL_OUT(out_READ_QUEUE_OUT_NUM_REG_RE            ,"num_reg_re"           ,Tspecial_address_t,_param->_size_special_register );     
     113     
     114      ALLOC0_INTERFACE_END();
     115    }
    134116
    135117    // ~~~~~[ Interface : "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     118    {
     119      ALLOC1_INTERFACE_BEGIN("gpr_read",IN,SOUTH,_("Interface with the General RegisterFile"),_param->_nb_gpr_read);
     120
     121      ALLOC1_VALACK_OUT(out_GPR_READ_VAL           ,VAL);
     122      ALLOC1_VALACK_IN ( in_GPR_READ_ACK           ,ACK);
     123      ALLOC1_SIGNAL_OUT(out_GPR_READ_OOO_ENGINE_ID ,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id);
     124      ALLOC1_SIGNAL_OUT(out_GPR_READ_NUM_REG       ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
     125      ALLOC1_SIGNAL_IN ( in_GPR_READ_DATA          ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data);
     126      ALLOC1_SIGNAL_IN ( in_GPR_READ_DATA_VAL      ,"data_val"     ,Tcontrol_t        ,1);
     127
     128      ALLOC1_INTERFACE_END(_param->_nb_gpr_read);
     129    }
    136130   
    137     out_GPR_READ_VAL          = new SC_OUT(Tcontrol_t        ) * [_param->_nb_gpr_read];
    138      in_GPR_READ_ACK          = new SC_IN (Tcontrol_t        ) * [_param->_nb_gpr_read];
    139     if(_param->_have_port_ooo_engine_id)
    140       out_GPR_READ_OOO_ENGINE_ID= new SC_OUT(Tcontext_t        ) * [_param->_nb_gpr_read];
    141     out_GPR_READ_NUM_REG      = new SC_OUT(Tgeneral_address_t) * [_param->_nb_gpr_read];
    142      in_GPR_READ_DATA         = new SC_IN (Tgeneral_data_t   ) * [_param->_nb_gpr_read];
    143      in_GPR_READ_DATA_VAL     = new SC_IN (Tcontrol_t        ) * [_param->_nb_gpr_read];
     131    // ~~~~~[ Interface : "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     132    {
     133      ALLOC1_INTERFACE_BEGIN("spr_read",IN,SOUTH,_("Interface with the General RegisterFile"),_param->_nb_spr_read);
    144134
    145     for (uint32_t i=0; i<_param->_nb_gpr_read; i++)
    146       {
    147         Interface_fifo * interface = _interfaces->set_interface("gpr_read_"+toString(i)
    148 #ifdef POSITION
    149                                                                 , IN 
    150                                                                 ,SOUTH
    151                                                                 , "Interface with the General RegisterFile."
    152 #endif
    153                                                                 );
     135      ALLOC1_VALACK_OUT(out_SPR_READ_VAL           ,VAL);
     136      ALLOC1_VALACK_IN ( in_SPR_READ_ACK           ,ACK);
     137      ALLOC1_SIGNAL_OUT(out_SPR_READ_OOO_ENGINE_ID ,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id);
     138      ALLOC1_SIGNAL_OUT(out_SPR_READ_NUM_REG       ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
     139      ALLOC1_SIGNAL_IN ( in_SPR_READ_DATA          ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data);
     140      ALLOC1_SIGNAL_IN ( in_SPR_READ_DATA_VAL      ,"data_val"     ,Tcontrol_t        ,1);
    154141
    155         out_GPR_READ_VAL           [i] = interface->set_signal_valack_out       ("val"    , VAL);
    156          in_GPR_READ_ACK           [i] = interface->set_signal_valack_in        ("ack"    , ACK);
    157         if(_param->_have_port_ooo_engine_id)
    158           out_GPR_READ_OOO_ENGINE_ID [i] = interface->set_signal_out <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id);
    159         out_GPR_READ_NUM_REG       [i] = interface->set_signal_out <Tgeneral_address_t> ("num_reg"  ,_param->_size_general_register);
    160          in_GPR_READ_DATA          [i] = interface->set_signal_in  <Tgeneral_data_t   > ("data"     ,_param->_size_general_data);
    161          in_GPR_READ_DATA_VAL      [i] = interface->set_signal_in  <Tcontrol_t        > ("data_val" ,1);
    162       }
    163      
    164     // ~~~~~[ Interface : "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    165    
    166     out_SPR_READ_VAL          = new SC_OUT(Tcontrol_t        ) * [_param->_nb_spr_read];
    167      in_SPR_READ_ACK          = new SC_IN (Tcontrol_t        ) * [_param->_nb_spr_read];
    168     if(_param->_have_port_ooo_engine_id)
    169       out_SPR_READ_OOO_ENGINE_ID= new SC_OUT(Tcontext_t        ) * [_param->_nb_spr_read];
    170     out_SPR_READ_NUM_REG      = new SC_OUT(Tspecial_address_t) * [_param->_nb_spr_read];
    171      in_SPR_READ_DATA         = new SC_IN (Tspecial_data_t   ) * [_param->_nb_spr_read];
    172      in_SPR_READ_DATA_VAL     = new SC_IN (Tcontrol_t        ) * [_param->_nb_spr_read];
    173 
    174     for (uint32_t i=0; i<_param->_nb_spr_read; i++)
    175       {
    176         Interface_fifo * interface = _interfaces->set_interface("spr_read_"+toString(i)
    177 #ifdef POSITION
    178                                                                 , IN 
    179                                                                 ,SOUTH
    180                                                                 , "Interface with the Special RegisterFile."
    181 #endif
    182                                                                 );
    183 
    184         out_SPR_READ_VAL           [i] = interface->set_signal_valack_out       ("val"    , VAL);
    185          in_SPR_READ_ACK           [i] = interface->set_signal_valack_in        ("ack"    , ACK);
    186         if(_param->_have_port_ooo_engine_id)
    187           out_SPR_READ_OOO_ENGINE_ID [i] = interface->set_signal_out <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id);
    188         out_SPR_READ_NUM_REG       [i] = interface->set_signal_out <Tspecial_address_t> ("num_reg"   ,_param->_size_special_register);
    189          in_SPR_READ_DATA          [i] = interface->set_signal_in  <Tspecial_data_t   > ("data"      ,_param->_size_special_data);
    190          in_SPR_READ_DATA_VAL      [i] = interface->set_signal_in  <Tcontrol_t        > ("data_val"  ,1);
    191       }
     142      ALLOC1_INTERFACE_END(_param->_nb_spr_read);
     143    }
    192144
    193145    // ~~~~~[ Interface : "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    194    
    195      in_GPR_WRITE_VAL          = new SC_IN (Tcontrol_t        ) * [_param->_nb_gpr_write];
    196      if(_param->_have_port_ooo_engine_id)
    197        in_GPR_WRITE_OOO_ENGINE_ID= new SC_IN (Tcontext_t        ) * [_param->_nb_gpr_write];
    198      in_GPR_WRITE_NUM_REG      = new SC_IN (Tgeneral_address_t) * [_param->_nb_gpr_write];
    199      in_GPR_WRITE_DATA         = new SC_IN (Tgeneral_data_t   ) * [_param->_nb_gpr_write];
     146    {
     147      ALLOC1_INTERFACE_BEGIN("gpr_write",IN,SOUTH,_("Interface with write queue to bypass the write in the RegisterFile"),_param->_nb_gpr_write);
    200148
    201     for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
    202       {
    203         Interface_fifo * interface = _interfaces->set_interface("gpr_write_"+toString(i)
    204 #ifdef POSITION
    205                                                                 , IN 
    206                                                                 ,SOUTH
    207                                                                 , "Interface with write queue to bypass the write in the RegisterFile."
    208 #endif
    209                                                                 );
    210 
    211          in_GPR_WRITE_VAL           [i] = interface->set_signal_valack_in        ("val"    , VAL);
    212          if(_param->_have_port_ooo_engine_id)
    213            in_GPR_WRITE_OOO_ENGINE_ID [i] = interface->set_signal_in  <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id);
    214          in_GPR_WRITE_NUM_REG       [i] = interface->set_signal_in  <Tgeneral_address_t> ("num_reg"   ,_param->_size_general_register);
    215          in_GPR_WRITE_DATA          [i] = interface->set_signal_in  <Tgeneral_data_t   > ("data"      ,_param->_size_general_data);
    216       }
     149      ALLOC1_VALACK_IN (in_GPR_WRITE_VAL           ,VAL);
     150      ALLOC1_SIGNAL_IN (in_GPR_WRITE_OOO_ENGINE_ID ,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id);
     151      ALLOC1_SIGNAL_IN (in_GPR_WRITE_NUM_REG       ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
     152      ALLOC1_SIGNAL_IN (in_GPR_WRITE_DATA          ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data);
     153     
     154      ALLOC1_INTERFACE_END(_param->_nb_gpr_write);
     155    }
    217156
    218157    // ~~~~~[ Interface : "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    219    
    220      in_SPR_WRITE_VAL          = new SC_IN (Tcontrol_t        ) * [_param->_nb_spr_write];
    221      if(_param->_have_port_ooo_engine_id)
    222        in_SPR_WRITE_OOO_ENGINE_ID= new SC_IN (Tcontext_t        ) * [_param->_nb_spr_write];
    223      in_SPR_WRITE_NUM_REG      = new SC_IN (Tspecial_address_t) * [_param->_nb_spr_write];
    224      in_SPR_WRITE_DATA         = new SC_IN (Tspecial_data_t   ) * [_param->_nb_spr_write];
     158    {
     159      ALLOC1_INTERFACE_BEGIN("spr_write",IN,SOUTH,_("Interface with write queue to bypass the write in the RegisterFile"),_param->_nb_spr_write);
    225160
    226     for (uint32_t i=0; i<_param->_nb_spr_write; i++)
    227       {
    228         Interface_fifo * interface = _interfaces->set_interface("spr_write_"+toString(i)
    229 #ifdef POSITION
    230                                                                 , IN 
    231                                                                 ,SOUTH
    232                                                                 , "Interface with write queue to bypass the write in the RegisterFile."
    233 #endif
    234                                                                 );
    235 
    236          in_SPR_WRITE_VAL           [i] = interface->set_signal_valack_in ("val"    , VAL);
    237          if(_param->_have_port_ooo_engine_id)
    238            in_SPR_WRITE_OOO_ENGINE_ID [i] = interface->set_signal_in  <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id);
    239          in_SPR_WRITE_NUM_REG       [i] = interface->set_signal_in  <Tspecial_address_t> ("num_reg"   ,_param->_size_special_register);
    240          in_SPR_WRITE_DATA          [i] = interface->set_signal_in  <Tspecial_data_t   > ("data"      ,_param->_size_special_data);
    241       }
     161      ALLOC1_VALACK_IN (in_SPR_WRITE_VAL           ,VAL);
     162      ALLOC1_SIGNAL_IN (in_SPR_WRITE_OOO_ENGINE_ID ,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id);
     163      ALLOC1_SIGNAL_IN (in_SPR_WRITE_NUM_REG       ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
     164      ALLOC1_SIGNAL_IN (in_SPR_WRITE_DATA          ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data);
     165     
     166      ALLOC1_INTERFACE_END(_param->_nb_spr_write);
     167    }
    242168
    243169    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   

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

    r88 r112  
    88
    99#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/include/Read_queue.h"
     10#include "Behavioural/include/Allocation.h"
    1011
    1112namespace morpheo                    {
    … …  
    2526    if (usage_is_set(_usage,USE_SYSTEMC))
    2627      {
    27     // ~~~~~[ Interface : "" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    28     delete     in_CLOCK ;
    29     delete     in_NRESET;
     28        delete     in_CLOCK ;
     29        delete     in_NRESET;
    3030
    31     // ~~~~~[ Interface : "read_queue_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    32     delete     in_READ_QUEUE_IN_VAL            ;
    33     delete    out_READ_QUEUE_IN_ACK            ;
     31        DELETE0_SIGNAL( in_READ_QUEUE_IN_VAL                   ,1                             );
     32        DELETE0_SIGNAL(out_READ_QUEUE_IN_ACK                   ,1                             );
     33        DELETE0_SIGNAL( in_READ_QUEUE_IN_CONTEXT_ID            ,_param->_size_context_id      );
     34        DELETE0_SIGNAL( in_READ_QUEUE_IN_FRONT_END_ID          ,_param->_size_front_end_id    );
     35        DELETE0_SIGNAL( in_READ_QUEUE_IN_OOO_ENGINE_ID         ,_param->_size_ooo_engine_id   );
     36        DELETE0_SIGNAL( in_READ_QUEUE_IN_ROB_ID                ,_param->_size_rob_ptr         );
     37        DELETE0_SIGNAL( in_READ_QUEUE_IN_OPERATION             ,_param->_size_operation       );
     38        DELETE0_SIGNAL( in_READ_QUEUE_IN_TYPE                  ,_param->_size_type            );
     39        DELETE0_SIGNAL( in_READ_QUEUE_IN_STORE_QUEUE_PTR_WRITE ,_param->_size_store_queue_ptr );
     40        DELETE0_SIGNAL( in_READ_QUEUE_IN_LOAD_QUEUE_PTR_WRITE  ,_param->_size_load_queue_ptr  );
     41        DELETE0_SIGNAL( in_READ_QUEUE_IN_HAS_IMMEDIAT          ,1                             );
     42        DELETE0_SIGNAL( in_READ_QUEUE_IN_IMMEDIAT              ,_param->_size_general_data    );
     43        DELETE0_SIGNAL( in_READ_QUEUE_IN_READ_RA               ,1                             );
     44        DELETE0_SIGNAL( in_READ_QUEUE_IN_NUM_REG_RA            ,_param->_size_general_register);
     45        DELETE0_SIGNAL( in_READ_QUEUE_IN_READ_RB               ,1                             );
     46        DELETE0_SIGNAL( in_READ_QUEUE_IN_NUM_REG_RB            ,_param->_size_general_register);
     47        DELETE0_SIGNAL( in_READ_QUEUE_IN_READ_RC               ,1                             );
     48        DELETE0_SIGNAL( in_READ_QUEUE_IN_NUM_REG_RC            ,_param->_size_special_register);
     49        DELETE0_SIGNAL( in_READ_QUEUE_IN_WRITE_RD              ,1                             );
     50        DELETE0_SIGNAL( in_READ_QUEUE_IN_NUM_REG_RD            ,_param->_size_general_register);
     51        DELETE0_SIGNAL( in_READ_QUEUE_IN_WRITE_RE              ,1                             );
     52        DELETE0_SIGNAL( in_READ_QUEUE_IN_NUM_REG_RE            ,_param->_size_special_register);
     53     
     54        DELETE0_SIGNAL(out_READ_QUEUE_OUT_VAL                  ,1                              );
     55        DELETE0_SIGNAL( in_READ_QUEUE_OUT_ACK                  ,1                              );
     56        DELETE0_SIGNAL(out_READ_QUEUE_OUT_CONTEXT_ID           ,_param->_size_context_id       );
     57        DELETE0_SIGNAL(out_READ_QUEUE_OUT_FRONT_END_ID         ,_param->_size_front_end_id     );
     58        DELETE0_SIGNAL(out_READ_QUEUE_OUT_OOO_ENGINE_ID        ,_param->_size_ooo_engine_id    );
     59        DELETE0_SIGNAL(out_READ_QUEUE_OUT_ROB_ID               ,_param->_size_rob_ptr          );
     60        DELETE0_SIGNAL(out_READ_QUEUE_OUT_OPERATION            ,_param->_size_operation        );
     61        DELETE0_SIGNAL(out_READ_QUEUE_OUT_TYPE                 ,_param->_size_type             );
     62        DELETE0_SIGNAL(out_READ_QUEUE_OUT_STORE_QUEUE_PTR_WRITE, _param->_size_store_queue_ptr );
     63        DELETE0_SIGNAL(out_READ_QUEUE_OUT_LOAD_QUEUE_PTR_WRITE , _param->_size_load_queue_ptr  );
     64        DELETE0_SIGNAL(out_READ_QUEUE_OUT_HAS_IMMEDIAT         ,1                              );
     65        DELETE0_SIGNAL(out_READ_QUEUE_OUT_IMMEDIAT             ,_param->_size_general_data     );
     66//      DELETE0_SIGNAL(out_READ_QUEUE_OUT_READ_RA              ,1                              );
     67        DELETE0_SIGNAL(out_READ_QUEUE_OUT_NUM_REG_RA           ,_param->_size_general_register );
     68        DELETE0_SIGNAL(out_READ_QUEUE_OUT_DATA_RA_VAL          ,1                              );
     69        DELETE0_SIGNAL(out_READ_QUEUE_OUT_DATA_RA              ,_param->_size_general_data     );
     70//      DELETE0_SIGNAL(out_READ_QUEUE_OUT_READ_RB              ,1                              );
     71        DELETE0_SIGNAL(out_READ_QUEUE_OUT_NUM_REG_RB           ,_param->_size_general_register );
     72        DELETE0_SIGNAL(out_READ_QUEUE_OUT_DATA_RB_VAL          ,1                              );
     73        DELETE0_SIGNAL(out_READ_QUEUE_OUT_DATA_RB              ,_param->_size_general_data     );
     74//      DELETE0_SIGNAL(out_READ_QUEUE_OUT_READ_RC              ,1                              );
     75        DELETE0_SIGNAL(out_READ_QUEUE_OUT_NUM_REG_RC           ,_param->_size_special_register );
     76        DELETE0_SIGNAL(out_READ_QUEUE_OUT_DATA_RC_VAL          ,1                              );
     77        DELETE0_SIGNAL(out_READ_QUEUE_OUT_DATA_RC              ,_param->_size_special_data     );
     78        DELETE0_SIGNAL(out_READ_QUEUE_OUT_WRITE_RD             ,1                              );
     79        DELETE0_SIGNAL(out_READ_QUEUE_OUT_NUM_REG_RD           ,_param->_size_general_register );
     80        DELETE0_SIGNAL(out_READ_QUEUE_OUT_WRITE_RE             ,1                              );
     81        DELETE0_SIGNAL(out_READ_QUEUE_OUT_NUM_REG_RE           ,_param->_size_special_register );     
    3482
    35     if(_param->_have_port_context_id   )
    36       delete     in_READ_QUEUE_IN_CONTEXT_ID     ;
    37     if(_param->_have_port_front_end_id )
    38       delete     in_READ_QUEUE_IN_FRONT_END_ID   ;
    39     if(_param->_have_port_ooo_engine_id)
    40       delete     in_READ_QUEUE_IN_OOO_ENGINE_ID  ;
    41     if(_param->_have_port_rob_ptr       )
    42       delete     in_READ_QUEUE_IN_ROB_ID         ;
    43     delete     in_READ_QUEUE_IN_OPERATION      ;
    44     delete     in_READ_QUEUE_IN_TYPE           ;
    45     delete     in_READ_QUEUE_IN_STORE_QUEUE_PTR_WRITE;
    46     if (_param->_have_port_load_queue_ptr)
    47     delete     in_READ_QUEUE_IN_LOAD_QUEUE_PTR_WRITE ;
    48     delete     in_READ_QUEUE_IN_HAS_IMMEDIAT   ;
    49     delete     in_READ_QUEUE_IN_IMMEDIAT       ;
    50     delete     in_READ_QUEUE_IN_READ_RA        ;
    51     delete     in_READ_QUEUE_IN_NUM_REG_RA     ;
    52     delete     in_READ_QUEUE_IN_READ_RB        ;
    53     delete     in_READ_QUEUE_IN_NUM_REG_RB     ;
    54     delete     in_READ_QUEUE_IN_READ_RC        ;
    55     delete     in_READ_QUEUE_IN_NUM_REG_RC     ;
    56     delete     in_READ_QUEUE_IN_WRITE_RD       ;
    57     delete     in_READ_QUEUE_IN_NUM_REG_RD     ;
    58     delete     in_READ_QUEUE_IN_WRITE_RE       ;
    59     delete     in_READ_QUEUE_IN_NUM_REG_RE     ;
     83        DELETE1_SIGNAL(out_GPR_READ_VAL           ,_param->_nb_gpr_read,1);
     84        DELETE1_SIGNAL( in_GPR_READ_ACK           ,_param->_nb_gpr_read,1);
     85        DELETE1_SIGNAL(out_GPR_READ_OOO_ENGINE_ID ,_param->_nb_gpr_read,_param->_size_ooo_engine_id);
     86        DELETE1_SIGNAL(out_GPR_READ_NUM_REG       ,_param->_nb_gpr_read,_param->_size_general_register);
     87        DELETE1_SIGNAL( in_GPR_READ_DATA          ,_param->_nb_gpr_read,_param->_size_general_data);
     88        DELETE1_SIGNAL( in_GPR_READ_DATA_VAL      ,_param->_nb_gpr_read,1);
    6089
    61     // ~~~~~[ Interface : "read_queue_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    62     delete    out_READ_QUEUE_OUT_VAL            ;
    63     delete     in_READ_QUEUE_OUT_ACK            ;
     90        DELETE1_SIGNAL(out_SPR_READ_VAL           ,_param->_nb_spr_read,1);
     91        DELETE1_SIGNAL( in_SPR_READ_ACK           ,_param->_nb_spr_read,1);
     92        DELETE1_SIGNAL(out_SPR_READ_OOO_ENGINE_ID ,_param->_nb_spr_read,_param->_size_ooo_engine_id);
     93        DELETE1_SIGNAL(out_SPR_READ_NUM_REG       ,_param->_nb_spr_read,_param->_size_general_register);
     94        DELETE1_SIGNAL( in_SPR_READ_DATA          ,_param->_nb_spr_read,_param->_size_general_data);
     95        DELETE1_SIGNAL( in_SPR_READ_DATA_VAL      ,_param->_nb_spr_read,1);
     96       
     97        DELETE1_SIGNAL(in_GPR_WRITE_VAL           ,_param->_nb_gpr_write,1);
     98        DELETE1_SIGNAL(in_GPR_WRITE_OOO_ENGINE_ID ,_param->_nb_gpr_write,_param->_size_ooo_engine_id);
     99        DELETE1_SIGNAL(in_GPR_WRITE_NUM_REG       ,_param->_nb_gpr_write,_param->_size_general_register);
     100        DELETE1_SIGNAL(in_GPR_WRITE_DATA          ,_param->_nb_gpr_write,_param->_size_general_data);
    64101
    65     if(_param->_have_port_context_id   )
    66       delete    out_READ_QUEUE_OUT_CONTEXT_ID     ;
    67     if(_param->_have_port_front_end_id )
    68       delete    out_READ_QUEUE_OUT_FRONT_END_ID   ;
    69     if(_param->_have_port_ooo_engine_id)
    70       delete    out_READ_QUEUE_OUT_OOO_ENGINE_ID  ;
    71     if(_param->_have_port_rob_ptr       )
    72       delete    out_READ_QUEUE_OUT_ROB_ID         ;
    73     delete    out_READ_QUEUE_OUT_OPERATION      ;
    74     delete    out_READ_QUEUE_OUT_TYPE           ;
    75     delete    out_READ_QUEUE_OUT_STORE_QUEUE_PTR_WRITE;
    76     if (_param->_have_port_load_queue_ptr)
    77     delete    out_READ_QUEUE_OUT_LOAD_QUEUE_PTR_WRITE ;
    78     delete    out_READ_QUEUE_OUT_HAS_IMMEDIAT   ;
    79     delete    out_READ_QUEUE_OUT_IMMEDIAT       ;
    80 //     delete    out_READ_QUEUE_OUT_READ_RA        ;
    81     delete    out_READ_QUEUE_OUT_NUM_REG_RA     ;
    82     delete    out_READ_QUEUE_OUT_DATA_RA_VAL    ;
    83     delete    out_READ_QUEUE_OUT_DATA_RA        ;
    84 //     delete    out_READ_QUEUE_OUT_READ_RB        ;
    85     delete    out_READ_QUEUE_OUT_NUM_REG_RB     ;
    86     delete    out_READ_QUEUE_OUT_DATA_RB_VAL    ;
    87     delete    out_READ_QUEUE_OUT_DATA_RB        ;
    88 //     delete    out_READ_QUEUE_OUT_READ_RC        ;
    89     delete    out_READ_QUEUE_OUT_NUM_REG_RC     ;
    90     delete    out_READ_QUEUE_OUT_DATA_RC_VAL    ;
    91     delete    out_READ_QUEUE_OUT_DATA_RC        ;
    92     delete    out_READ_QUEUE_OUT_WRITE_RD       ;
    93     delete    out_READ_QUEUE_OUT_NUM_REG_RD     ;
    94     delete    out_READ_QUEUE_OUT_WRITE_RE       ;
    95     delete    out_READ_QUEUE_OUT_NUM_REG_RE     ;
    96 
    97     // ~~~~~[ Interface : "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    98    
    99     delete [] out_GPR_READ_VAL       ;
    100     delete []  in_GPR_READ_ACK       ;
    101     if(_param->_have_port_ooo_engine_id)
    102       delete [] out_GPR_READ_OOO_ENGINE_ID;
    103     delete [] out_GPR_READ_NUM_REG   ;
    104     delete []  in_GPR_READ_DATA      ;
    105     delete []  in_GPR_READ_DATA_VAL  ;
    106 
    107     // ~~~~~[ Interface : "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    108    
    109     delete [] out_SPR_READ_VAL       ;
    110     delete []  in_SPR_READ_ACK       ;
    111     if(_param->_have_port_ooo_engine_id)
    112       delete [] out_SPR_READ_OOO_ENGINE_ID;
    113     delete [] out_SPR_READ_NUM_REG   ;
    114     delete []  in_SPR_READ_DATA      ;
    115     delete []  in_SPR_READ_DATA_VAL  ;
    116 
    117     // ~~~~~[ Interface : "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    118    
    119     delete []  in_GPR_WRITE_VAL       ;
    120     if(_param->_have_port_ooo_engine_id)
    121       delete []  in_GPR_WRITE_OOO_ENGINE_ID;
    122     delete []  in_GPR_WRITE_NUM_REG   ;
    123     delete []  in_GPR_WRITE_DATA      ;
    124 
    125     // ~~~~~[ Interface : "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    126    
    127     delete []  in_SPR_WRITE_VAL       ;
    128     if(_param->_have_port_ooo_engine_id)
    129       delete []  in_SPR_WRITE_OOO_ENGINE_ID;
    130     delete []  in_SPR_WRITE_NUM_REG   ;
    131     delete []  in_SPR_WRITE_DATA      ;
     102        DELETE1_SIGNAL(in_SPR_WRITE_VAL           ,_param->_nb_spr_write,1);
     103        DELETE1_SIGNAL(in_SPR_WRITE_OOO_ENGINE_ID ,_param->_nb_spr_write,_param->_size_ooo_engine_id);
     104        DELETE1_SIGNAL(in_SPR_WRITE_NUM_REG       ,_param->_nb_spr_write,_param->_size_general_register);
     105        DELETE1_SIGNAL(in_SPR_WRITE_DATA          ,_param->_nb_spr_write,_param->_size_general_data);
    132106      }
    133107

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

    r111 r112  
    3434        // > 2) flush all slot in one cycle
    3535
    36         _queue->clear();
     36        while (_queue->empty() == false)
     37          {
     38            delete _queue->front();
     39            _queue->pop_front();
     40          }
     41        // _queue->clear();
    3742
    3843        // Init, else error in registerfile

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

    r97 r112  
    77 */
    88#define NB_ITERATION  1
    9 #define CYCLE_MAX     (2048*NB_ITERATION)
     9#define CYCLE_MAX     (10000*NB_ITERATION)
    1010
    1111#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/SelfTest/include/test.h"

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

    r97 r112  
    88
    99#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/include/Reservation_station.h"
     10#include "Behavioural/include/Allocation.h"
    1011
    1112namespace morpheo                    {
    … …  
    4344                                                         ,IN
    4445                                                         ,SOUTH,
    45                                                          "Generalist interface"
     46                                                         _("Generalist interface")
    4647#endif
    4748                                                         );
    … …  
    5051     in_NRESET       = interface->set_signal_in  <Tcontrol_t> ("nreset",1, RESET_VHDL_YES);
    5152
    52     // ~~~~~[ Interface : "insert" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~
    53     {
    54       Interface_fifo * interface = _interfaces->set_interface("insert"
    55 #ifdef POSITION
    56                                                                ,IN
    57                                                                ,EAST
    58                                                                ,"Input of reservation_station"
    59 #endif
    60                                                                );
    61      
    62        in_INSERT_VAL            = interface->set_signal_valack_in  (VAL);
    63       out_INSERT_ACK            = interface->set_signal_valack_out (ACK);
    64       if (_param->_have_port_context_id)
    65        in_INSERT_CONTEXT_ID     = interface->set_signal_in <Tcontext_t        > ("context_id"     ,_param->_size_context_id       );
    66       if (_param->_have_port_front_end_id)
    67        in_INSERT_FRONT_END_ID   = interface->set_signal_in <Tcontext_t        > ("front_end_id"   ,_param->_size_front_end_id     );
    68       if (_param->_have_port_ooo_engine_id)
    69        in_INSERT_OOO_ENGINE_ID  = interface->set_signal_in <Tcontext_t        > ("ooo_engine_id"  ,_param->_size_ooo_engine_id    );
    70       if (_param->_have_port_rob_ptr)
    71        in_INSERT_ROB_ID         = interface->set_signal_in <Tpacket_t         > ("rob_id"         ,_param->_size_rob_ptr        );
    72        in_INSERT_OPERATION      = interface->set_signal_in <Toperation_t      > ("operation"      ,_param->_size_operation        );
    73        in_INSERT_TYPE           = interface->set_signal_in <Ttype_t           > ("type"           ,_param->_size_type             );
    74        in_INSERT_STORE_QUEUE_PTR_WRITE = interface->set_signal_in <Tlsq_ptr_t> ("store_queue_ptr_write" ,_param->_size_store_queue_ptr);
    75        if (_param->_have_port_load_queue_ptr)
    76        in_INSERT_LOAD_QUEUE_PTR_WRITE  = interface->set_signal_in <Tlsq_ptr_t> ("load_queue_ptr_write"  ,_param->_size_load_queue_ptr );
    77        in_INSERT_HAS_IMMEDIAT   = interface->set_signal_in <Tcontrol_t        > ("has_immediat"   ,1                             );
    78        in_INSERT_IMMEDIAT       = interface->set_signal_in <Tgeneral_data_t   > ("immediat"       ,_param->_size_general_data     );
    79 //     in_INSERT_READ_RA        = interface->set_signal_in <Tcontrol_t        > ("read_ra"        ,1                             );
    80        in_INSERT_NUM_REG_RA     = interface->set_signal_in <Tgeneral_address_t> ("num_reg_ra"     ,_param->_size_general_register );
    81        in_INSERT_DATA_RA_VAL    = interface->set_signal_in <Tcontrol_t        > ("data_ra_val"    ,1                             );
    82        in_INSERT_DATA_RA        = interface->set_signal_in <Tgeneral_data_t   > ("data_ra"        ,_param->_size_general_data     );
    83 //     in_INSERT_READ_RB        = interface->set_signal_in <Tcontrol_t        > ("read_rb"        ,1                             );
    84        in_INSERT_NUM_REG_RB     = interface->set_signal_in <Tgeneral_address_t> ("num_reg_rb"     ,_param->_size_general_register );
    85        in_INSERT_DATA_RB_VAL    = interface->set_signal_in <Tcontrol_t        > ("data_rb_val"    ,1                             );
    86        in_INSERT_DATA_RB        = interface->set_signal_in <Tgeneral_data_t   > ("data_rb"        ,_param->_size_general_data     );
    87 //     in_INSERT_READ_RC        = interface->set_signal_in <Tcontrol_t        > ("read_rc"        ,1                             );
    88        in_INSERT_NUM_REG_RC     = interface->set_signal_in <Tspecial_address_t> ("num_reg_rc"     ,_param->_size_special_register );
    89        in_INSERT_DATA_RC_VAL    = interface->set_signal_in <Tcontrol_t        > ("data_rc_val"    ,1                             );
    90        in_INSERT_DATA_RC        = interface->set_signal_in <Tspecial_data_t   > ("data_rc"        ,_param->_size_special_data     );
    91        in_INSERT_WRITE_RD       = interface->set_signal_in <Tcontrol_t        > ("write_rd"       ,1                             );
    92        in_INSERT_NUM_REG_RD     = interface->set_signal_in <Tgeneral_address_t> ("num_reg_rd"     ,_param->_size_general_register );
    93        in_INSERT_WRITE_RE       = interface->set_signal_in <Tcontrol_t        > ("write_re"       ,1                             );
    94        in_INSERT_NUM_REG_RE     = interface->set_signal_in <Tspecial_address_t> ("num_reg_re"     ,_param->_size_special_register );     
     53     // ~~~~~[ Interface : "insert" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~
     54     {
     55       ALLOC0_INTERFACE_BEGIN("insert",IN,EAST,_("Input of reservation_station"));
     56       
     57       ALLOC0_VALACK_IN ( in_INSERT_VAL                  ,VAL);
     58       ALLOC0_VALACK_OUT(out_INSERT_ACK                  ,ACK);
     59       ALLOC0_SIGNAL_IN ( in_INSERT_CONTEXT_ID           ,"context_id"           ,Tcontext_t        ,_param->_size_context_id      );
     60       ALLOC0_SIGNAL_IN ( in_INSERT_FRONT_END_ID         ,"front_end_id"         ,Tcontext_t        ,_param->_size_front_end_id    );
     61       ALLOC0_SIGNAL_IN ( in_INSERT_OOO_ENGINE_ID        ,"ooo_engine_id"        ,Tcontext_t        ,_param->_size_ooo_engine_id   );
     62       ALLOC0_SIGNAL_IN ( in_INSERT_ROB_ID               ,"rob_id"               ,Tpacket_t         ,_param->_size_rob_ptr         );
     63       ALLOC0_SIGNAL_IN ( in_INSERT_OPERATION            ,"operation"            ,Toperation_t      ,_param->_size_operation       );
     64       ALLOC0_SIGNAL_IN ( in_INSERT_TYPE                 ,"type"                 ,Ttype_t           ,_param->_size_type            );
     65       ALLOC0_SIGNAL_IN ( in_INSERT_STORE_QUEUE_PTR_WRITE,"store_queue_ptr_write",Tlsq_ptr_t        ,_param->_size_store_queue_ptr );
     66       ALLOC0_SIGNAL_IN ( in_INSERT_LOAD_QUEUE_PTR_WRITE ,"load_queue_ptr_write" ,Tlsq_ptr_t        ,_param->_size_load_queue_ptr  );
     67       ALLOC0_SIGNAL_IN ( in_INSERT_HAS_IMMEDIAT         ,"has_immediat"         ,Tcontrol_t        ,1                             );
     68       ALLOC0_SIGNAL_IN ( in_INSERT_IMMEDIAT             ,"immediat"             ,Tgeneral_data_t   ,_param->_size_general_data    );
     69//     ALLOC0_SIGNAL_IN ( in_INSERT_READ_RA              ,"read_ra"              ,Tcontrol_t        ,1                             );
     70       ALLOC0_SIGNAL_IN ( in_INSERT_NUM_REG_RA           ,"num_reg_ra"           ,Tgeneral_address_t,_param->_size_general_register);
     71       ALLOC0_SIGNAL_IN ( in_INSERT_DATA_RA_VAL          ,"data_ra_val"          ,Tcontrol_t        ,1                             );
     72       ALLOC0_SIGNAL_IN ( in_INSERT_DATA_RA              ,"data_ra"              ,Tgeneral_data_t   ,_param->_size_general_data    );
     73//     ALLOC0_SIGNAL_IN ( in_INSERT_READ_RB              ,"read_rb"              ,Tcontrol_t        ,1                             );
     74       ALLOC0_SIGNAL_IN ( in_INSERT_NUM_REG_RB           ,"num_reg_rb"           ,Tgeneral_address_t,_param->_size_general_register);
     75       ALLOC0_SIGNAL_IN ( in_INSERT_DATA_RB_VAL          ,"data_rb_val"          ,Tcontrol_t        ,1                             );
     76       ALLOC0_SIGNAL_IN ( in_INSERT_DATA_RB              ,"data_rb"              ,Tgeneral_data_t   ,_param->_size_general_data    );
     77//     ALLOC0_SIGNAL_IN ( in_INSERT_READ_RC              ,"read_rc"              ,Tcontrol_t        ,1                             );
     78       ALLOC0_SIGNAL_IN ( in_INSERT_NUM_REG_RC           ,"num_reg_rc"           ,Tspecial_address_t,_param->_size_special_register);
     79       ALLOC0_SIGNAL_IN ( in_INSERT_DATA_RC_VAL          ,"data_rc_val"          ,Tcontrol_t        ,1                             );
     80       ALLOC0_SIGNAL_IN ( in_INSERT_DATA_RC              ,"data_rc"              ,Tspecial_data_t   ,_param->_size_special_data    );
     81       ALLOC0_SIGNAL_IN ( in_INSERT_WRITE_RD             ,"write_rd"             ,Tcontrol_t        ,1                             );
     82       ALLOC0_SIGNAL_IN ( in_INSERT_NUM_REG_RD           ,"num_reg_rd"           ,Tgeneral_address_t,_param->_size_general_register);
     83       ALLOC0_SIGNAL_IN ( in_INSERT_WRITE_RE             ,"write_re"             ,Tcontrol_t        ,1                             );
     84       ALLOC0_SIGNAL_IN ( in_INSERT_NUM_REG_RE           ,"num_reg_re"           ,Tspecial_address_t,_param->_size_special_register);
     85
     86       ALLOC0_INTERFACE_END();
     87     }
     88     
     89     // ~~~~~[ Interface : "retire" ]~~~~~~~~~~~~~~~~~~~~~~~~~~
     90     {
     91       ALLOC1_INTERFACE_BEGIN("retire",OUT,WEST,_("Output of reservation_station"),_param->_nb_inst_retire);
     92       
     93       ALLOC1_VALACK_OUT(out_RETIRE_VAL                  ,VAL);
     94       ALLOC1_VALACK_IN ( in_RETIRE_ACK                  ,ACK);
     95       ALLOC1_SIGNAL_OUT(out_RETIRE_CONTEXT_ID           ,"context_id"           ,Tcontext_t        ,_param->_size_context_id);
     96       ALLOC1_SIGNAL_OUT(out_RETIRE_FRONT_END_ID         ,"front_end_id"         ,Tcontext_t        ,_param->_size_front_end_id);
     97       ALLOC1_SIGNAL_OUT(out_RETIRE_OOO_ENGINE_ID        ,"ooo_engine_id"        ,Tcontext_t        ,_param->_size_ooo_engine_id);
     98       ALLOC1_SIGNAL_OUT(out_RETIRE_ROB_ID               ,"rob_id"               ,Tpacket_t         ,_param->_size_rob_ptr);
     99       ALLOC1_SIGNAL_OUT(out_RETIRE_OPERATION            ,"operation"            ,Toperation_t      ,_param->_size_operation);
     100       ALLOC1_SIGNAL_OUT(out_RETIRE_TYPE                 ,"type"                 ,Ttype_t           ,_param->_size_type);
     101       ALLOC1_SIGNAL_OUT(out_RETIRE_STORE_QUEUE_PTR_WRITE,"store_queue_ptr_write",Tlsq_ptr_t        ,_param->_size_store_queue_ptr);
     102       ALLOC1_SIGNAL_OUT(out_RETIRE_LOAD_QUEUE_PTR_WRITE ,"load_queue_ptr_write" ,Tlsq_ptr_t        ,_param->_size_load_queue_ptr );
     103       ALLOC1_SIGNAL_OUT(out_RETIRE_HAS_IMMEDIAT         ,"has_immediat"         ,Tcontrol_t        ,1);
     104       ALLOC1_SIGNAL_OUT(out_RETIRE_IMMEDIAT             ,"immediat"             ,Tgeneral_data_t   ,_param->_size_general_data);
     105       ALLOC1_SIGNAL_OUT(out_RETIRE_DATA_RA              ,"data_ra"              ,Tgeneral_data_t   ,_param->_size_general_data);
     106       ALLOC1_SIGNAL_OUT(out_RETIRE_DATA_RB              ,"data_rb"              ,Tgeneral_data_t   ,_param->_size_general_data);
     107       ALLOC1_SIGNAL_OUT(out_RETIRE_DATA_RC              ,"data_rc"              ,Tspecial_data_t   ,_param->_size_special_data);
     108       ALLOC1_SIGNAL_OUT(out_RETIRE_WRITE_RD             ,"write_rd"             ,Tcontrol_t        ,1);
     109       ALLOC1_SIGNAL_OUT(out_RETIRE_NUM_REG_RD           ,"num_reg_rd"           ,Tgeneral_address_t,_param->_size_general_register);
     110       ALLOC1_SIGNAL_OUT(out_RETIRE_WRITE_RE             ,"write_re"             ,Tcontrol_t        ,1);
     111       ALLOC1_SIGNAL_OUT(out_RETIRE_NUM_REG_RE           ,"num_reg_re"           ,Tspecial_address_t,_param->_size_special_register);
     112
     113       ALLOC1_INTERFACE_END(_param->_nb_inst_retire);
     114     }
     115     
     116     // ~~~~~[ Interface : "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     117     {
     118       ALLOC1_INTERFACE_BEGIN("gpr_write",IN,SOUTH,_("Interface with write queue to bypass the write in the RegisterFile."),_param->_nb_gpr_write);
     119       
     120       ALLOC1_VALACK_IN ( in_GPR_WRITE_VAL          ,VAL);
     121       ALLOC1_SIGNAL_IN ( in_GPR_WRITE_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id);
     122       ALLOC1_SIGNAL_IN ( in_GPR_WRITE_NUM_REG      ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
     123       ALLOC1_SIGNAL_IN ( in_GPR_WRITE_DATA         ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data);
     124
     125       ALLOC1_INTERFACE_END(_param->_nb_gpr_write);
    95126     }
    96127
    97     // ~~~~~[ Interface : "retire" ]~~~~~~~~~~~~~~~~~~~~~~~~~~
    98     out_RETIRE_VAL            = new SC_OUT(Tcontrol_t        ) * [_param->_nb_inst_retire];
    99      in_RETIRE_ACK            = new SC_IN (Tcontrol_t        ) * [_param->_nb_inst_retire];
    100     if (_param->_have_port_context_id)
    101     out_RETIRE_CONTEXT_ID     = new SC_OUT(Tcontext_t        ) * [_param->_nb_inst_retire];
    102     if (_param->_have_port_front_end_id)
    103     out_RETIRE_FRONT_END_ID   = new SC_OUT(Tcontext_t        ) * [_param->_nb_inst_retire];
    104     if (_param->_have_port_ooo_engine_id)
    105     out_RETIRE_OOO_ENGINE_ID  = new SC_OUT(Tcontext_t        ) * [_param->_nb_inst_retire];
    106     if (_param->_have_port_rob_ptr)
    107     out_RETIRE_ROB_ID         = new SC_OUT(Tpacket_t         ) * [_param->_nb_inst_retire];
    108     out_RETIRE_OPERATION      = new SC_OUT(Toperation_t      ) * [_param->_nb_inst_retire];
    109     out_RETIRE_TYPE           = new SC_OUT(Ttype_t           ) * [_param->_nb_inst_retire];
    110     out_RETIRE_STORE_QUEUE_PTR_WRITE = new SC_OUT(Tlsq_ptr_t ) * [_param->_nb_inst_retire];
    111     if (_param->_have_port_load_queue_ptr)
    112     out_RETIRE_LOAD_QUEUE_PTR_WRITE  = new SC_OUT(Tlsq_ptr_t ) * [_param->_nb_inst_retire];
    113     out_RETIRE_HAS_IMMEDIAT   = new SC_OUT(Tcontrol_t        ) * [_param->_nb_inst_retire];
    114     out_RETIRE_IMMEDIAT       = new SC_OUT(Tgeneral_data_t   ) * [_param->_nb_inst_retire];
    115     out_RETIRE_DATA_RA        = new SC_OUT(Tgeneral_data_t   ) * [_param->_nb_inst_retire];
    116     out_RETIRE_DATA_RB        = new SC_OUT(Tgeneral_data_t   ) * [_param->_nb_inst_retire];
    117     out_RETIRE_DATA_RC        = new SC_OUT(Tspecial_data_t   ) * [_param->_nb_inst_retire];
    118     out_RETIRE_WRITE_RD       = new SC_OUT(Tcontrol_t        ) * [_param->_nb_inst_retire];
    119     out_RETIRE_NUM_REG_RD     = new SC_OUT(Tgeneral_address_t) * [_param->_nb_inst_retire];
    120     out_RETIRE_WRITE_RE       = new SC_OUT(Tcontrol_t        ) * [_param->_nb_inst_retire];
    121     out_RETIRE_NUM_REG_RE     = new SC_OUT(Tspecial_address_t) * [_param->_nb_inst_retire];
    122    
    123     for (uint32_t i=0; i<_param->_nb_inst_retire; i++)
    124       {
    125         Interface_fifo * interface = _interfaces->set_interface("retire_"+toString(i)
    126 #ifdef POSITION
    127                                                                 ,OUT
    128                                                                 ,WEST
    129                                                                 ,"Output of reservation_station"
    130 #endif
    131                                                                 );
    132         out_RETIRE_VAL          [i] = interface->set_signal_valack_out(VAL);
    133          in_RETIRE_ACK          [i] = interface->set_signal_valack_in (ACK);
    134         if (_param->_have_port_context_id)
    135         out_RETIRE_CONTEXT_ID   [i] = interface->set_signal_out<Tcontext_t        > ("context_id"   ,_param->_size_context_id);
    136         if (_param->_have_port_front_end_id)
    137         out_RETIRE_FRONT_END_ID [i] = interface->set_signal_out<Tcontext_t        > ("front_end_id" ,_param->_size_front_end_id);
    138         if (_param->_have_port_ooo_engine_id)
    139         out_RETIRE_OOO_ENGINE_ID[i] = interface->set_signal_out<Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id);
    140         if (_param->_have_port_rob_ptr)
    141         out_RETIRE_ROB_ID       [i] = interface->set_signal_out<Tpacket_t         > ("rob_id"       ,_param->_size_rob_ptr);
    142         out_RETIRE_OPERATION    [i] = interface->set_signal_out<Toperation_t      > ("operation"    ,_param->_size_operation);
    143         out_RETIRE_TYPE         [i] = interface->set_signal_out<Ttype_t           > ("type"         ,_param->_size_type);
    144         out_RETIRE_STORE_QUEUE_PTR_WRITE [i] = interface->set_signal_out<Tlsq_ptr_t> ("store_queue_ptr_write" ,_param->_size_store_queue_ptr);
    145         if (_param->_have_port_load_queue_ptr)
    146         out_RETIRE_LOAD_QUEUE_PTR_WRITE  [i] = interface->set_signal_out<Tlsq_ptr_t> ("load_queue_ptr_write"  ,_param->_size_load_queue_ptr );
     128    // ~~~~~[ Interface : "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     129     {
     130       ALLOC1_INTERFACE_BEGIN("spr_write",IN,SOUTH,_("Interface with write queue to bypass the write in the RegisterFile."),_param->_nb_spr_write);
     131       
     132       ALLOC1_VALACK_IN ( in_SPR_WRITE_VAL          ,VAL);
     133       ALLOC1_SIGNAL_IN ( in_SPR_WRITE_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id);
     134       ALLOC1_SIGNAL_IN ( in_SPR_WRITE_NUM_REG      ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
     135       ALLOC1_SIGNAL_IN ( in_SPR_WRITE_DATA         ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data);
    147136
    148         out_RETIRE_HAS_IMMEDIAT [i] = interface->set_signal_out<Tcontrol_t        > ("has_immediat" ,1);
    149         out_RETIRE_IMMEDIAT     [i] = interface->set_signal_out<Tgeneral_data_t   > ("immediat"     ,_param->_size_general_data);
    150         out_RETIRE_DATA_RA      [i] = interface->set_signal_out<Tgeneral_data_t   > ("data_ra"      ,_param->_size_general_data);
    151         out_RETIRE_DATA_RB      [i] = interface->set_signal_out<Tgeneral_data_t   > ("data_rb"      ,_param->_size_general_data);
    152         out_RETIRE_DATA_RC      [i] = interface->set_signal_out<Tspecial_data_t   > ("data_rc"      ,_param->_size_special_data);
    153         out_RETIRE_WRITE_RD     [i] = interface->set_signal_out<Tcontrol_t        > ("write_rd"     ,1);
    154         out_RETIRE_NUM_REG_RD   [i] = interface->set_signal_out<Tgeneral_address_t> ("num_reg_rd"   ,_param->_size_general_register);
    155         out_RETIRE_WRITE_RE     [i] = interface->set_signal_out<Tcontrol_t        > ("write_re"     ,1);
    156         out_RETIRE_NUM_REG_RE   [i] = interface->set_signal_out<Tspecial_address_t> ("num_reg_re"   ,_param->_size_special_register);
    157       }
     137       ALLOC1_INTERFACE_END(_param->_nb_spr_write);
     138     }
    158139
    159     // ~~~~~[ Interface : "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    160      in_GPR_WRITE_VAL          = new SC_IN (Tcontrol_t        ) * [_param->_nb_gpr_write];
    161      if (_param->_have_port_ooo_engine_id)
    162      in_GPR_WRITE_OOO_ENGINE_ID= new SC_IN (Tcontext_t        ) * [_param->_nb_gpr_write];
    163      in_GPR_WRITE_NUM_REG      = new SC_IN (Tgeneral_address_t) * [_param->_nb_gpr_write];
    164      in_GPR_WRITE_DATA         = new SC_IN (Tgeneral_data_t   ) * [_param->_nb_gpr_write];
     140     // ~~~~~[ Interface : "bypass_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     141     {
     142       ALLOC1_INTERFACE_BEGIN("bypass_write",IN,NORTH,_("Interface with write queue to bypass the write in the RegisterFile."),_param->_nb_bypass_write);
    165143
    166     for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
    167       {
    168         Interface_fifo * interface = _interfaces->set_interface("gpr_write_"+toString(i)
    169 #ifdef POSITION
    170                                                                 , IN 
    171                                                                 ,SOUTH
    172                                                                 , "Interface with write queue to bypass the write in the RegisterFile."
    173 #endif
    174                                                                 );
     144       ALLOC1_SIGNAL_IN ( in_BYPASS_WRITE_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id);
     145       ALLOC1_SIGNAL_IN ( in_BYPASS_WRITE_GPR_VAL      ,"gpr_val"      ,Tcontrol_t        ,1);
     146       ALLOC1_SIGNAL_IN ( in_BYPASS_WRITE_GPR_NUM_REG  ,"gpr_num_reg"  ,Tgeneral_address_t,_param->_size_general_register);
     147       ALLOC1_SIGNAL_IN ( in_BYPASS_WRITE_GPR_DATA     ,"gpr_data"     ,Tgeneral_data_t   ,_param->_size_general_data);
     148       ALLOC1_SIGNAL_IN ( in_BYPASS_WRITE_SPR_VAL      ,"spr_val"      ,Tcontrol_t        ,1);
     149       ALLOC1_SIGNAL_IN ( in_BYPASS_WRITE_SPR_NUM_REG  ,"spr_num_reg"  ,Tspecial_address_t,_param->_size_special_register);
     150       ALLOC1_SIGNAL_IN ( in_BYPASS_WRITE_SPR_DATA     ,"spr_data"     ,Tspecial_data_t   ,_param->_size_special_data);
     151       
     152       ALLOC1_INTERFACE_END(_param->_nb_bypass_write);
     153     }
     154     
     155     // ~~~~~[ Interface : "bypass_memory" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     156     {
     157       ALLOC1_INTERFACE_BEGIN("bypass_memory",IN,NORTH,_("Interface with load/store unit to bypass the write in the RegisterFile."),_param->_nb_bypass_memory);
    175158
    176          in_GPR_WRITE_VAL           [i] = interface->set_signal_valack_in (VAL);
    177          if (_param->_have_port_ooo_engine_id)
    178          in_GPR_WRITE_OOO_ENGINE_ID [i] = interface->set_signal_in  <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id);
    179          in_GPR_WRITE_NUM_REG       [i] = interface->set_signal_in  <Tgeneral_address_t> ("num_reg"      ,_param->_size_general_register);
    180          in_GPR_WRITE_DATA          [i] = interface->set_signal_in  <Tgeneral_data_t   > ("data"         ,_param->_size_general_data);
    181       }
    182 
    183     // ~~~~~[ Interface : "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    184      in_SPR_WRITE_VAL          = new SC_IN (Tcontrol_t        ) * [_param->_nb_spr_write];
    185      if (_param->_have_port_ooo_engine_id)
    186      in_SPR_WRITE_OOO_ENGINE_ID= new SC_IN (Tcontext_t        ) * [_param->_nb_spr_write];
    187      in_SPR_WRITE_NUM_REG      = new SC_IN (Tspecial_address_t) * [_param->_nb_spr_write];
    188      in_SPR_WRITE_DATA         = new SC_IN (Tspecial_data_t   ) * [_param->_nb_spr_write];
    189 
    190     for (uint32_t i=0; i<_param->_nb_spr_write; i++)
    191       {
    192         Interface_fifo * interface = _interfaces->set_interface("spr_write_"+toString(i)
    193 #ifdef POSITION
    194                                                                 , IN 
    195                                                                 ,SOUTH
    196                                                                 , "Interface with write queue to bypass the write in the RegisterFile."
    197 #endif
    198                                                                 );
    199 
    200          in_SPR_WRITE_VAL           [i] = interface->set_signal_valack_in (VAL);
    201          if (_param->_have_port_ooo_engine_id)
    202          in_SPR_WRITE_OOO_ENGINE_ID [i] = interface->set_signal_in  <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id);
    203          in_SPR_WRITE_NUM_REG       [i] = interface->set_signal_in  <Tspecial_address_t> ("num_reg"      ,_param->_size_special_register);
    204          in_SPR_WRITE_DATA          [i] = interface->set_signal_in  <Tspecial_data_t   > ("data"         ,_param->_size_special_data);
    205       }
    206 
    207     // ~~~~~[ Interface : "bypass_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    208      if (_param->_have_port_ooo_engine_id)
    209      in_BYPASS_WRITE_OOO_ENGINE_ID  = new SC_IN (Tcontext_t        ) * [_param->_nb_bypass_write];
    210      in_BYPASS_WRITE_GPR_VAL        = new SC_IN (Tcontrol_t        ) * [_param->_nb_bypass_write];
    211      in_BYPASS_WRITE_GPR_NUM_REG    = new SC_IN (Tgeneral_address_t) * [_param->_nb_bypass_write];
    212      in_BYPASS_WRITE_GPR_DATA       = new SC_IN (Tgeneral_data_t   ) * [_param->_nb_bypass_write];
    213      in_BYPASS_WRITE_SPR_VAL        = new SC_IN (Tcontrol_t        ) * [_param->_nb_bypass_write];
    214      in_BYPASS_WRITE_SPR_NUM_REG    = new SC_IN (Tspecial_address_t) * [_param->_nb_bypass_write];
    215      in_BYPASS_WRITE_SPR_DATA       = new SC_IN (Tspecial_data_t   ) * [_param->_nb_bypass_write];
    216 
    217     for (uint32_t i=0; i<_param->_nb_bypass_write; i++)
    218       {
    219         Interface_fifo * interface = _interfaces->set_interface("bypass_write_"+toString(i)
    220 #ifdef POSITION
    221                                                                 , IN 
    222                                                                 ,NORTH
    223                                                                 , "Interface with write queue to bypass the write in the RegisterFile."
    224 #endif
    225                                                                 );
    226 
    227          if (_param->_have_port_ooo_engine_id)
    228          in_BYPASS_WRITE_OOO_ENGINE_ID [i] = interface->set_signal_in  <Tcontext_t        > ("ooo_engine_id" ,_param->_size_ooo_engine_id);
    229          in_BYPASS_WRITE_GPR_VAL       [i] = interface->set_signal_valack_in ("gpr_val",VAL);               
    230          in_BYPASS_WRITE_GPR_NUM_REG   [i] = interface->set_signal_in  <Tgeneral_address_t> ("gpr_num_reg"   ,_param->_size_general_register);
    231          in_BYPASS_WRITE_GPR_DATA      [i] = interface->set_signal_in  <Tgeneral_data_t   > ("gpr_data"      ,_param->_size_general_data);
    232          in_BYPASS_WRITE_SPR_VAL       [i] = interface->set_signal_valack_in ("spr_val",VAL);               
    233          in_BYPASS_WRITE_SPR_NUM_REG   [i] = interface->set_signal_in  <Tspecial_address_t> ("spr_num_reg"   ,_param->_size_special_register);
    234          in_BYPASS_WRITE_SPR_DATA      [i] = interface->set_signal_in  <Tspecial_data_t   > ("spr_data"      ,_param->_size_special_data);
    235       }
    236 
    237     // ~~~~~[ Interface : "bypass_memory" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    238      in_BYPASS_MEMORY_VAL          = new SC_IN (Tcontrol_t        ) * [_param->_nb_bypass_memory];
    239      if (_param->_have_port_ooo_engine_id)
    240      in_BYPASS_MEMORY_OOO_ENGINE_ID= new SC_IN (Tcontext_t        ) * [_param->_nb_bypass_memory];
    241      in_BYPASS_MEMORY_NUM_REG      = new SC_IN (Tgeneral_address_t) * [_param->_nb_bypass_memory];
    242      in_BYPASS_MEMORY_DATA         = new SC_IN (Tgeneral_data_t   ) * [_param->_nb_bypass_memory];
    243 
    244     for (uint32_t i=0; i<_param->_nb_bypass_memory; i++)
    245       {
    246         Interface_fifo * interface = _interfaces->set_interface("bypass_memory_"+toString(i)
    247 #ifdef POSITION
    248                                                                 , IN 
    249                                                                 , NORTH
    250                                                                 , "Interface with load/store unit to bypass the write in the RegisterFile."
    251 #endif
    252                                                                 );
    253 
    254          in_BYPASS_MEMORY_VAL          [i] = interface->set_signal_valack_in (VAL);
    255          if (_param->_have_port_ooo_engine_id)
    256          in_BYPASS_MEMORY_OOO_ENGINE_ID[i] = interface->set_signal_in  <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id);
    257          in_BYPASS_MEMORY_NUM_REG      [i] = interface->set_signal_in  <Tgeneral_address_t> ("num_reg"      ,_param->_size_general_register);
    258          in_BYPASS_MEMORY_DATA         [i] = interface->set_signal_in  <Tgeneral_data_t   > ("data"         ,_param->_size_general_data);
    259       }
    260 
     159       ALLOC1_VALACK_IN ( in_BYPASS_MEMORY_VAL          ,VAL);
     160       ALLOC1_SIGNAL_IN ( in_BYPASS_MEMORY_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id);
     161       ALLOC1_SIGNAL_IN ( in_BYPASS_MEMORY_NUM_REG      ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
     162       ALLOC1_SIGNAL_IN ( in_BYPASS_MEMORY_DATA         ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data);
     163       
     164       ALLOC1_INTERFACE_END(_param->_nb_bypass_memory);
     165     }
    261166
    262167    if (usage_is_set(_usage,USE_SYSTEMC))
    263168      {
    264169    // ~~~~~[ internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    265     internal_RETIRE_VAL  = new Tcontrol_t [_param->_nb_inst_retire];
    266     internal_RETIRE_SLOT = new uint32_t   [_param->_nb_inst_retire];
     170        ALLOC1(internal_RETIRE_VAL ,Tcontrol_t,_param->_nb_inst_retire);
     171        ALLOC1(internal_RETIRE_SLOT,uint32_t  ,_param->_nb_inst_retire);
    267172      }
    268173

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

    r88 r112  
    1111
    1212#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/include/Reservation_station.h"
     13#include "Behavioural/include/Allocation.h"
    1314
    1415namespace morpheo                    {
    … …  
    3031    if (usage_is_set(_usage,USE_SYSTEMC))
    3132      {
    32     delete     in_CLOCK ;
    33     delete     in_NRESET;
     33        delete     in_CLOCK ;
     34        delete     in_NRESET;
    3435
    35     delete     in_INSERT_VAL           ;
    36     delete    out_INSERT_ACK           ;
    37     if (_param->_have_port_context_id)
    38     delete     in_INSERT_CONTEXT_ID    ;
    39     if (_param->_have_port_front_end_id)
    40     delete     in_INSERT_FRONT_END_ID  ;
    41     if (_param->_have_port_ooo_engine_id)
    42     delete     in_INSERT_OOO_ENGINE_ID ;
    43     if (_param->_have_port_rob_ptr)
    44     delete     in_INSERT_ROB_ID        ;
    45     delete     in_INSERT_OPERATION     ;
    46     delete     in_INSERT_TYPE          ;
    47     delete     in_INSERT_STORE_QUEUE_PTR_WRITE;
    48     if (_param->_have_port_load_queue_ptr)
    49     delete     in_INSERT_LOAD_QUEUE_PTR_WRITE ;
    50     delete     in_INSERT_HAS_IMMEDIAT  ;
    51     delete     in_INSERT_IMMEDIAT      ;
    52 //  delete     in_INSERT_READ_RA       ;
    53     delete     in_INSERT_NUM_REG_RA    ;
    54     delete     in_INSERT_DATA_RA_VAL   ;
    55     delete     in_INSERT_DATA_RA       ;
    56 //  delete     in_INSERT_READ_RB       ;
    57     delete     in_INSERT_NUM_REG_RB    ;
    58     delete     in_INSERT_DATA_RB_VAL   ;
    59     delete     in_INSERT_DATA_RB       ;
    60 //  delete     in_INSERT_READ_RC       ;
    61     delete     in_INSERT_NUM_REG_RC    ;
    62     delete     in_INSERT_DATA_RC_VAL   ;
    63     delete     in_INSERT_DATA_RC       ;
    64     delete     in_INSERT_WRITE_RD      ;
    65     delete     in_INSERT_NUM_REG_RD    ;
    66     delete     in_INSERT_WRITE_RE      ;
    67     delete     in_INSERT_NUM_REG_RE    ;
    68    
    69     delete [] out_RETIRE_VAL           ;
    70     delete []  in_RETIRE_ACK           ;
    71     if (_param->_have_port_context_id)
    72     delete [] out_RETIRE_CONTEXT_ID    ;
    73     if (_param->_have_port_front_end_id)
    74     delete [] out_RETIRE_FRONT_END_ID  ;
    75     if (_param->_have_port_ooo_engine_id)
    76     delete [] out_RETIRE_OOO_ENGINE_ID ;
    77     if (_param->_have_port_rob_ptr)
    78     delete [] out_RETIRE_ROB_ID        ;
    79     delete [] out_RETIRE_OPERATION     ;
    80     delete [] out_RETIRE_TYPE          ;
    81     delete [] out_RETIRE_STORE_QUEUE_PTR_WRITE;
    82     if (_param->_have_port_load_queue_ptr)
    83     delete [] out_RETIRE_LOAD_QUEUE_PTR_WRITE ;
    84     delete [] out_RETIRE_HAS_IMMEDIAT  ;
    85     delete [] out_RETIRE_IMMEDIAT      ;
    86     delete [] out_RETIRE_DATA_RA       ;
    87     delete [] out_RETIRE_DATA_RB       ;
    88     delete [] out_RETIRE_DATA_RC       ;
    89     delete [] out_RETIRE_WRITE_RD      ;
    90     delete [] out_RETIRE_NUM_REG_RD    ;
    91     delete [] out_RETIRE_WRITE_RE      ;
    92     delete [] out_RETIRE_NUM_REG_RE    ;
    93    
    94     delete []  in_GPR_WRITE_VAL         ;
    95     if (_param->_have_port_ooo_engine_id)
    96     delete []  in_GPR_WRITE_OOO_ENGINE_ID;
    97     delete []  in_GPR_WRITE_NUM_REG     ;
    98     delete []  in_GPR_WRITE_DATA        ;
    99    
    100     delete []  in_SPR_WRITE_VAL       ;
    101     if (_param->_have_port_ooo_engine_id)
    102     delete []  in_SPR_WRITE_OOO_ENGINE_ID;
    103     delete []  in_SPR_WRITE_NUM_REG   ;
    104     delete []  in_SPR_WRITE_DATA      ;
    105    
    106     if (_param->_have_port_ooo_engine_id)
    107     delete []  in_BYPASS_WRITE_OOO_ENGINE_ID;
    108     delete []  in_BYPASS_WRITE_GPR_VAL    ;
    109     delete []  in_BYPASS_WRITE_GPR_NUM_REG;
    110     delete []  in_BYPASS_WRITE_GPR_DATA   ;
    111     delete []  in_BYPASS_WRITE_SPR_VAL    ;
    112     delete []  in_BYPASS_WRITE_SPR_NUM_REG;
    113     delete []  in_BYPASS_WRITE_SPR_DATA   ;
    114    
    115     delete []  in_BYPASS_MEMORY_VAL       ;
    116     if (_param->_have_port_ooo_engine_id)
    117     delete []  in_BYPASS_MEMORY_OOO_ENGINE_ID;
    118     delete []  in_BYPASS_MEMORY_NUM_REG   ;
    119     delete []  in_BYPASS_MEMORY_DATA      ;
    120    
    121     // ~~~~~[ internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    122     delete []  internal_RETIRE_VAL;
    123     delete []  internal_RETIRE_SLOT;
     36        DELETE0_SIGNAL( in_INSERT_VAL                  ,1);
     37        DELETE0_SIGNAL(out_INSERT_ACK                  ,1);
     38        DELETE0_SIGNAL( in_INSERT_CONTEXT_ID           ,_param->_size_context_id      );
     39        DELETE0_SIGNAL( in_INSERT_FRONT_END_ID         ,_param->_size_front_end_id    );
     40        DELETE0_SIGNAL( in_INSERT_OOO_ENGINE_ID        ,_param->_size_ooo_engine_id   );
     41        DELETE0_SIGNAL( in_INSERT_ROB_ID               ,_param->_size_rob_ptr         );
     42        DELETE0_SIGNAL( in_INSERT_OPERATION            ,_param->_size_operation       );
     43        DELETE0_SIGNAL( in_INSERT_TYPE                 ,_param->_size_type            );
     44        DELETE0_SIGNAL( in_INSERT_STORE_QUEUE_PTR_WRITE,_param->_size_store_queue_ptr );
     45        DELETE0_SIGNAL( in_INSERT_LOAD_QUEUE_PTR_WRITE ,_param->_size_load_queue_ptr  );
     46        DELETE0_SIGNAL( in_INSERT_HAS_IMMEDIAT         ,1                             );
     47        DELETE0_SIGNAL( in_INSERT_IMMEDIAT             ,_param->_size_general_data    );
     48//      DELETE0_SIGNAL( in_INSERT_READ_RA              ,1                             );
     49        DELETE0_SIGNAL( in_INSERT_NUM_REG_RA           ,_param->_size_general_register);
     50        DELETE0_SIGNAL( in_INSERT_DATA_RA_VAL          ,1                             );
     51        DELETE0_SIGNAL( in_INSERT_DATA_RA              ,_param->_size_general_data    );
     52//      DELETE0_SIGNAL( in_INSERT_READ_RB              ,1                             );
     53        DELETE0_SIGNAL( in_INSERT_NUM_REG_RB           ,_param->_size_general_register);
     54        DELETE0_SIGNAL( in_INSERT_DATA_RB_VAL          ,1                             );
     55        DELETE0_SIGNAL( in_INSERT_DATA_RB              ,_param->_size_general_data    );
     56//      DELETE0_SIGNAL( in_INSERT_READ_RC              ,1                             );
     57        DELETE0_SIGNAL( in_INSERT_NUM_REG_RC           ,_param->_size_special_register);
     58        DELETE0_SIGNAL( in_INSERT_DATA_RC_VAL          ,1                             );
     59        DELETE0_SIGNAL( in_INSERT_DATA_RC              ,_param->_size_special_data    );
     60        DELETE0_SIGNAL( in_INSERT_WRITE_RD             ,1                             );
     61        DELETE0_SIGNAL( in_INSERT_NUM_REG_RD           ,_param->_size_general_register);
     62        DELETE0_SIGNAL( in_INSERT_WRITE_RE             ,1                             );
     63        DELETE0_SIGNAL( in_INSERT_NUM_REG_RE           ,_param->_size_special_register);
     64       
     65        DELETE1_SIGNAL(out_RETIRE_VAL                  ,_param->_nb_inst_retire,1);
     66        DELETE1_SIGNAL( in_RETIRE_ACK                  ,_param->_nb_inst_retire,1);
     67        DELETE1_SIGNAL(out_RETIRE_CONTEXT_ID           ,_param->_nb_inst_retire,_param->_size_context_id);
     68        DELETE1_SIGNAL(out_RETIRE_FRONT_END_ID         ,_param->_nb_inst_retire,_param->_size_front_end_id);
     69        DELETE1_SIGNAL(out_RETIRE_OOO_ENGINE_ID        ,_param->_nb_inst_retire,_param->_size_ooo_engine_id);
     70        DELETE1_SIGNAL(out_RETIRE_ROB_ID               ,_param->_nb_inst_retire,_param->_size_rob_ptr);
     71        DELETE1_SIGNAL(out_RETIRE_OPERATION            ,_param->_nb_inst_retire,_param->_size_operation);
     72        DELETE1_SIGNAL(out_RETIRE_TYPE                 ,_param->_nb_inst_retire,_param->_size_type);
     73        DELETE1_SIGNAL(out_RETIRE_STORE_QUEUE_PTR_WRITE,_param->_nb_inst_retire,_param->_size_store_queue_ptr);
     74        DELETE1_SIGNAL(out_RETIRE_LOAD_QUEUE_PTR_WRITE ,_param->_nb_inst_retire,_param->_size_load_queue_ptr );
     75        DELETE1_SIGNAL(out_RETIRE_HAS_IMMEDIAT         ,_param->_nb_inst_retire,1);
     76        DELETE1_SIGNAL(out_RETIRE_IMMEDIAT             ,_param->_nb_inst_retire,_param->_size_general_data);
     77        DELETE1_SIGNAL(out_RETIRE_DATA_RA              ,_param->_nb_inst_retire,_param->_size_general_data);
     78        DELETE1_SIGNAL(out_RETIRE_DATA_RB              ,_param->_nb_inst_retire,_param->_size_general_data);
     79        DELETE1_SIGNAL(out_RETIRE_DATA_RC              ,_param->_nb_inst_retire,_param->_size_special_data);
     80        DELETE1_SIGNAL(out_RETIRE_WRITE_RD             ,_param->_nb_inst_retire,1);
     81        DELETE1_SIGNAL(out_RETIRE_NUM_REG_RD           ,_param->_nb_inst_retire,_param->_size_general_register);
     82        DELETE1_SIGNAL(out_RETIRE_WRITE_RE             ,_param->_nb_inst_retire,1);
     83        DELETE1_SIGNAL(out_RETIRE_NUM_REG_RE           ,_param->_nb_inst_retire,_param->_size_special_register);
     84       
     85        DELETE1_SIGNAL( in_GPR_WRITE_VAL          ,_param->_nb_gpr_write,1);
     86        DELETE1_SIGNAL( in_GPR_WRITE_OOO_ENGINE_ID,_param->_nb_gpr_write,_param->_size_ooo_engine_id);
     87        DELETE1_SIGNAL( in_GPR_WRITE_NUM_REG      ,_param->_nb_gpr_write,_param->_size_general_register);
     88        DELETE1_SIGNAL( in_GPR_WRITE_DATA         ,_param->_nb_gpr_write,_param->_size_general_data);
     89       
     90        DELETE1_SIGNAL( in_SPR_WRITE_VAL          ,_param->_nb_spr_write,1);
     91        DELETE1_SIGNAL( in_SPR_WRITE_OOO_ENGINE_ID,_param->_nb_spr_write,_param->_size_ooo_engine_id);
     92        DELETE1_SIGNAL( in_SPR_WRITE_NUM_REG      ,_param->_nb_spr_write,_param->_size_general_register);
     93        DELETE1_SIGNAL( in_SPR_WRITE_DATA         ,_param->_nb_spr_write,_param->_size_general_data);
     94       
     95        DELETE1_SIGNAL( in_BYPASS_WRITE_OOO_ENGINE_ID,_param->_nb_bypass_write,_param->_size_ooo_engine_id);
     96        DELETE1_SIGNAL( in_BYPASS_WRITE_GPR_VAL      ,_param->_nb_bypass_write,1);
     97        DELETE1_SIGNAL( in_BYPASS_WRITE_GPR_NUM_REG  ,_param->_nb_bypass_write,_param->_size_general_register);
     98        DELETE1_SIGNAL( in_BYPASS_WRITE_GPR_DATA     ,_param->_nb_bypass_write,_param->_size_general_data);
     99        DELETE1_SIGNAL( in_BYPASS_WRITE_SPR_VAL      ,_param->_nb_bypass_write,1);
     100        DELETE1_SIGNAL( in_BYPASS_WRITE_SPR_NUM_REG  ,_param->_nb_bypass_write,_param->_size_special_register);
     101        DELETE1_SIGNAL( in_BYPASS_WRITE_SPR_DATA     ,_param->_nb_bypass_write,_param->_size_special_data);
     102       
     103        DELETE1_SIGNAL( in_BYPASS_MEMORY_VAL          ,_param->_nb_bypass_memory,1);
     104        DELETE1_SIGNAL( in_BYPASS_MEMORY_OOO_ENGINE_ID,_param->_nb_bypass_memory,_param->_size_ooo_engine_id);
     105        DELETE1_SIGNAL( in_BYPASS_MEMORY_NUM_REG      ,_param->_nb_bypass_memory,_param->_size_general_register);
     106        DELETE1_SIGNAL( in_BYPASS_MEMORY_DATA         ,_param->_nb_bypass_memory,_param->_size_general_data);
     107       
     108        DELETE1(internal_RETIRE_VAL ,_param->_nb_inst_retire);
     109        DELETE1(internal_RETIRE_SLOT,_param->_nb_inst_retire);
    124110      }
     111
    125112    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    126113

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

    r88 r112  
    6464  sc_signal<Tcontrol_t> *  in_NRESET = new sc_signal<Tcontrol_t> ("NRESET");
    6565
    66   ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_VAL                   ," in_READ_UNIT_IN_VAL                   ",Tcontrol_t        );
    67   ALLOC_SC_SIGNAL (out_READ_UNIT_IN_ACK                   ,"out_READ_UNIT_IN_ACK                   ",Tcontrol_t        );
    68   ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_CONTEXT_ID            ," in_READ_UNIT_IN_CONTEXT_ID            ",Tcontext_t        );
    69   ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_FRONT_END_ID          ," in_READ_UNIT_IN_FRONT_END_ID          ",Tcontext_t        );
    70   ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_OOO_ENGINE_ID         ," in_READ_UNIT_IN_OOO_ENGINE_ID         ",Tcontext_t        );
    71   ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_PACKET_ID             ," in_READ_UNIT_IN_PACKET_ID             ",Tpacket_t         );
    72   ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_OPERATION             ," in_READ_UNIT_IN_OPERATION             ",Toperation_t      );
    73   ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_TYPE                  ," in_READ_UNIT_IN_TYPE                  ",Ttype_t           );
    74   ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_STORE_QUEUE_PTR_WRITE ," in_READ_UNIT_IN_STORE_QUEUE_PTR_WRITE ",Tlsq_ptr_t        );
    75   ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_LOAD_QUEUE_PTR_WRITE  ," in_READ_UNIT_IN_LOAD_QUEUE_PTR_WRITE  ",Tlsq_ptr_t        );
    76   ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_HAS_IMMEDIAT          ," in_READ_UNIT_IN_HAS_IMMEDIAT          ",Tcontrol_t        );
    77   ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_IMMEDIAT              ," in_READ_UNIT_IN_IMMEDIAT              ",Tgeneral_data_t   );
    78   ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_READ_RA               ," in_READ_UNIT_IN_READ_RA               ",Tcontrol_t        );
    79   ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_NUM_REG_RA            ," in_READ_UNIT_IN_NUM_REG_RA            ",Tgeneral_address_t);
    80   ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_READ_RB               ," in_READ_UNIT_IN_READ_RB               ",Tcontrol_t        );
    81   ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_NUM_REG_RB            ," in_READ_UNIT_IN_NUM_REG_RB            ",Tgeneral_address_t);
    82   ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_READ_RC               ," in_READ_UNIT_IN_READ_RC               ",Tcontrol_t        );
    83   ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_NUM_REG_RC            ," in_READ_UNIT_IN_NUM_REG_RC            ",Tspecial_address_t);
    84   ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_WRITE_RD              ," in_READ_UNIT_IN_WRITE_RD              ",Tcontrol_t        );
    85   ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_NUM_REG_RD            ," in_READ_UNIT_IN_NUM_REG_RD            ",Tgeneral_address_t);
    86   ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_WRITE_RE              ," in_READ_UNIT_IN_WRITE_RE              ",Tcontrol_t        );
    87   ALLOC_SC_SIGNAL ( in_READ_UNIT_IN_NUM_REG_RE            ," in_READ_UNIT_IN_NUM_REG_RE            ",Tspecial_address_t);
     66  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_VAL                   ," in_READ_UNIT_IN_VAL                   ",Tcontrol_t        );
     67  ALLOC0_SC_SIGNAL(out_READ_UNIT_IN_ACK                   ,"out_READ_UNIT_IN_ACK                   ",Tcontrol_t        );
     68  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_CONTEXT_ID            ," in_READ_UNIT_IN_CONTEXT_ID            ",Tcontext_t        );
     69  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_FRONT_END_ID          ," in_READ_UNIT_IN_FRONT_END_ID          ",Tcontext_t        );
     70  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_OOO_ENGINE_ID         ," in_READ_UNIT_IN_OOO_ENGINE_ID         ",Tcontext_t        );
     71  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_PACKET_ID             ," in_READ_UNIT_IN_PACKET_ID             ",Tpacket_t         );
     72  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_OPERATION             ," in_READ_UNIT_IN_OPERATION             ",Toperation_t      );
     73  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_TYPE                  ," in_READ_UNIT_IN_TYPE                  ",Ttype_t           );
     74  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_STORE_QUEUE_PTR_WRITE ," in_READ_UNIT_IN_STORE_QUEUE_PTR_WRITE ",Tlsq_ptr_t        );
     75  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_LOAD_QUEUE_PTR_WRITE  ," in_READ_UNIT_IN_LOAD_QUEUE_PTR_WRITE  ",Tlsq_ptr_t        );
     76  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_HAS_IMMEDIAT          ," in_READ_UNIT_IN_HAS_IMMEDIAT          ",Tcontrol_t        );
     77  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_IMMEDIAT              ," in_READ_UNIT_IN_IMMEDIAT              ",Tgeneral_data_t   );
     78  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_READ_RA               ," in_READ_UNIT_IN_READ_RA               ",Tcontrol_t        );
     79  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_NUM_REG_RA            ," in_READ_UNIT_IN_NUM_REG_RA            ",Tgeneral_address_t);
     80  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_READ_RB               ," in_READ_UNIT_IN_READ_RB               ",Tcontrol_t        );
     81  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_NUM_REG_RB            ," in_READ_UNIT_IN_NUM_REG_RB            ",Tgeneral_address_t);
     82  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_READ_RC               ," in_READ_UNIT_IN_READ_RC               ",Tcontrol_t        );
     83  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_NUM_REG_RC            ," in_READ_UNIT_IN_NUM_REG_RC            ",Tspecial_address_t);
     84  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_WRITE_RD              ," in_READ_UNIT_IN_WRITE_RD              ",Tcontrol_t        );
     85  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_NUM_REG_RD            ," in_READ_UNIT_IN_NUM_REG_RD            ",Tgeneral_address_t);
     86  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_WRITE_RE              ," in_READ_UNIT_IN_WRITE_RE              ",Tcontrol_t        );
     87  ALLOC0_SC_SIGNAL( in_READ_UNIT_IN_NUM_REG_RE            ," in_READ_UNIT_IN_NUM_REG_RE            ",Tspecial_address_t);
    8888  ALLOC1_SC_SIGNAL(out_READ_UNIT_OUT_VAL                  ,"out_READ_UNIT_OUT_VAL                  ",Tcontrol_t        ,_param->_nb_inst_retire);
    8989  ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_ACK                  ," in_READ_UNIT_OUT_ACK                  ",Tcontrol_t        ,_param->_nb_inst_retire);
    … …  
    146146  (*(_Read_unit->in_NRESET))       (*(in_NRESET));
    147147
    148   INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_VAL                   );
    149   INSTANCE_SC_SIGNAL (_Read_unit,out_READ_UNIT_IN_ACK                   );
     148  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_VAL                   );
     149  INSTANCE0_SC_SIGNAL(_Read_unit,out_READ_UNIT_IN_ACK                   );
    150150  if (_param->_have_port_context_id)
    151   INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_CONTEXT_ID            );
     151  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_CONTEXT_ID            );
    152152  if (_param->_have_port_front_end_id)
    153   INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_FRONT_END_ID          );
     153  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_FRONT_END_ID          );
    154154  if (_param->_have_port_ooo_engine_id)
    155   INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_OOO_ENGINE_ID         );
     155  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_OOO_ENGINE_ID         );
    156156  if (_param->_have_port_rob_ptr)
    157   INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_PACKET_ID             );
    158   INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_OPERATION             );
    159   INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_TYPE                  );
    160   INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_STORE_QUEUE_PTR_WRITE );
     157  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_PACKET_ID             );
     158  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_OPERATION             );
     159  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_TYPE                  );
     160  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_STORE_QUEUE_PTR_WRITE );
    161161  if (_param->_have_port_load_queue_ptr)
    162   INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_LOAD_QUEUE_PTR_WRITE  );
    163   INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_HAS_IMMEDIAT          );
    164   INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_IMMEDIAT              );
    165   INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_READ_RA               );
    166   INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_NUM_REG_RA            );
    167   INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_READ_RB               );
    168   INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_NUM_REG_RB            );
    169   INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_READ_RC               );
    170   INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_NUM_REG_RC            );
    171   INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_WRITE_RD              );
    172   INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_NUM_REG_RD            );
    173   INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_WRITE_RE              );
    174   INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_NUM_REG_RE            );
     162  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_LOAD_QUEUE_PTR_WRITE  );
     163  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_HAS_IMMEDIAT          );
     164  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_IMMEDIAT              );
     165  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_READ_RA               );
     166  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_NUM_REG_RA            );
     167  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_READ_RB               );
     168  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_NUM_REG_RB            );
     169  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_READ_RC               );
     170  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_NUM_REG_RC            );
     171  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_WRITE_RD              );
     172  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_NUM_REG_RD            );
     173  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_WRITE_RE              );
     174  INSTANCE0_SC_SIGNAL(_Read_unit, in_READ_UNIT_IN_NUM_REG_RE            );
    175175  INSTANCE1_SC_SIGNAL(_Read_unit,out_READ_UNIT_OUT_VAL                  ,_param->_nb_inst_retire);
    176176  INSTANCE1_SC_SIGNAL(_Read_unit, in_READ_UNIT_OUT_ACK                  ,_param->_nb_inst_retire);

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

    r97 r112  
    5757    // ~~~~~[ Interface "read_unit_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    5858     {
    59        ALLOC_INTERFACE("read_unit_in", IN, WEST, _("Enter of new operation"));
    60 
    61        ALLOC_VALACK_IN    ( in_READ_UNIT_IN_VAL,VAL);
    62        ALLOC_VALACK_OUT   (out_READ_UNIT_IN_ACK,ACK);
    63        ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_CONTEXT_ID           ,"context_id"           ,Tcontext_t        ,_param->_size_context_id   );
    64        ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_FRONT_END_ID         ,"front_end_id"         ,Tcontext_t        ,_param->_size_front_end_id );
    65        ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_OOO_ENGINE_ID        ,"ooo_engine_id"        ,Tcontext_t        ,_param->_size_ooo_engine_id);
    66        ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_PACKET_ID            ,"packet_id"            ,Tpacket_t         ,_param->_size_rob_ptr    );
    67        ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_OPERATION            ,"operation"            ,Toperation_t      ,_param->_size_operation    );
    68        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_ptr);
    70        ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,"load_queue_ptr_write" ,Tlsq_ptr_t        ,_param->_size_load_queue_ptr);
    71        ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_HAS_IMMEDIAT         ,"has_immediat"         ,Tcontrol_t        ,1);
    72        ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_IMMEDIAT             ,"immediat"             ,Tgeneral_data_t   ,_param->_size_general_data);
    73        ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_READ_RA              ,"read_ra"              ,Tcontrol_t        ,1);
    74        ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_NUM_REG_RA           ,"num_reg_ra"           ,Tgeneral_address_t,_param->_size_general_register);
    75        ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_READ_RB              ,"read_rb"              ,Tcontrol_t        ,1);
    76        ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_NUM_REG_RB           ,"num_reg_rb"           ,Tgeneral_address_t,_param->_size_general_register);
    77        ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_READ_RC              ,"read_rc"              ,Tcontrol_t        ,1);
    78        ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_NUM_REG_RC           ,"num_reg_rc"           ,Tspecial_address_t,_param->_size_special_register);
    79        ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_WRITE_RD             ,"write_rd"             ,Tcontrol_t        ,1);
    80        ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_NUM_REG_RD           ,"num_reg_rd"           ,Tgeneral_address_t,_param->_size_general_register);
    81        ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_WRITE_RE             ,"write_re"             ,Tcontrol_t        ,1);
    82        ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_NUM_REG_RE           ,"num_reg_re"           ,Tspecial_address_t,_param->_size_special_register);
     59       ALLOC0_INTERFACE_BEGIN("read_unit_in", IN, WEST, _("Enter of new operation"));
     60
     61       ALLOC0_VALACK_IN    ( in_READ_UNIT_IN_VAL,VAL);
     62       ALLOC0_VALACK_OUT   (out_READ_UNIT_IN_ACK,ACK);
     63       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_CONTEXT_ID           ,"context_id"           ,Tcontext_t        ,_param->_size_context_id   );
     64       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_FRONT_END_ID         ,"front_end_id"         ,Tcontext_t        ,_param->_size_front_end_id );
     65       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_OOO_ENGINE_ID        ,"ooo_engine_id"        ,Tcontext_t        ,_param->_size_ooo_engine_id);
     66       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_PACKET_ID            ,"packet_id"            ,Tpacket_t         ,_param->_size_rob_ptr    );
     67       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_OPERATION            ,"operation"            ,Toperation_t      ,_param->_size_operation    );
     68       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_TYPE                 ,"type"                 ,Ttype_t           ,_param->_size_type         );
     69       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_STORE_QUEUE_PTR_WRITE,"store_queue_ptr_write",Tlsq_ptr_t        ,_param->_size_store_queue_ptr);
     70       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,"load_queue_ptr_write" ,Tlsq_ptr_t        ,_param->_size_load_queue_ptr);
     71       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_HAS_IMMEDIAT         ,"has_immediat"         ,Tcontrol_t        ,1);
     72       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_IMMEDIAT             ,"immediat"             ,Tgeneral_data_t   ,_param->_size_general_data);
     73       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_READ_RA              ,"read_ra"              ,Tcontrol_t        ,1);
     74       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_NUM_REG_RA           ,"num_reg_ra"           ,Tgeneral_address_t,_param->_size_general_register);
     75       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_READ_RB              ,"read_rb"              ,Tcontrol_t        ,1);
     76       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_NUM_REG_RB           ,"num_reg_rb"           ,Tgeneral_address_t,_param->_size_general_register);
     77       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_READ_RC              ,"read_rc"              ,Tcontrol_t        ,1);
     78       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_NUM_REG_RC           ,"num_reg_rc"           ,Tspecial_address_t,_param->_size_special_register);
     79       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_WRITE_RD             ,"write_rd"             ,Tcontrol_t        ,1);
     80       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_NUM_REG_RD           ,"num_reg_rd"           ,Tgeneral_address_t,_param->_size_general_register);
     81       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_WRITE_RE             ,"write_re"             ,Tcontrol_t        ,1);
     82       ALLOC0_SIGNAL_IN ( in_READ_UNIT_IN_NUM_REG_RE           ,"num_reg_re"           ,Tspecial_address_t,_param->_size_special_register);
     83
     84       ALLOC0_INTERFACE_END();
    8385     }
    8486
    8587    // ~~~~~[ Interface "read_unit_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    8688     {
    87        ALLOC1_INTERFACE("read_unit_out", OUT, EAST, _("Output of operation. All operand is valid."), _param->_nb_inst_retire);
     89       ALLOC1_INTERFACE_BEGIN("read_unit_out", OUT, EAST, _("Output of operation. All operand is valid."), _param->_nb_inst_retire);
    8890
    8991       ALLOC1_VALACK_OUT   (out_READ_UNIT_OUT_VAL,VAL);
    … …  
    106108       ALLOC1_SIGNAL_OUT(out_READ_UNIT_OUT_WRITE_RE             ,"write_re"             ,Tcontrol_t        ,1                             );
    107109       ALLOC1_SIGNAL_OUT(out_READ_UNIT_OUT_NUM_REG_RE           ,"num_reg_re"           ,Tspecial_address_t,_param->_size_special_register);
     110
     111       ALLOC1_INTERFACE_END(_param->_nb_inst_retire);
    108112     }
    109113
    110114    // ~~~~~[ Interface "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    111115     {
    112        ALLOC1_INTERFACE("gpr_read", OUT, SOUTH, _("Read port."), _param->_nb_gpr_read);
     116       ALLOC1_INTERFACE_BEGIN("gpr_read", OUT, SOUTH, _("Read port."), _param->_nb_gpr_read);
    113117
    114118       ALLOC1_VALACK_OUT   (out_GPR_READ_VAL,VAL);
    … …  
    118122       ALLOC1_SIGNAL_IN ( in_GPR_READ_DATA         ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data    );
    119123       ALLOC1_SIGNAL_IN ( in_GPR_READ_DATA_VAL     ,"data_val"     ,Tcontrol_t        ,1);
     124
     125       ALLOC1_INTERFACE_END(_param->_nb_gpr_read);
    120126     }
    121127
    122128    // ~~~~~[ Interface "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    123129     {
    124        ALLOC1_INTERFACE("spr_read", OUT, SOUTH, _("Read port."), _param->_nb_spr_read);
     130       ALLOC1_INTERFACE_BEGIN("spr_read", OUT, SOUTH, _("Read port."), _param->_nb_spr_read);
    125131
    126132       ALLOC1_VALACK_OUT   (out_SPR_READ_VAL,VAL);
    … …  
    130136       ALLOC1_SIGNAL_IN ( in_SPR_READ_DATA         ,"data"         ,Tspecial_data_t   ,_param->_size_special_data    );
    131137       ALLOC1_SIGNAL_IN ( in_SPR_READ_DATA_VAL     ,"data_val"     ,Tcontrol_t        ,1);
     138
     139       ALLOC1_INTERFACE_END(_param->_nb_spr_read);
    132140     }
    133141
    134142    // ~~~~~[ Interface "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    135143     {
    136        ALLOC1_INTERFACE("gpr_write", IN , SOUTH, _("Write port."), _param->_nb_gpr_write);
     144       ALLOC1_INTERFACE_BEGIN("gpr_write", IN , SOUTH, _("Write port."), _param->_nb_gpr_write);
    137145
    138146       ALLOC1_VALACK_IN    ( in_GPR_WRITE_VAL,VAL);
    … …  
    140148       ALLOC1_SIGNAL_IN ( in_GPR_WRITE_NUM_REG      ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
    141149       ALLOC1_SIGNAL_IN ( in_GPR_WRITE_DATA         ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data);
     150
     151       ALLOC1_INTERFACE_END(_param->_nb_gpr_write);
    142152     }
    143153
    144154    // ~~~~~[ Interface "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    145155     {
    146        ALLOC1_INTERFACE("spr_write", IN , SOUTH, _("Write port."), _param->_nb_spr_write);
     156       ALLOC1_INTERFACE_BEGIN("spr_write", IN , SOUTH, _("Write port."), _param->_nb_spr_write);
    147157
    148158       ALLOC1_VALACK_IN    ( in_SPR_WRITE_VAL,VAL);
    … …  
    150160       ALLOC1_SIGNAL_IN ( in_SPR_WRITE_NUM_REG      ,"num_reg"      ,Tspecial_address_t,_param->_size_special_register);
    151161       ALLOC1_SIGNAL_IN ( in_SPR_WRITE_DATA         ,"data"         ,Tspecial_data_t   ,_param->_size_special_data);
     162
     163       ALLOC1_INTERFACE_END(_param->_nb_spr_write);
    152164     }
    153165
    154166    // ~~~~~[ Interface "bypass_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    155167     {
    156        ALLOC1_INTERFACE("bypass_write", IN , NORTH, _("Output of write_queue."), _param->_nb_bypass_write);
     168       ALLOC1_INTERFACE_BEGIN("bypass_write", IN , NORTH, _("Output of write_queue."), _param->_nb_bypass_write);
    157169
    158170       ALLOC1_SIGNAL_IN ( in_BYPASS_WRITE_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id   );
    … …  
    163175       ALLOC1_SIGNAL_IN ( in_BYPASS_WRITE_SPR_NUM_REG  ,"spr_num_reg"  ,Tspecial_address_t,_param->_size_special_register);
    164176       ALLOC1_SIGNAL_IN ( in_BYPASS_WRITE_SPR_DATA     ,"spr_data"     ,Tspecial_data_t   ,_param->_size_special_data    );
     177
     178       ALLOC1_INTERFACE_END(_param->_nb_bypass_write);
    165179     }
    166180
    167181    // ~~~~~[ Interface "bypass_memory" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    168182     {
    169        ALLOC1_INTERFACE("bypass_memory", IN , NORTH, _("Output of write_queue."), _param->_nb_bypass_memory);
     183       ALLOC1_INTERFACE_BEGIN("bypass_memory", IN , NORTH, _("Output of write_queue."), _param->_nb_bypass_memory);
    170184
    171185       ALLOC1_SIGNAL_IN ( in_BYPASS_MEMORY_VAL          ,"val"          ,Tcontrol_t        ,1);
    … …  
    173187       ALLOC1_SIGNAL_IN ( in_BYPASS_MEMORY_NUM_REG      ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
    174188       ALLOC1_SIGNAL_IN ( in_BYPASS_MEMORY_DATA         ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data    );
     189
     190       ALLOC1_INTERFACE_END(_param->_nb_bypass_memory);
    175191     }
    176192

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

    r88 r112  
    77
    88#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/include/Read_unit.h"
     9#include "Behavioural/include/Allocation.h"
    910
    1011namespace morpheo                    {
    … …  
    2829        delete     in_NRESET;
    2930
    30         // ~~~~~[ Interface "read_unit_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    31         delete     in_READ_UNIT_IN_VAL                  ;
    32         delete    out_READ_UNIT_IN_ACK                  ;
    33         if (_param->_have_port_context_id)
    34         delete     in_READ_UNIT_IN_CONTEXT_ID           ;
    35         if (_param->_have_port_front_end_id)
    36         delete     in_READ_UNIT_IN_FRONT_END_ID         ;
    37         if (_param->_have_port_ooo_engine_id)
    38         delete     in_READ_UNIT_IN_OOO_ENGINE_ID        ;
    39         if (_param->_have_port_rob_ptr)
    40         delete     in_READ_UNIT_IN_PACKET_ID            ;
    41         delete     in_READ_UNIT_IN_OPERATION            ;
    42         delete     in_READ_UNIT_IN_TYPE                 ;
    43         delete     in_READ_UNIT_IN_STORE_QUEUE_PTR_WRITE;
    44         if (_param->_have_port_load_queue_ptr)
    45         delete     in_READ_UNIT_IN_LOAD_QUEUE_PTR_WRITE ;
    46         delete     in_READ_UNIT_IN_HAS_IMMEDIAT         ;
    47         delete     in_READ_UNIT_IN_IMMEDIAT             ;
    48         delete     in_READ_UNIT_IN_READ_RA              ;
    49         delete     in_READ_UNIT_IN_NUM_REG_RA           ;
    50         delete     in_READ_UNIT_IN_READ_RB              ;
    51         delete     in_READ_UNIT_IN_NUM_REG_RB           ;
    52         delete     in_READ_UNIT_IN_READ_RC              ;
    53         delete     in_READ_UNIT_IN_NUM_REG_RC           ;
    54         delete     in_READ_UNIT_IN_WRITE_RD             ;
    55         delete     in_READ_UNIT_IN_NUM_REG_RD           ;
    56         delete     in_READ_UNIT_IN_WRITE_RE             ;
    57         delete     in_READ_UNIT_IN_NUM_REG_RE           ;
     31        DELETE0_SIGNAL( in_READ_UNIT_IN_VAL                  ,1);
     32        DELETE0_SIGNAL(out_READ_UNIT_IN_ACK                  ,1);
     33        DELETE0_SIGNAL( in_READ_UNIT_IN_CONTEXT_ID           ,_param->_size_context_id   );
     34        DELETE0_SIGNAL( in_READ_UNIT_IN_FRONT_END_ID         ,_param->_size_front_end_id );
     35        DELETE0_SIGNAL( in_READ_UNIT_IN_OOO_ENGINE_ID        ,_param->_size_ooo_engine_id);
     36        DELETE0_SIGNAL( in_READ_UNIT_IN_PACKET_ID            ,_param->_size_rob_ptr    );
     37        DELETE0_SIGNAL( in_READ_UNIT_IN_OPERATION            ,_param->_size_operation    );
     38        DELETE0_SIGNAL( in_READ_UNIT_IN_TYPE                 ,_param->_size_type         );
     39        DELETE0_SIGNAL( in_READ_UNIT_IN_STORE_QUEUE_PTR_WRITE,_param->_size_store_queue_ptr);
     40        DELETE0_SIGNAL( in_READ_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,_param->_size_load_queue_ptr);
     41        DELETE0_SIGNAL( in_READ_UNIT_IN_HAS_IMMEDIAT         ,1);
     42        DELETE0_SIGNAL( in_READ_UNIT_IN_IMMEDIAT             ,_param->_size_general_data);
     43        DELETE0_SIGNAL( in_READ_UNIT_IN_READ_RA              ,1);
     44        DELETE0_SIGNAL( in_READ_UNIT_IN_NUM_REG_RA           ,_param->_size_general_register);
     45        DELETE0_SIGNAL( in_READ_UNIT_IN_READ_RB              ,1);
     46        DELETE0_SIGNAL( in_READ_UNIT_IN_NUM_REG_RB           ,_param->_size_general_register);
     47        DELETE0_SIGNAL( in_READ_UNIT_IN_READ_RC              ,1);
     48        DELETE0_SIGNAL( in_READ_UNIT_IN_NUM_REG_RC           ,_param->_size_special_register);
     49        DELETE0_SIGNAL( in_READ_UNIT_IN_WRITE_RD             ,1);
     50        DELETE0_SIGNAL( in_READ_UNIT_IN_NUM_REG_RD           ,_param->_size_general_register);
     51        DELETE0_SIGNAL( in_READ_UNIT_IN_WRITE_RE             ,1);
     52        DELETE0_SIGNAL( in_READ_UNIT_IN_NUM_REG_RE           ,_param->_size_special_register);
    5853
    59         // ~~~~~[ Interface "read_unit_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    60         delete [] out_READ_UNIT_OUT_VAL                  ;
    61         delete []  in_READ_UNIT_OUT_ACK                  ;
    62         if (_param->_have_port_context_id)
    63         delete [] out_READ_UNIT_OUT_CONTEXT_ID           ;
    64         if (_param->_have_port_front_end_id)
    65         delete [] out_READ_UNIT_OUT_FRONT_END_ID         ;
    66         if (_param->_have_port_ooo_engine_id)
    67         delete [] out_READ_UNIT_OUT_OOO_ENGINE_ID        ;
    68         if (_param->_have_port_rob_ptr)
    69         delete [] out_READ_UNIT_OUT_PACKET_ID            ;
    70         delete [] out_READ_UNIT_OUT_OPERATION            ;
    71         delete [] out_READ_UNIT_OUT_TYPE                 ;
    72         delete [] out_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE;
    73         if (_param->_have_port_load_queue_ptr)
    74         delete [] out_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ;
    75         delete [] out_READ_UNIT_OUT_HAS_IMMEDIAT         ;
    76         delete [] out_READ_UNIT_OUT_IMMEDIAT             ;
    77         delete [] out_READ_UNIT_OUT_DATA_RA              ;
    78         delete [] out_READ_UNIT_OUT_DATA_RB              ;
    79         delete [] out_READ_UNIT_OUT_DATA_RC              ;
    80         delete [] out_READ_UNIT_OUT_WRITE_RD             ;
    81         delete [] out_READ_UNIT_OUT_NUM_REG_RD           ;
    82         delete [] out_READ_UNIT_OUT_WRITE_RE             ;
    83         delete [] out_READ_UNIT_OUT_NUM_REG_RE           ;
     54        DELETE1_SIGNAL(out_READ_UNIT_OUT_VAL                  ,_param->_nb_inst_retire,1);
     55        DELETE1_SIGNAL( in_READ_UNIT_OUT_ACK                  ,_param->_nb_inst_retire,1);
     56        DELETE1_SIGNAL(out_READ_UNIT_OUT_CONTEXT_ID           ,_param->_nb_inst_retire,_param->_size_context_id      );
     57        DELETE1_SIGNAL(out_READ_UNIT_OUT_FRONT_END_ID         ,_param->_nb_inst_retire,_param->_size_front_end_id    );
     58        DELETE1_SIGNAL(out_READ_UNIT_OUT_OOO_ENGINE_ID        ,_param->_nb_inst_retire,_param->_size_ooo_engine_id   );
     59        DELETE1_SIGNAL(out_READ_UNIT_OUT_PACKET_ID            ,_param->_nb_inst_retire,_param->_size_rob_ptr       );
     60        DELETE1_SIGNAL(out_READ_UNIT_OUT_OPERATION            ,_param->_nb_inst_retire,_param->_size_operation       );
     61        DELETE1_SIGNAL(out_READ_UNIT_OUT_TYPE                 ,_param->_nb_inst_retire,_param->_size_type            );
     62        DELETE1_SIGNAL(out_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE,_param->_nb_inst_retire,_param->_size_store_queue_ptr);
     63        DELETE1_SIGNAL(out_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ,_param->_nb_inst_retire,_param->_size_load_queue_ptr);
     64        DELETE1_SIGNAL(out_READ_UNIT_OUT_HAS_IMMEDIAT         ,_param->_nb_inst_retire,1                             );
     65        DELETE1_SIGNAL(out_READ_UNIT_OUT_IMMEDIAT             ,_param->_nb_inst_retire,_param->_size_general_data    );
     66        DELETE1_SIGNAL(out_READ_UNIT_OUT_DATA_RA              ,_param->_nb_inst_retire,_param->_size_general_data    );
     67        DELETE1_SIGNAL(out_READ_UNIT_OUT_DATA_RB              ,_param->_nb_inst_retire,_param->_size_general_data    );
     68        DELETE1_SIGNAL(out_READ_UNIT_OUT_DATA_RC              ,_param->_nb_inst_retire,_param->_size_special_data    );
     69        DELETE1_SIGNAL(out_READ_UNIT_OUT_WRITE_RD             ,_param->_nb_inst_retire,1                             );
     70        DELETE1_SIGNAL(out_READ_UNIT_OUT_NUM_REG_RD           ,_param->_nb_inst_retire,_param->_size_general_register);
     71        DELETE1_SIGNAL(out_READ_UNIT_OUT_WRITE_RE             ,_param->_nb_inst_retire,1                             );
     72        DELETE1_SIGNAL(out_READ_UNIT_OUT_NUM_REG_RE           ,_param->_nb_inst_retire,_param->_size_special_register);
    8473
    85         // ~~~~~[ Interface "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    86         delete [] out_GPR_READ_VAL          ;
    87         delete []  in_GPR_READ_ACK          ;
    88         if (_param->_have_port_ooo_engine_id)
    89         delete [] out_GPR_READ_OOO_ENGINE_ID;
    90         delete [] out_GPR_READ_NUM_REG      ;
    91         delete []  in_GPR_READ_DATA         ;
    92         delete []  in_GPR_READ_DATA_VAL     ;
     74        DELETE1_SIGNAL(out_GPR_READ_VAL          , _param->_nb_gpr_read,1);
     75        DELETE1_SIGNAL( in_GPR_READ_ACK          , _param->_nb_gpr_read,1);
     76        DELETE1_SIGNAL(out_GPR_READ_OOO_ENGINE_ID, _param->_nb_gpr_read,_param->_size_ooo_engine_id   );
     77        DELETE1_SIGNAL(out_GPR_READ_NUM_REG      , _param->_nb_gpr_read,_param->_size_general_register);
     78        DELETE1_SIGNAL( in_GPR_READ_DATA         , _param->_nb_gpr_read,_param->_size_general_data    );
     79        DELETE1_SIGNAL( in_GPR_READ_DATA_VAL     , _param->_nb_gpr_read,1);
    9380
    94         // ~~~~~[ Interface "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    95         delete [] out_SPR_READ_VAL          ;
    96         delete []  in_SPR_READ_ACK          ;
    97         if (_param->_have_port_ooo_engine_id)
    98         delete [] out_SPR_READ_OOO_ENGINE_ID;
    99         delete [] out_SPR_READ_NUM_REG      ;
    100         delete []  in_SPR_READ_DATA         ;
    101         delete []  in_SPR_READ_DATA_VAL     ;
     81        DELETE1_SIGNAL(out_SPR_READ_VAL          , _param->_nb_spr_read,1);
     82        DELETE1_SIGNAL( in_SPR_READ_ACK          , _param->_nb_spr_read,1);
     83        DELETE1_SIGNAL(out_SPR_READ_OOO_ENGINE_ID, _param->_nb_spr_read,_param->_size_ooo_engine_id   );
     84        DELETE1_SIGNAL(out_SPR_READ_NUM_REG      , _param->_nb_spr_read,_param->_size_special_register);
     85        DELETE1_SIGNAL( in_SPR_READ_DATA         , _param->_nb_spr_read,_param->_size_special_data    );
     86        DELETE1_SIGNAL( in_SPR_READ_DATA_VAL     , _param->_nb_spr_read,1);
    10287
    103         // ~~~~~[ Interface "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    104         delete []  in_GPR_WRITE_VAL          ;
    105         if (_param->_have_port_ooo_engine_id)
    106         delete []  in_GPR_WRITE_OOO_ENGINE_ID;
    107         delete []  in_GPR_WRITE_NUM_REG      ;
    108         delete []  in_GPR_WRITE_DATA         ;
     88        DELETE1_SIGNAL( in_GPR_WRITE_VAL          , _param->_nb_gpr_write,1);
     89        DELETE1_SIGNAL( in_GPR_WRITE_OOO_ENGINE_ID, _param->_nb_gpr_write,_param->_size_ooo_engine_id   );
     90        DELETE1_SIGNAL( in_GPR_WRITE_NUM_REG      , _param->_nb_gpr_write,_param->_size_general_register);
     91        DELETE1_SIGNAL( in_GPR_WRITE_DATA         , _param->_nb_gpr_write,_param->_size_general_data);
    10992
    110         // ~~~~~[ Interface "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    111         delete []  in_SPR_WRITE_VAL          ;
    112         if (_param->_have_port_ooo_engine_id)
    113         delete []  in_SPR_WRITE_OOO_ENGINE_ID;
    114         delete []  in_SPR_WRITE_NUM_REG      ;
    115         delete []  in_SPR_WRITE_DATA         ;
     93        DELETE1_SIGNAL( in_SPR_WRITE_VAL          , _param->_nb_spr_write,1);
     94        DELETE1_SIGNAL( in_SPR_WRITE_OOO_ENGINE_ID, _param->_nb_spr_write,_param->_size_ooo_engine_id   );
     95        DELETE1_SIGNAL( in_SPR_WRITE_NUM_REG      , _param->_nb_spr_write,_param->_size_special_register);
     96        DELETE1_SIGNAL( in_SPR_WRITE_DATA         , _param->_nb_spr_write,_param->_size_special_data);
    11697
    117         // ~~~~~[ Interface "bypass_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    118         if (_param->_have_port_ooo_engine_id)
    119         delete []  in_BYPASS_WRITE_OOO_ENGINE_ID ;
    120         delete []  in_BYPASS_WRITE_GPR_VAL       ;
    121         delete []  in_BYPASS_WRITE_GPR_NUM_REG   ;
    122         delete []  in_BYPASS_WRITE_GPR_DATA      ;
    123         delete []  in_BYPASS_WRITE_SPR_VAL       ;
    124         delete []  in_BYPASS_WRITE_SPR_NUM_REG   ;
    125         delete []  in_BYPASS_WRITE_SPR_DATA      ;
     98        DELETE1_SIGNAL( in_BYPASS_WRITE_OOO_ENGINE_ID, _param->_nb_bypass_write,_param->_size_ooo_engine_id   );
     99        DELETE1_SIGNAL( in_BYPASS_WRITE_GPR_VAL      , _param->_nb_bypass_write,1);
     100        DELETE1_SIGNAL( in_BYPASS_WRITE_GPR_NUM_REG  , _param->_nb_bypass_write,_param->_size_general_register);
     101        DELETE1_SIGNAL( in_BYPASS_WRITE_GPR_DATA     , _param->_nb_bypass_write,_param->_size_general_data    );
     102        DELETE1_SIGNAL( in_BYPASS_WRITE_SPR_VAL      , _param->_nb_bypass_write,1);
     103        DELETE1_SIGNAL( in_BYPASS_WRITE_SPR_NUM_REG  , _param->_nb_bypass_write,_param->_size_special_register);
     104        DELETE1_SIGNAL( in_BYPASS_WRITE_SPR_DATA     , _param->_nb_bypass_write,_param->_size_special_data    );
    126105
    127         // ~~~~~[ Interface "bypass_memory" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    128         delete []  in_BYPASS_MEMORY_VAL          ;
    129         if (_param->_have_port_ooo_engine_id)
    130         delete []  in_BYPASS_MEMORY_OOO_ENGINE_ID;
    131         delete []  in_BYPASS_MEMORY_NUM_REG      ;
    132         delete []  in_BYPASS_MEMORY_DATA         ;
     106        DELETE1_SIGNAL( in_BYPASS_MEMORY_VAL          , _param->_nb_bypass_memory,1);
     107        DELETE1_SIGNAL( in_BYPASS_MEMORY_OOO_ENGINE_ID, _param->_nb_bypass_memory,_param->_size_ooo_engine_id   );
     108        DELETE1_SIGNAL( in_BYPASS_MEMORY_NUM_REG      , _param->_nb_bypass_memory,_param->_size_general_register);
     109        DELETE1_SIGNAL( in_BYPASS_MEMORY_DATA         , _param->_nb_bypass_memory,_param->_size_general_data    );
    133110      }
    134111    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   

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

    r98 r112  
    112112  sc_signal<Tcontrol_t> *  in_NRESET = new sc_signal<Tcontrol_t> ("NRESET");
    113113
    114   ALLOC_SC_SIGNAL ( in_EXECUTE_QUEUE_IN_VAL           ," in_EXECUTE_QUEUE_IN_VAL"           , Tcontrol_t        );
    115   ALLOC_SC_SIGNAL (out_EXECUTE_QUEUE_IN_ACK           ,"out_EXECUTE_QUEUE_IN_ACK"           , Tcontrol_t        );
    116   ALLOC_SC_SIGNAL ( in_EXECUTE_QUEUE_IN_CONTEXT_ID    ," in_EXECUTE_QUEUE_IN_CONTEXT_ID"    , Tcontext_t        );
    117   ALLOC_SC_SIGNAL ( in_EXECUTE_QUEUE_IN_FRONT_END_ID  ," in_EXECUTE_QUEUE_IN_FRONT_END_ID"  , Tcontext_t        );
    118   ALLOC_SC_SIGNAL ( in_EXECUTE_QUEUE_IN_OOO_ENGINE_ID ," in_EXECUTE_QUEUE_IN_OOO_ENGINE_ID" , Tcontext_t        );
    119   ALLOC_SC_SIGNAL ( in_EXECUTE_QUEUE_IN_PACKET_ID     ," in_EXECUTE_QUEUE_IN_PACKET_ID"     , Tpacket_t         );
    120 //ALLOC_SC_SIGNAL ( in_EXECUTE_QUEUE_IN_OPERATION     ," in_EXECUTE_QUEUE_IN_OPERATION"     , Toperation_t      );
    121 //ALLOC_SC_SIGNAL ( in_EXECUTE_QUEUE_IN_TYPE          ," in_EXECUTE_QUEUE_IN_TYPE"          , Ttype_t           );
    122   ALLOC_SC_SIGNAL ( in_EXECUTE_QUEUE_IN_FLAGS         ," in_EXECUTE_QUEUE_IN_FLAGS"         , Tspecial_data_t   );
    123   ALLOC_SC_SIGNAL ( in_EXECUTE_QUEUE_IN_EXCEPTION     ," in_EXECUTE_QUEUE_IN_EXCEPTION"     , Texception_t      );
    124   ALLOC_SC_SIGNAL ( in_EXECUTE_QUEUE_IN_NO_SEQUENCE   ," in_EXECUTE_QUEUE_IN_NO_SEQUENCE"   , Tcontrol_t        );
    125   ALLOC_SC_SIGNAL ( in_EXECUTE_QUEUE_IN_ADDRESS       ," in_EXECUTE_QUEUE_IN_ADDRESS"       , Taddress_t        );
    126   ALLOC_SC_SIGNAL ( in_EXECUTE_QUEUE_IN_DATA          ," in_EXECUTE_QUEUE_IN_DATA"          , Tgeneral_data_t   );
    127   ALLOC_SC_SIGNAL (out_EXECUTE_QUEUE_OUT_VAL          ,"out_EXECUTE_QUEUE_OUT_VAL"          , Tcontrol_t        );
    128   ALLOC_SC_SIGNAL ( in_EXECUTE_QUEUE_OUT_ACK          ," in_EXECUTE_QUEUE_OUT_ACK"          , Tcontrol_t        );
    129   ALLOC_SC_SIGNAL (out_EXECUTE_QUEUE_OUT_CONTEXT_ID   ,"out_EXECUTE_QUEUE_OUT_CONTEXT_ID"   , Tcontext_t        );
    130   ALLOC_SC_SIGNAL (out_EXECUTE_QUEUE_OUT_FRONT_END_ID ,"out_EXECUTE_QUEUE_OUT_FRONT_END_ID" , Tcontext_t        );
    131   ALLOC_SC_SIGNAL (out_EXECUTE_QUEUE_OUT_OOO_ENGINE_ID,"out_EXECUTE_QUEUE_OUT_OOO_ENGINE_ID", Tcontext_t        );
    132   ALLOC_SC_SIGNAL (out_EXECUTE_QUEUE_OUT_PACKET_ID    ,"out_EXECUTE_QUEUE_OUT_PACKET_ID"    , Tpacket_t         );
    133 //ALLOC_SC_SIGNAL (out_EXECUTE_QUEUE_OUT_OPERATION    ,"out_EXECUTE_QUEUE_OUT_OPERATION"    , Toperation_t      );
    134 //ALLOC_SC_SIGNAL (out_EXECUTE_QUEUE_OUT_TYPE         ,"out_EXECUTE_QUEUE_OUT_TYPE"         , Ttype_t           );
    135   ALLOC_SC_SIGNAL (out_EXECUTE_QUEUE_OUT_FLAGS        ,"out_EXECUTE_QUEUE_OUT_FLAGS"        , Tspecial_data_t   );
    136   ALLOC_SC_SIGNAL (out_EXECUTE_QUEUE_OUT_EXCEPTION    ,"out_EXECUTE_QUEUE_OUT_EXCEPTION"    , Texception_t      );
    137   ALLOC_SC_SIGNAL (out_EXECUTE_QUEUE_OUT_NO_SEQUENCE  ,"out_EXECUTE_QUEUE_OUT_NO_SEQUENCE"  , Tcontrol_t        );
    138   ALLOC_SC_SIGNAL (out_EXECUTE_QUEUE_OUT_ADDRESS      ,"out_EXECUTE_QUEUE_OUT_ADDRESS"      , Taddress_t        );
    139   ALLOC_SC_SIGNAL (out_EXECUTE_QUEUE_OUT_DATA         ,"out_EXECUTE_QUEUE_OUT_DATA"         , Tgeneral_data_t   );
     114  ALLOC0_SC_SIGNAL( in_EXECUTE_QUEUE_IN_VAL           ," in_EXECUTE_QUEUE_IN_VAL"           , Tcontrol_t        );
     115  ALLOC0_SC_SIGNAL(out_EXECUTE_QUEUE_IN_ACK           ,"out_EXECUTE_QUEUE_IN_ACK"           , Tcontrol_t        );
     116  ALLOC0_SC_SIGNAL( in_EXECUTE_QUEUE_IN_CONTEXT_ID    ," in_EXECUTE_QUEUE_IN_CONTEXT_ID"    , Tcontext_t        );
     117  ALLOC0_SC_SIGNAL( in_EXECUTE_QUEUE_IN_FRONT_END_ID  ," in_EXECUTE_QUEUE_IN_FRONT_END_ID"  , Tcontext_t        );
     118  ALLOC0_SC_SIGNAL( in_EXECUTE_QUEUE_IN_OOO_ENGINE_ID ," in_EXECUTE_QUEUE_IN_OOO_ENGINE_ID" , Tcontext_t        );
     119  ALLOC0_SC_SIGNAL( in_EXECUTE_QUEUE_IN_PACKET_ID     ," in_EXECUTE_QUEUE_IN_PACKET_ID"     , Tpacket_t         );
     120//ALLOC0_SC_SIGNAL( in_EXECUTE_QUEUE_IN_OPERATION     ," in_EXECUTE_QUEUE_IN_OPERATION"     , Toperation_t      );
     121//ALLOC0_SC_SIGNAL( in_EXECUTE_QUEUE_IN_TYPE          ," in_EXECUTE_QUEUE_IN_TYPE"          , Ttype_t           );
     122  ALLOC0_SC_SIGNAL( in_EXECUTE_QUEUE_IN_FLAGS         ," in_EXECUTE_QUEUE_IN_FLAGS"         , Tspecial_data_t   );
     123  ALLOC0_SC_SIGNAL( in_EXECUTE_QUEUE_IN_EXCEPTION     ," in_EXECUTE_QUEUE_IN_EXCEPTION"     , Texception_t      );
     124  ALLOC0_SC_SIGNAL( in_EXECUTE_QUEUE_IN_NO_SEQUENCE   ," in_EXECUTE_QUEUE_IN_NO_SEQUENCE"   , Tcontrol_t        );
     125  ALLOC0_SC_SIGNAL( in_EXECUTE_QUEUE_IN_ADDRESS       ," in_EXECUTE_QUEUE_IN_ADDRESS"       , Taddress_t        );
     126  ALLOC0_SC_SIGNAL( in_EXECUTE_QUEUE_IN_DATA          ," in_EXECUTE_QUEUE_IN_DATA"          , Tgeneral_data_t   );
     127  ALLOC0_SC_SIGNAL(out_EXECUTE_QUEUE_OUT_VAL          ,"out_EXECUTE_QUEUE_OUT_VAL"          , Tcontrol_t        );
     128  ALLOC0_SC_SIGNAL( in_EXECUTE_QUEUE_OUT_ACK          ," in_EXECUTE_QUEUE_OUT_ACK"          , Tcontrol_t        );
     129  ALLOC0_SC_SIGNAL(out_EXECUTE_QUEUE_OUT_CONTEXT_ID   ,"out_EXECUTE_QUEUE_OUT_CONTEXT_ID"   , Tcontext_t        );
     130  ALLOC0_SC_SIGNAL(out_EXECUTE_QUEUE_OUT_FRONT_END_ID ,"out_EXECUTE_QUEUE_OUT_FRONT_END_ID" , Tcontext_t        );
     131  ALLOC0_SC_SIGNAL(out_EXECUTE_QUEUE_OUT_OOO_ENGINE_ID,"out_EXECUTE_QUEUE_OUT_OOO_ENGINE_ID", Tcontext_t        );
     132  ALLOC0_SC_SIGNAL(out_EXECUTE_QUEUE_OUT_PACKET_ID    ,"out_EXECUTE_QUEUE_OUT_PACKET_ID"    , Tpacket_t         );
     133//ALLOC0_SC_SIGNAL(out_EXECUTE_QUEUE_OUT_OPERATION    ,"out_EXECUTE_QUEUE_OUT_OPERATION"    , Toperation_t      );
     134//ALLOC0_SC_SIGNAL(out_EXECUTE_QUEUE_OUT_TYPE         ,"out_EXECUTE_QUEUE_OUT_TYPE"         , Ttype_t           );
     135  ALLOC0_SC_SIGNAL(out_EXECUTE_QUEUE_OUT_FLAGS        ,"out_EXECUTE_QUEUE_OUT_FLAGS"        , Tspecial_data_t   );
     136  ALLOC0_SC_SIGNAL(out_EXECUTE_QUEUE_OUT_EXCEPTION    ,"out_EXECUTE_QUEUE_OUT_EXCEPTION"    , Texception_t      );
     137  ALLOC0_SC_SIGNAL(out_EXECUTE_QUEUE_OUT_NO_SEQUENCE  ,"out_EXECUTE_QUEUE_OUT_NO_SEQUENCE"  , Tcontrol_t        );
     138  ALLOC0_SC_SIGNAL(out_EXECUTE_QUEUE_OUT_ADDRESS      ,"out_EXECUTE_QUEUE_OUT_ADDRESS"      , Taddress_t        );
     139  ALLOC0_SC_SIGNAL(out_EXECUTE_QUEUE_OUT_DATA         ,"out_EXECUTE_QUEUE_OUT_DATA"         , Tgeneral_data_t   );
    140140
    141141 
    … …  
    149149  (*(_Execute_queue->in_NRESET))       (*(in_NRESET));
    150150
    151   INSTANCE_SC_SIGNAL (_Execute_queue,  in_EXECUTE_QUEUE_IN_VAL           );
    152   INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_IN_ACK           );
     151  INSTANCE0_SC_SIGNAL(_Execute_queue,  in_EXECUTE_QUEUE_IN_VAL           );
     152  INSTANCE0_SC_SIGNAL(_Execute_queue, out_EXECUTE_QUEUE_IN_ACK           );
    153153  if (_param->_have_port_context_id)
    154   INSTANCE_SC_SIGNAL (_Execute_queue,  in_EXECUTE_QUEUE_IN_CONTEXT_ID    );
     154  INSTANCE0_SC_SIGNAL(_Execute_queue,  in_EXECUTE_QUEUE_IN_CONTEXT_ID    );
    155155  if (_param->_have_port_front_end_id)
    156   INSTANCE_SC_SIGNAL (_Execute_queue,  in_EXECUTE_QUEUE_IN_FRONT_END_ID  );
     156  INSTANCE0_SC_SIGNAL(_Execute_queue,  in_EXECUTE_QUEUE_IN_FRONT_END_ID  );
    157157  if (_param->_have_port_ooo_engine_id)
    158   INSTANCE_SC_SIGNAL (_Execute_queue,  in_EXECUTE_QUEUE_IN_OOO_ENGINE_ID );
     158  INSTANCE0_SC_SIGNAL(_Execute_queue,  in_EXECUTE_QUEUE_IN_OOO_ENGINE_ID );
    159159  if (_param->_have_port_rob_ptr)
    160   INSTANCE_SC_SIGNAL (_Execute_queue,  in_EXECUTE_QUEUE_IN_PACKET_ID     );
    161 //INSTANCE_SC_SIGNAL (_Execute_queue,  in_EXECUTE_QUEUE_IN_OPERATION     );
    162 //INSTANCE_SC_SIGNAL (_Execute_queue,  in_EXECUTE_QUEUE_IN_TYPE          );
    163   INSTANCE_SC_SIGNAL (_Execute_queue,  in_EXECUTE_QUEUE_IN_FLAGS         );
    164   INSTANCE_SC_SIGNAL (_Execute_queue,  in_EXECUTE_QUEUE_IN_EXCEPTION     );
    165   INSTANCE_SC_SIGNAL (_Execute_queue,  in_EXECUTE_QUEUE_IN_NO_SEQUENCE   );
    166   INSTANCE_SC_SIGNAL (_Execute_queue,  in_EXECUTE_QUEUE_IN_ADDRESS       );
    167   INSTANCE_SC_SIGNAL (_Execute_queue,  in_EXECUTE_QUEUE_IN_DATA          );
    168 
    169   INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_OUT_VAL          );
    170   INSTANCE_SC_SIGNAL (_Execute_queue,  in_EXECUTE_QUEUE_OUT_ACK          );
     160  INSTANCE0_SC_SIGNAL(_Execute_queue,  in_EXECUTE_QUEUE_IN_PACKET_ID     );
     161//INSTANCE0_SC_SIGNAL(_Execute_queue,  in_EXECUTE_QUEUE_IN_OPERATION     );
     162//INSTANCE0_SC_SIGNAL(_Execute_queue,  in_EXECUTE_QUEUE_IN_TYPE          );
     163  INSTANCE0_SC_SIGNAL(_Execute_queue,  in_EXECUTE_QUEUE_IN_FLAGS         );
     164  INSTANCE0_SC_SIGNAL(_Execute_queue,  in_EXECUTE_QUEUE_IN_EXCEPTION     );
     165  INSTANCE0_SC_SIGNAL(_Execute_queue,  in_EXECUTE_QUEUE_IN_NO_SEQUENCE   );
     166  INSTANCE0_SC_SIGNAL(_Execute_queue,  in_EXECUTE_QUEUE_IN_ADDRESS       );
     167  INSTANCE0_SC_SIGNAL(_Execute_queue,  in_EXECUTE_QUEUE_IN_DATA          );
     168
     169  INSTANCE0_SC_SIGNAL(_Execute_queue, out_EXECUTE_QUEUE_OUT_VAL          );
     170  INSTANCE0_SC_SIGNAL(_Execute_queue,  in_EXECUTE_QUEUE_OUT_ACK          );
    171171  if (_param->_have_port_context_id)
    172   INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_OUT_CONTEXT_ID   );
     172  INSTANCE0_SC_SIGNAL(_Execute_queue, out_EXECUTE_QUEUE_OUT_CONTEXT_ID   );
    173173  if (_param->_have_port_front_end_id)
    174   INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_OUT_FRONT_END_ID );
     174  INSTANCE0_SC_SIGNAL(_Execute_queue, out_EXECUTE_QUEUE_OUT_FRONT_END_ID );
    175175  if (_param->_have_port_ooo_engine_id)
    176   INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_OUT_OOO_ENGINE_ID);
     176  INSTANCE0_SC_SIGNAL(_Execute_queue, out_EXECUTE_QUEUE_OUT_OOO_ENGINE_ID);
    177177  if (_param->_have_port_rob_ptr)
    178   INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_OUT_PACKET_ID    );
    179 //INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_OUT_OPERATION    );
    180 //INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_OUT_TYPE         );
    181   INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_OUT_FLAGS        );
    182   INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_OUT_EXCEPTION    );
    183   INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_OUT_NO_SEQUENCE  );
    184   INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_OUT_ADDRESS      );
    185   INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_OUT_DATA         );
     178  INSTANCE0_SC_SIGNAL(_Execute_queue, out_EXECUTE_QUEUE_OUT_PACKET_ID    );
     179//INSTANCE0_SC_SIGNAL(_Execute_queue, out_EXECUTE_QUEUE_OUT_OPERATION    );
     180//INSTANCE0_SC_SIGNAL(_Execute_queue, out_EXECUTE_QUEUE_OUT_TYPE         );
     181  INSTANCE0_SC_SIGNAL(_Execute_queue, out_EXECUTE_QUEUE_OUT_FLAGS        );
     182  INSTANCE0_SC_SIGNAL(_Execute_queue, out_EXECUTE_QUEUE_OUT_EXCEPTION    );
     183  INSTANCE0_SC_SIGNAL(_Execute_queue, out_EXECUTE_QUEUE_OUT_NO_SEQUENCE  );
     184  INSTANCE0_SC_SIGNAL(_Execute_queue, out_EXECUTE_QUEUE_OUT_ADDRESS      );
     185  INSTANCE0_SC_SIGNAL(_Execute_queue, out_EXECUTE_QUEUE_OUT_DATA         );
    186186
    187187  msg(_("<%s> : Start Simulation ............\n"),name.c_str());

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

    r101 r112  
    5050    // -----[ Interface "execute_queue_in" ]--------------------------------   
    5151     {
    52        ALLOC_INTERFACE ("execute_queue_in", IN, WEST, "Input of execute_queue");
     52       ALLOC0_INTERFACE_BEGIN("execute_queue_in", IN, WEST, "Input of execute_queue");
    5353       
    54        ALLOC_VALACK_IN ( in_EXECUTE_QUEUE_IN_VAL,VAL);
    55        ALLOC_VALACK_OUT(out_EXECUTE_QUEUE_IN_ACK,ACK);
    56        if(_param->_have_port_context_id)
    57        ALLOC_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_CONTEXT_ID   ,"context_id"   ,Tcontext_t        ,_param->_size_context_id       );
    58        if(_param->_have_port_front_end_id)
    59        ALLOC_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_FRONT_END_ID ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id     );
    60        if(_param->_have_port_ooo_engine_id)
    61        ALLOC_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id    );
    62        if(_param->_have_port_rob_ptr)
    63        ALLOC_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_PACKET_ID    ,"packet_id"    ,Tpacket_t         ,_param->_size_rob_ptr        );
    64 //     ALLOC_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_OPERATION    ,"operation"    ,Toperation_t      ,_param->_size_operation        );
    65 //     ALLOC_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_TYPE         ,"type"         ,Ttype_t           ,_param->_size_type             );
    66        ALLOC_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_FLAGS        ,"flags"        ,Tspecial_data_t   ,_param->_size_special_data     );
    67        ALLOC_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_EXCEPTION    ,"exception"    ,Texception_t      ,_param->_size_exception        );
    68        ALLOC_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t        ,1                              );
    69        ALLOC_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_ADDRESS      ,"address"      ,Taddress_t        ,_param->_size_instruction_address);
    70        ALLOC_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_DATA         ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data     );
     54       ALLOC0_VALACK_IN ( in_EXECUTE_QUEUE_IN_VAL,VAL);
     55       ALLOC0_VALACK_OUT(out_EXECUTE_QUEUE_IN_ACK,ACK);
     56       ALLOC0_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_CONTEXT_ID   ,"context_id"   ,Tcontext_t        ,_param->_size_context_id       );
     57       ALLOC0_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_FRONT_END_ID ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id     );
     58       ALLOC0_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id    );
     59       ALLOC0_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_PACKET_ID    ,"packet_id"    ,Tpacket_t         ,_param->_size_rob_ptr        );
     60//     ALLOC0_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_OPERATION    ,"operation"    ,Toperation_t      ,_param->_size_operation        );
     61//     ALLOC0_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_TYPE         ,"type"         ,Ttype_t           ,_param->_size_type             );
     62       ALLOC0_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_FLAGS        ,"flags"        ,Tspecial_data_t   ,_param->_size_special_data     );
     63       ALLOC0_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_EXCEPTION    ,"exception"    ,Texception_t      ,_param->_size_exception        );
     64       ALLOC0_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t        ,1                              );
     65       ALLOC0_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_ADDRESS      ,"address"      ,Taddress_t        ,_param->_size_instruction_address);
     66       ALLOC0_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_DATA         ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data     );
     67
     68       ALLOC0_INTERFACE_END();
    7169     }
    7270
    7371    // -----[ Interface "execute_queue_out" ]-------------------------------
    7472     {
    75        ALLOC_INTERFACE ("execute_queue_out", OUT, EAST, "Output of execute_queue");
     73       ALLOC0_INTERFACE_BEGIN("execute_queue_out", OUT, EAST, "Output of execute_queue");
    7674       
    77        ALLOC_VALACK_OUT(out_EXECUTE_QUEUE_OUT_VAL,VAL);
    78        ALLOC_VALACK_IN ( in_EXECUTE_QUEUE_OUT_ACK,ACK);
    79        if(_param->_have_port_context_id)
    80        ALLOC_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_CONTEXT_ID   ,"context_id"   ,Tcontext_t     ,_param->_size_context_id   );
    81        if(_param->_have_port_front_end_id)
    82        ALLOC_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_FRONT_END_ID ,"front_end_id" ,Tcontext_t     ,_param->_size_front_end_id );
    83        if(_param->_have_port_ooo_engine_id)
    84        ALLOC_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t     ,_param->_size_ooo_engine_id);
    85        if(_param->_have_port_rob_ptr)
    86        ALLOC_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_PACKET_ID    ,"packet_id"    ,Tpacket_t      ,_param->_size_rob_ptr    );
    87 //     ALLOC_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_OPERATION    ,"operation"    ,Toperation_t   ,_param->_size_operation    );
    88 //     ALLOC_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_TYPE         ,"type"         ,Ttype_t        ,_param->_size_type         );
    89        ALLOC_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_FLAGS        ,"flags"        ,Tspecial_data_t,_param->_size_special_data );
    90        ALLOC_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_EXCEPTION    ,"exception"    ,Texception_t   ,_param->_size_exception    );
    91        ALLOC_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t     ,1                          );
    92        ALLOC_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_ADDRESS      ,"address"      ,Taddress_t     ,_param->_size_instruction_address);
    93        ALLOC_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_DATA         ,"data"         ,Tgeneral_data_t,_param->_size_general_data );
     75       ALLOC0_VALACK_OUT(out_EXECUTE_QUEUE_OUT_VAL,VAL);
     76       ALLOC0_VALACK_IN ( in_EXECUTE_QUEUE_OUT_ACK,ACK);
     77       ALLOC0_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_CONTEXT_ID   ,"context_id"   ,Tcontext_t     ,_param->_size_context_id   );
     78       ALLOC0_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_FRONT_END_ID ,"front_end_id" ,Tcontext_t     ,_param->_size_front_end_id );
     79       ALLOC0_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t     ,_param->_size_ooo_engine_id);
     80       ALLOC0_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_PACKET_ID    ,"packet_id"    ,Tpacket_t      ,_param->_size_rob_ptr    );
     81//     ALLOC0_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_OPERATION    ,"operation"    ,Toperation_t   ,_param->_size_operation    );
     82//     ALLOC0_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_TYPE         ,"type"         ,Ttype_t        ,_param->_size_type         );
     83       ALLOC0_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_FLAGS        ,"flags"        ,Tspecial_data_t,_param->_size_special_data );
     84       ALLOC0_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_EXCEPTION    ,"exception"    ,Texception_t   ,_param->_size_exception    );
     85       ALLOC0_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t     ,1                          );
     86       ALLOC0_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_ADDRESS      ,"address"      ,Taddress_t     ,_param->_size_instruction_address);
     87       ALLOC0_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_DATA         ,"data"         ,Tgeneral_data_t,_param->_size_general_data );
     88
     89       ALLOC0_INTERFACE_END();
    9490     }
    9591

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

    r101 r112  
    77
    88#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue/include/Execute_queue.h"
     9#include "Behavioural/include/Allocation.h"
    910
    1011namespace morpheo                    {
    … …  
    2930        delete    in_NRESET;
    3031
    31         // -----[ Interface "execute_queue_in" ]--------------------------------   
    32         delete      in_EXECUTE_QUEUE_IN_VAL          ;
    33         delete     out_EXECUTE_QUEUE_IN_ACK          ;
    34         if (_param->_have_port_context_id)
    35         delete      in_EXECUTE_QUEUE_IN_CONTEXT_ID   ;
    36         if (_param->_have_port_front_end_id)
    37         delete      in_EXECUTE_QUEUE_IN_FRONT_END_ID ;
    38         if (_param->_have_port_ooo_engine_id)
    39         delete      in_EXECUTE_QUEUE_IN_OOO_ENGINE_ID;
    40         if (_param->_have_port_rob_ptr)
    41         delete      in_EXECUTE_QUEUE_IN_PACKET_ID    ;
    42 //      delete      in_EXECUTE_QUEUE_IN_OPERATION    ;
    43 //      delete      in_EXECUTE_QUEUE_IN_TYPE         ;
    44         delete      in_EXECUTE_QUEUE_IN_FLAGS        ;
    45         delete      in_EXECUTE_QUEUE_IN_EXCEPTION    ;
    46         delete      in_EXECUTE_QUEUE_IN_NO_SEQUENCE  ;
    47         delete      in_EXECUTE_QUEUE_IN_ADDRESS      ;
    48         delete      in_EXECUTE_QUEUE_IN_DATA         ;
    49 
    50         // -----[ Interface "execute_queue_out" ]-------------------------------   
    51         delete     out_EXECUTE_QUEUE_OUT_VAL          ;
    52         delete      in_EXECUTE_QUEUE_OUT_ACK          ;
    53         if (_param->_have_port_context_id)
    54         delete     out_EXECUTE_QUEUE_OUT_CONTEXT_ID   ;
    55         if (_param->_have_port_front_end_id)
    56         delete     out_EXECUTE_QUEUE_OUT_FRONT_END_ID ;
    57         if (_param->_have_port_ooo_engine_id)
    58         delete     out_EXECUTE_QUEUE_OUT_OOO_ENGINE_ID;
    59         if (_param->_have_port_rob_ptr)
    60         delete     out_EXECUTE_QUEUE_OUT_PACKET_ID    ;
    61 //      delete     out_EXECUTE_QUEUE_OUT_OPERATION    ;
    62 //      delete     out_EXECUTE_QUEUE_OUT_TYPE         ;
    63         delete     out_EXECUTE_QUEUE_OUT_FLAGS        ;
    64         delete     out_EXECUTE_QUEUE_OUT_EXCEPTION    ;
    65         delete     out_EXECUTE_QUEUE_OUT_NO_SEQUENCE  ;
    66         delete     out_EXECUTE_QUEUE_OUT_ADDRESS      ;
    67         delete     out_EXECUTE_QUEUE_OUT_DATA         ;
     32        DELETE0_SIGNAL( in_EXECUTE_QUEUE_IN_VAL           ,1);
     33        DELETE0_SIGNAL(out_EXECUTE_QUEUE_IN_ACK           ,1);
     34        DELETE0_SIGNAL( in_EXECUTE_QUEUE_IN_CONTEXT_ID    ,_param->_size_context_id       );
     35        DELETE0_SIGNAL( in_EXECUTE_QUEUE_IN_FRONT_END_ID  ,_param->_size_front_end_id     );
     36        DELETE0_SIGNAL( in_EXECUTE_QUEUE_IN_OOO_ENGINE_ID ,_param->_size_ooo_engine_id    );
     37        DELETE0_SIGNAL( in_EXECUTE_QUEUE_IN_PACKET_ID     ,_param->_size_rob_ptr          );
     38//      DELETE0_SIGNAL( in_EXECUTE_QUEUE_IN_OPERATION     ,_param->_size_operation        );
     39//      DELETE0_SIGNAL( in_EXECUTE_QUEUE_IN_TYPE          ,_param->_size_type             );
     40        DELETE0_SIGNAL( in_EXECUTE_QUEUE_IN_FLAGS         ,_param->_size_special_data     );
     41        DELETE0_SIGNAL( in_EXECUTE_QUEUE_IN_EXCEPTION     ,_param->_size_exception        );
     42        DELETE0_SIGNAL( in_EXECUTE_QUEUE_IN_NO_SEQUENCE   ,1                              );
     43        DELETE0_SIGNAL( in_EXECUTE_QUEUE_IN_ADDRESS       ,_param->_size_instruction_address);
     44        DELETE0_SIGNAL( in_EXECUTE_QUEUE_IN_DATA          ,_param->_size_general_data     );
     45       
     46        DELETE0_SIGNAL(out_EXECUTE_QUEUE_OUT_VAL          ,1);
     47        DELETE0_SIGNAL( in_EXECUTE_QUEUE_OUT_ACK          ,1);
     48        DELETE0_SIGNAL(out_EXECUTE_QUEUE_OUT_CONTEXT_ID   ,_param->_size_context_id   );
     49        DELETE0_SIGNAL(out_EXECUTE_QUEUE_OUT_FRONT_END_ID ,_param->_size_front_end_id );
     50        DELETE0_SIGNAL(out_EXECUTE_QUEUE_OUT_OOO_ENGINE_ID,_param->_size_ooo_engine_id);
     51        DELETE0_SIGNAL(out_EXECUTE_QUEUE_OUT_PACKET_ID    ,_param->_size_rob_ptr    );
     52//      DELETE0_SIGNAL(out_EXECUTE_QUEUE_OUT_OPERATION    ,_param->_size_operation    );
     53//      DELETE0_SIGNAL(out_EXECUTE_QUEUE_OUT_TYPE         ,_param->_size_type         );
     54        DELETE0_SIGNAL(out_EXECUTE_QUEUE_OUT_FLAGS        ,_param->_size_special_data );
     55        DELETE0_SIGNAL(out_EXECUTE_QUEUE_OUT_EXCEPTION    ,_param->_size_exception    );
     56        DELETE0_SIGNAL(out_EXECUTE_QUEUE_OUT_NO_SEQUENCE  ,1                          );
     57        DELETE0_SIGNAL(out_EXECUTE_QUEUE_OUT_ADDRESS      ,_param->_size_instruction_address);
     58        DELETE0_SIGNAL(out_EXECUTE_QUEUE_OUT_DATA         ,_param->_size_general_data );
    6859      }
    6960

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

    r97 r112  
    126126  sc_signal<Tcontrol_t> *  in_NRESET = new sc_signal<Tcontrol_t> ("NRESET");
    127127
    128   ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_VAL           ," in_WRITE_UNIT_IN_VAL"           , Tcontrol_t        );
    129   ALLOC_SC_SIGNAL (out_WRITE_UNIT_IN_ACK           ,"out_WRITE_UNIT_IN_ACK"           , Tcontrol_t        );
    130   ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_CONTEXT_ID    ," in_WRITE_UNIT_IN_CONTEXT_ID"    , Tcontext_t        );
    131   ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_FRONT_END_ID  ," in_WRITE_UNIT_IN_FRONT_END_ID"  , Tcontext_t        );
    132   ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_OOO_ENGINE_ID ," in_WRITE_UNIT_IN_OOO_ENGINE_ID" , Tcontext_t        );
    133   ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_PACKET_ID     ," in_WRITE_UNIT_IN_PACKET_ID"     , Tpacket_t         );
    134 //ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_OPERATION     ," in_WRITE_UNIT_IN_OPERATION"     , Toperation_t      );
    135 //ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_TYPE          ," in_WRITE_UNIT_IN_TYPE"          , Ttype_t           );
    136   ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_WRITE_RD      ," in_WRITE_UNIT_IN_WRITE_RD"      , Tcontrol_t        );
    137   ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_NUM_REG_RD    ," in_WRITE_UNIT_IN_NUM_REG_RD"    , Tgeneral_address_t);
    138   ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_DATA_RD       ," in_WRITE_UNIT_IN_DATA_RD"       , Tgeneral_data_t   );
    139   ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_WRITE_RE      ," in_WRITE_UNIT_IN_WRITE_RE"      , Tcontrol_t        );
    140   ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_NUM_REG_RE    ," in_WRITE_UNIT_IN_NUM_REG_RE"    , Tspecial_address_t);
    141   ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_DATA_RE       ," in_WRITE_UNIT_IN_DATA_RE"       , Tspecial_data_t   );
    142   ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_EXCEPTION     ," in_WRITE_UNIT_IN_EXCEPTION"     , Texception_t      );
    143   ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_NO_SEQUENCE   ," in_WRITE_UNIT_IN_NO_SEQUENCE"   , Tcontrol_t        );
    144   ALLOC_SC_SIGNAL ( in_WRITE_UNIT_IN_ADDRESS       ," in_WRITE_UNIT_IN_ADDRESS"       , Taddress_t        );
    145   ALLOC_SC_SIGNAL (out_WRITE_UNIT_OUT_VAL          ,"out_WRITE_UNIT_OUT_VAL"          , Tcontrol_t        );
    146   ALLOC_SC_SIGNAL ( in_WRITE_UNIT_OUT_ACK          ," in_WRITE_UNIT_OUT_ACK"          , Tcontrol_t        );
    147   ALLOC_SC_SIGNAL (out_WRITE_UNIT_OUT_CONTEXT_ID   ,"out_WRITE_UNIT_OUT_CONTEXT_ID"   , Tcontext_t        );
    148   ALLOC_SC_SIGNAL (out_WRITE_UNIT_OUT_FRONT_END_ID ,"out_WRITE_UNIT_OUT_FRONT_END_ID" , Tcontext_t        );
    149   ALLOC_SC_SIGNAL (out_WRITE_UNIT_OUT_OOO_ENGINE_ID,"out_WRITE_UNIT_OUT_OOO_ENGINE_ID", Tcontext_t        );
    150   ALLOC_SC_SIGNAL (out_WRITE_UNIT_OUT_PACKET_ID    ,"out_WRITE_UNIT_OUT_PACKET_ID"    , Tpacket_t         );
    151 //ALLOC_SC_SIGNAL (out_WRITE_UNIT_OUT_OPERATION    ,"out_WRITE_UNIT_OUT_OPERATION"    , Toperation_t      );
    152 //ALLOC_SC_SIGNAL (out_WRITE_UNIT_OUT_TYPE         ,"out_WRITE_UNIT_OUT_TYPE"         , Ttype_t           );
    153   ALLOC_SC_SIGNAL (out_WRITE_UNIT_OUT_FLAGS        ,"out_WRITE_UNIT_OUT_FLAGS"        , Tspecial_data_t   );
    154   ALLOC_SC_SIGNAL (out_WRITE_UNIT_OUT_EXCEPTION    ,"out_WRITE_UNIT_OUT_EXCEPTION"    , Texception_t      );
    155   ALLOC_SC_SIGNAL (out_WRITE_UNIT_OUT_NO_SEQUENCE  ,"out_WRITE_UNIT_OUT_NO_SEQUENCE"  , Tcontrol_t        );
    156   ALLOC_SC_SIGNAL (out_WRITE_UNIT_OUT_ADDRESS      ,"out_WRITE_UNIT_OUT_ADDRESS"      , Taddress_t        );
    157   ALLOC_SC_SIGNAL (out_WRITE_UNIT_OUT_DATA         ,"out_WRITE_UNIT_OUT_DATA"         , Tgeneral_data_t   );
     128  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_VAL           ," in_WRITE_UNIT_IN_VAL"           , Tcontrol_t        );
     129  ALLOC0_SC_SIGNAL(out_WRITE_UNIT_IN_ACK           ,"out_WRITE_UNIT_IN_ACK"           , Tcontrol_t        );
     130  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_CONTEXT_ID    ," in_WRITE_UNIT_IN_CONTEXT_ID"    , Tcontext_t        );
     131  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_FRONT_END_ID  ," in_WRITE_UNIT_IN_FRONT_END_ID"  , Tcontext_t        );
     132  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_OOO_ENGINE_ID ," in_WRITE_UNIT_IN_OOO_ENGINE_ID" , Tcontext_t        );
     133  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_PACKET_ID     ," in_WRITE_UNIT_IN_PACKET_ID"     , Tpacket_t         );
     134//ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_OPERATION     ," in_WRITE_UNIT_IN_OPERATION"     , Toperation_t      );
     135//ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_TYPE          ," in_WRITE_UNIT_IN_TYPE"          , Ttype_t           );
     136  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_WRITE_RD      ," in_WRITE_UNIT_IN_WRITE_RD"      , Tcontrol_t        );
     137  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_NUM_REG_RD    ," in_WRITE_UNIT_IN_NUM_REG_RD"    , Tgeneral_address_t);
     138  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_DATA_RD       ," in_WRITE_UNIT_IN_DATA_RD"       , Tgeneral_data_t   );
     139  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_WRITE_RE      ," in_WRITE_UNIT_IN_WRITE_RE"      , Tcontrol_t        );
     140  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_NUM_REG_RE    ," in_WRITE_UNIT_IN_NUM_REG_RE"    , Tspecial_address_t);
     141  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_DATA_RE       ," in_WRITE_UNIT_IN_DATA_RE"       , Tspecial_data_t   );
     142  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_EXCEPTION     ," in_WRITE_UNIT_IN_EXCEPTION"     , Texception_t      );
     143  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_NO_SEQUENCE   ," in_WRITE_UNIT_IN_NO_SEQUENCE"   , Tcontrol_t        );
     144  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_IN_ADDRESS       ," in_WRITE_UNIT_IN_ADDRESS"       , Taddress_t        );
     145  ALLOC0_SC_SIGNAL(out_WRITE_UNIT_OUT_VAL          ,"out_WRITE_UNIT_OUT_VAL"          , Tcontrol_t        );
     146  ALLOC0_SC_SIGNAL( in_WRITE_UNIT_OUT_ACK          ," in_WRITE_UNIT_OUT_ACK"          , Tcontrol_t        );
     147  ALLOC0_SC_SIGNAL(out_WRITE_UNIT_OUT_CONTEXT_ID   ,"out_WRITE_UNIT_OUT_CONTEXT_ID"   , Tcontext_t        );
     148  ALLOC0_SC_SIGNAL(out_WRITE_UNIT_OUT_FRONT_END_ID ,"out_WRITE_UNIT_OUT_FRONT_END_ID" , Tcontext_t        );
     149  ALLOC0_SC_SIGNAL(out_WRITE_UNIT_OUT_OOO_ENGINE_ID,"out_WRITE_UNIT_OUT_OOO_ENGINE_ID", Tcontext_t        );
     150  ALLOC0_SC_SIGNAL(out_WRITE_UNIT_OUT_PACKET_ID    ,"out_WRITE_UNIT_OUT_PACKET_ID"    , Tpacket_t         );
     151//ALLOC0_SC_SIGNAL(out_WRITE_UNIT_OUT_OPERATION    ,"out_WRITE_UNIT_OUT_OPERATION"    , Toperation_t      );
     152//ALLOC0_SC_SIGNAL(out_WRITE_UNIT_OUT_TYPE         ,"out_WRITE_UNIT_OUT_TYPE"         , Ttype_t           );
     153  ALLOC0_SC_SIGNAL(out_WRITE_UNIT_OUT_FLAGS        ,"out_WRITE_UNIT_OUT_FLAGS"        , Tspecial_data_t   );
     154  ALLOC0_SC_SIGNAL(out_WRITE_UNIT_OUT_EXCEPTION    ,"out_WRITE_UNIT_OUT_EXCEPTION"    , Texception_t      );
     155  ALLOC0_SC_SIGNAL(out_WRITE_UNIT_OUT_NO_SEQUENCE  ,"out_WRITE_UNIT_OUT_NO_SEQUENCE"  , Tcontrol_t        );
     156  ALLOC0_SC_SIGNAL(out_WRITE_UNIT_OUT_ADDRESS      ,"out_WRITE_UNIT_OUT_ADDRESS"      , Taddress_t        );
     157  ALLOC0_SC_SIGNAL(out_WRITE_UNIT_OUT_DATA         ,"out_WRITE_UNIT_OUT_DATA"         , Tgeneral_data_t   );
    158158  ALLOC1_SC_SIGNAL(out_GPR_WRITE_VAL                ,"out_GPR_WRITE_VAL"                , Tcontrol_t        , _param->_nb_gpr_write);
    159159  ALLOC1_SC_SIGNAL( in_GPR_WRITE_ACK                ," in_GPR_WRITE_ACK"                , Tcontrol_t        , _param->_nb_gpr_write);
    … …  
    184184  (*(_Write_unit->in_NRESET))       (*(in_NRESET));
    185185
    186   INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_VAL           );
    187   INSTANCE_SC_SIGNAL (_Write_unit, out_WRITE_UNIT_IN_ACK           );
     186  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_VAL           );
     187  INSTANCE0_SC_SIGNAL(_Write_unit, out_WRITE_UNIT_IN_ACK           );
    188188  if (_param->_have_port_context_id)
    189   INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_CONTEXT_ID    );
     189  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_CONTEXT_ID    );
    190190  if (_param->_have_port_front_end_id)
    191   INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_FRONT_END_ID  );
     191  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_FRONT_END_ID  );
    192192  if (_param->_have_port_ooo_engine_id)
    193   INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_OOO_ENGINE_ID );
     193  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_OOO_ENGINE_ID );
    194194  if (_param->_have_port_rob_ptr)
    195   INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_PACKET_ID     );
    196 //INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_OPERATION     );
    197 //INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_TYPE          );
    198   INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_WRITE_RD      );
    199   INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_NUM_REG_RD    );
    200   INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_DATA_RD       );
    201   INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_WRITE_RE      );
    202   INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_NUM_REG_RE    );
    203   INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_DATA_RE       );
    204   INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_EXCEPTION     );
    205   INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_NO_SEQUENCE   );
    206   INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_ADDRESS       );
    207   INSTANCE_SC_SIGNAL (_Write_unit, out_WRITE_UNIT_OUT_VAL          );
    208   INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_OUT_ACK          );
     195  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_PACKET_ID     );
     196//INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_OPERATION     );
     197//INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_TYPE          );
     198  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_WRITE_RD      );
     199  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_NUM_REG_RD    );
     200  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_DATA_RD       );
     201  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_WRITE_RE      );
     202  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_NUM_REG_RE    );
     203  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_DATA_RE       );
     204  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_EXCEPTION     );
     205  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_NO_SEQUENCE   );
     206  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_IN_ADDRESS       );
     207  INSTANCE0_SC_SIGNAL(_Write_unit, out_WRITE_UNIT_OUT_VAL          );
     208  INSTANCE0_SC_SIGNAL(_Write_unit,  in_WRITE_UNIT_OUT_ACK          );
    209209  if (_param->_have_port_context_id)
    210   INSTANCE_SC_SIGNAL (_Write_unit, out_WRITE_UNIT_OUT_CONTEXT_ID   );
     210  INSTANCE0_SC_SIGNAL(_Write_unit, out_WRITE_UNIT_OUT_CONTEXT_ID   );
    211211  if (_param->_have_port_front_end_id)
    212   INSTANCE_SC_SIGNAL (_Write_unit, out_WRITE_UNIT_OUT_FRONT_END_ID );
     212  INSTANCE0_SC_SIGNAL(_Write_unit, out_WRITE_UNIT_OUT_FRONT_END_ID );
    213213  if (_param->_have_port_ooo_engine_id)
    214   INSTANCE_SC_SIGNAL (_Write_unit, out_WRITE_UNIT_OUT_OOO_ENGINE_ID);
     214  INSTANCE0_SC_SIGNAL(_Write_unit, out_WRITE_UNIT_OUT_OOO_ENGINE_ID);
    215215  if (_param->_have_port_rob_ptr)
    216   INSTANCE_SC_SIGNAL (_Write_unit, out_WRITE_UNIT_OUT_PACKET_ID    );
    217 //INSTANCE_SC_SIGNAL (_Write_unit, out_WRITE_UNIT_OUT_OPERATION    );
    218 //INSTANCE_SC_SIGNAL (_Write_unit, out_WRITE_UNIT_OUT_TYPE         );
    219   INSTANCE_SC_SIGNAL (_Write_unit, out_WRITE_UNIT_OUT_FLAGS        );
    220   INSTANCE_SC_SIGNAL (_Write_unit, out_WRITE_UNIT_OUT_EXCEPTION    );
    221   INSTANCE_SC_SIGNAL (_Write_unit, out_WRITE_UNIT_OUT_NO_SEQUENCE  );
    222   INSTANCE_SC_SIGNAL (_Write_unit, out_WRITE_UNIT_OUT_ADDRESS      );
    223   INSTANCE_SC_SIGNAL (_Write_unit, out_WRITE_UNIT_OUT_DATA         );
     216  INSTANCE0_SC_SIGNAL(_Write_unit, out_WRITE_UNIT_OUT_PACKET_ID    );
     217//INSTANCE0_SC_SIGNAL(_Write_unit, out_WRITE_UNIT_OUT_OPERATION    );
     218//INSTANCE0_SC_SIGNAL(_Write_unit, out_WRITE_UNIT_OUT_TYPE         );
     219  INSTANCE0_SC_SIGNAL(_Write_unit, out_WRITE_UNIT_OUT_FLAGS        );
     220  INSTANCE0_SC_SIGNAL(_Write_unit, out_WRITE_UNIT_OUT_EXCEPTION    );
     221  INSTANCE0_SC_SIGNAL(_Write_unit, out_WRITE_UNIT_OUT_NO_SEQUENCE  );
     222  INSTANCE0_SC_SIGNAL(_Write_unit, out_WRITE_UNIT_OUT_ADDRESS      );
     223  INSTANCE0_SC_SIGNAL(_Write_unit, out_WRITE_UNIT_OUT_DATA         );
    224224  INSTANCE1_SC_SIGNAL(_Write_unit, out_GPR_WRITE_VAL                , _param->_nb_gpr_write);
    225225  INSTANCE1_SC_SIGNAL(_Write_unit,  in_GPR_WRITE_ACK                , _param->_nb_gpr_write);

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

    r97 r112  
    125125  sc_signal<Tcontrol_t> *  in_NRESET = new sc_signal<Tcontrol_t> ("NRESET");
    126126
    127   ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_VAL           ," in_WRITE_QUEUE_IN_VAL"           , Tcontrol_t        );
    128   ALLOC_SC_SIGNAL (out_WRITE_QUEUE_IN_ACK           ,"out_WRITE_QUEUE_IN_ACK"           , Tcontrol_t        );
    129   ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_CONTEXT_ID    ," in_WRITE_QUEUE_IN_CONTEXT_ID"    , Tcontext_t        );
    130   ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_FRONT_END_ID  ," in_WRITE_QUEUE_IN_FRONT_END_ID"  , Tcontext_t        );
    131   ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_OOO_ENGINE_ID ," in_WRITE_QUEUE_IN_OOO_ENGINE_ID" , Tcontext_t        );
    132   ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_PACKET_ID     ," in_WRITE_QUEUE_IN_PACKET_ID"     , Tpacket_t         );
    133 //ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_OPERATION     ," in_WRITE_QUEUE_IN_OPERATION"     , Toperation_t      );
    134 //ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_TYPE          ," in_WRITE_QUEUE_IN_TYPE"          , Ttype_t           );
    135   ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_WRITE_RD      ," in_WRITE_QUEUE_IN_WRITE_RD"      , Tcontrol_t        );
    136   ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_NUM_REG_RD    ," in_WRITE_QUEUE_IN_NUM_REG_RD"    , Tgeneral_address_t);
    137   ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_DATA_RD       ," in_WRITE_QUEUE_IN_DATA_RD"       , Tgeneral_data_t   );
    138   ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_WRITE_RE      ," in_WRITE_QUEUE_IN_WRITE_RE"      , Tcontrol_t        );
    139   ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_NUM_REG_RE    ," in_WRITE_QUEUE_IN_NUM_REG_RE"    , Tspecial_address_t);
    140   ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_DATA_RE       ," in_WRITE_QUEUE_IN_DATA_RE"       , Tspecial_data_t   );
    141   ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_EXCEPTION     ," in_WRITE_QUEUE_IN_EXCEPTION"     , Texception_t      );
    142   ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_NO_SEQUENCE   ," in_WRITE_QUEUE_IN_NO_SEQUENCE"   , Tcontrol_t        );
    143   ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_IN_ADDRESS       ," in_WRITE_QUEUE_IN_ADDRESS"       , Taddress_t        );
    144   ALLOC_SC_SIGNAL (out_WRITE_QUEUE_OUT_VAL          ,"out_WRITE_QUEUE_OUT_VAL"          , Tcontrol_t        );
    145   ALLOC_SC_SIGNAL ( in_WRITE_QUEUE_OUT_ACK          ," in_WRITE_QUEUE_OUT_ACK"          , Tcontrol_t        );
    146   ALLOC_SC_SIGNAL (out_WRITE_QUEUE_OUT_CONTEXT_ID   ,"out_WRITE_QUEUE_OUT_CONTEXT_ID"   , Tcontext_t        );
    147   ALLOC_SC_SIGNAL (out_WRITE_QUEUE_OUT_FRONT_END_ID ,"out_WRITE_QUEUE_OUT_FRONT_END_ID" , Tcontext_t        );
    148   ALLOC_SC_SIGNAL (out_WRITE_QUEUE_OUT_OOO_ENGINE_ID,"out_WRITE_QUEUE_OUT_OOO_ENGINE_ID", Tcontext_t        );
    149   ALLOC_SC_SIGNAL (out_WRITE_QUEUE_OUT_PACKET_ID    ,"out_WRITE_QUEUE_OUT_PACKET_ID"    , Tpacket_t         );
    150 //ALLOC_SC_SIGNAL (out_WRITE_QUEUE_OUT_OPERATION    ,"out_WRITE_QUEUE_OUT_OPERATION"    , Toperation_t      );
    151 //ALLOC_SC_SIGNAL (out_WRITE_QUEUE_OUT_TYPE         ,"out_WRITE_QUEUE_OUT_TYPE"         , Ttype_t           );
    152   ALLOC_SC_SIGNAL (out_WRITE_QUEUE_OUT_FLAGS        ,"out_WRITE_QUEUE_OUT_FLAGS"        , Tspecial_data_t   );
    153   ALLOC_SC_SIGNAL (out_WRITE_QUEUE_OUT_EXCEPTION    ,"out_WRITE_QUEUE_OUT_EXCEPTION"    , Texception_t      );
    154   ALLOC_SC_SIGNAL (out_WRITE_QUEUE_OUT_NO_SEQUENCE  ,"out_WRITE_QUEUE_OUT_NO_SEQUENCE"  , Tcontrol_t        );
    155   ALLOC_SC_SIGNAL (out_WRITE_QUEUE_OUT_ADDRESS      ,"out_WRITE_QUEUE_OUT_ADDRESS"      , Tgeneral_data_t   );
    156   ALLOC_SC_SIGNAL (out_WRITE_QUEUE_OUT_DATA         ,"out_WRITE_QUEUE_OUT_DATA"         , Taddress_t        );
     127  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_VAL           ," in_WRITE_QUEUE_IN_VAL"           , Tcontrol_t        );
     128  ALLOC0_SC_SIGNAL(out_WRITE_QUEUE_IN_ACK           ,"out_WRITE_QUEUE_IN_ACK"           , Tcontrol_t        );
     129  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_CONTEXT_ID    ," in_WRITE_QUEUE_IN_CONTEXT_ID"    , Tcontext_t        );
     130  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_FRONT_END_ID  ," in_WRITE_QUEUE_IN_FRONT_END_ID"  , Tcontext_t        );
     131  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_OOO_ENGINE_ID ," in_WRITE_QUEUE_IN_OOO_ENGINE_ID" , Tcontext_t        );
     132  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_PACKET_ID     ," in_WRITE_QUEUE_IN_PACKET_ID"     , Tpacket_t         );
     133//ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_OPERATION     ," in_WRITE_QUEUE_IN_OPERATION"     , Toperation_t      );
     134//ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_TYPE          ," in_WRITE_QUEUE_IN_TYPE"          , Ttype_t           );
     135  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_WRITE_RD      ," in_WRITE_QUEUE_IN_WRITE_RD"      , Tcontrol_t        );
     136  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_NUM_REG_RD    ," in_WRITE_QUEUE_IN_NUM_REG_RD"    , Tgeneral_address_t);
     137  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_DATA_RD       ," in_WRITE_QUEUE_IN_DATA_RD"       , Tgeneral_data_t   );
     138  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_WRITE_RE      ," in_WRITE_QUEUE_IN_WRITE_RE"      , Tcontrol_t        );
     139  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_NUM_REG_RE    ," in_WRITE_QUEUE_IN_NUM_REG_RE"    , Tspecial_address_t);
     140  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_DATA_RE       ," in_WRITE_QUEUE_IN_DATA_RE"       , Tspecial_data_t   );
     141  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_EXCEPTION     ," in_WRITE_QUEUE_IN_EXCEPTION"     , Texception_t      );
     142  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_NO_SEQUENCE   ," in_WRITE_QUEUE_IN_NO_SEQUENCE"   , Tcontrol_t        );
     143  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_IN_ADDRESS       ," in_WRITE_QUEUE_IN_ADDRESS"       , Taddress_t        );
     144  ALLOC0_SC_SIGNAL(out_WRITE_QUEUE_OUT_VAL          ,"out_WRITE_QUEUE_OUT_VAL"          , Tcontrol_t        );
     145  ALLOC0_SC_SIGNAL( in_WRITE_QUEUE_OUT_ACK          ," in_WRITE_QUEUE_OUT_ACK"          , Tcontrol_t        );
     146  ALLOC0_SC_SIGNAL(out_WRITE_QUEUE_OUT_CONTEXT_ID   ,"out_WRITE_QUEUE_OUT_CONTEXT_ID"   , Tcontext_t        );
     147  ALLOC0_SC_SIGNAL(out_WRITE_QUEUE_OUT_FRONT_END_ID ,"out_WRITE_QUEUE_OUT_FRONT_END_ID" , Tcontext_t        );
     148  ALLOC0_SC_SIGNAL(out_WRITE_QUEUE_OUT_OOO_ENGINE_ID,"out_WRITE_QUEUE_OUT_OOO_ENGINE_ID", Tcontext_t        );
     149  ALLOC0_SC_SIGNAL(out_WRITE_QUEUE_OUT_PACKET_ID    ,"out_WRITE_QUEUE_OUT_PACKET_ID"    , Tpacket_t         );
     150//ALLOC0_SC_SIGNAL(out_WRITE_QUEUE_OUT_OPERATION    ,"out_WRITE_QUEUE_OUT_OPERATION"    , Toperation_t      );
     151//ALLOC0_SC_SIGNAL(out_WRITE_QUEUE_OUT_TYPE         ,"out_WRITE_QUEUE_OUT_TYPE"         , Ttype_t           );
     152  ALLOC0_SC_SIGNAL(out_WRITE_QUEUE_OUT_FLAGS        ,"out_WRITE_QUEUE_OUT_FLAGS"        , Tspecial_data_t   );
     153  ALLOC0_SC_SIGNAL(out_WRITE_QUEUE_OUT_EXCEPTION    ,"out_WRITE_QUEUE_OUT_EXCEPTION"    , Texception_t      );
     154  ALLOC0_SC_SIGNAL(out_WRITE_QUEUE_OUT_NO_SEQUENCE  ,"out_WRITE_QUEUE_OUT_NO_SEQUENCE"  , Tcontrol_t        );
     155  ALLOC0_SC_SIGNAL(out_WRITE_QUEUE_OUT_ADDRESS      ,"out_WRITE_QUEUE_OUT_ADDRESS"      , Tgeneral_data_t   );
     156  ALLOC0_SC_SIGNAL(out_WRITE_QUEUE_OUT_DATA         ,"out_WRITE_QUEUE_OUT_DATA"         , Taddress_t        );
    157157  ALLOC1_SC_SIGNAL(out_GPR_WRITE_VAL                ,"out_GPR_WRITE_VAL"                , Tcontrol_t        , _param->_nb_gpr_write);
    158158  ALLOC1_SC_SIGNAL( in_GPR_WRITE_ACK                ," in_GPR_WRITE_ACK"                , Tcontrol_t        , _param->_nb_gpr_write);
    … …  
    182182  (*(_Write_queue->in_NRESET))       (*(in_NRESET));
    183183
    184   INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_VAL           );
    185   INSTANCE_SC_SIGNAL (_Write_queue, out_WRITE_QUEUE_IN_ACK           );
     184  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_VAL           );
     185  INSTANCE0_SC_SIGNAL(_Write_queue, out_WRITE_QUEUE_IN_ACK           );
    186186  if (_param->_have_port_context_id)
    187   INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_CONTEXT_ID    );
     187  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_CONTEXT_ID    );
    188188  if (_param->_have_port_front_end_id)
    189   INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_FRONT_END_ID  );
     189  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_FRONT_END_ID  );
    190190  if (_param->_have_port_ooo_engine_id)
    191   INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_OOO_ENGINE_ID );
     191  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_OOO_ENGINE_ID );
    192192  if (_param->_have_port_rob_ptr  )
    193   INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_PACKET_ID     );
    194 //INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_OPERATION     );
    195 //INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_TYPE          );
    196   INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_WRITE_RD      );
    197   INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_NUM_REG_RD    );
    198   INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_DATA_RD       );
    199   INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_WRITE_RE      );
    200   INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_NUM_REG_RE    );
    201   INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_DATA_RE       );
    202   INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_EXCEPTION     );
    203   INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_NO_SEQUENCE   );
    204   INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_ADDRESS       );
    205   INSTANCE_SC_SIGNAL (_Write_queue, out_WRITE_QUEUE_OUT_VAL          );
    206   INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_OUT_ACK          );
     193  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_PACKET_ID     );
     194//INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_OPERATION     );
     195//INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_TYPE          );
     196  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_WRITE_RD      );
     197  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_NUM_REG_RD    );
     198  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_DATA_RD       );
     199  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_WRITE_RE      );
     200  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_NUM_REG_RE    );
     201  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_DATA_RE       );
     202  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_EXCEPTION     );
     203  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_NO_SEQUENCE   );
     204  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_IN_ADDRESS       );
     205  INSTANCE0_SC_SIGNAL(_Write_queue, out_WRITE_QUEUE_OUT_VAL          );
     206  INSTANCE0_SC_SIGNAL(_Write_queue,  in_WRITE_QUEUE_OUT_ACK          );
    207207  if (_param->_have_port_context_id)
    208   INSTANCE_SC_SIGNAL (_Write_queue, out_WRITE_QUEUE_OUT_CONTEXT_ID   );
     208  INSTANCE0_SC_SIGNAL(_Write_queue, out_WRITE_QUEUE_OUT_CONTEXT_ID   );
    209209  if (_param->_have_port_front_end_id)
    210   INSTANCE_SC_SIGNAL (_Write_queue, out_WRITE_QUEUE_OUT_FRONT_END_ID );
     210  INSTANCE0_SC_SIGNAL(_Write_queue, out_WRITE_QUEUE_OUT_FRONT_END_ID );
    211211  if (_param->_have_port_ooo_engine_id)
    212   INSTANCE_SC_SIGNAL (_Write_queue, out_WRITE_QUEUE_OUT_OOO_ENGINE_ID);
     212  INSTANCE0_SC_SIGNAL(_Write_queue, out_WRITE_QUEUE_OUT_OOO_ENGINE_ID);
    213213  if (_param->_have_port_rob_ptr  )
    214   INSTANCE_SC_SIGNAL (_Write_queue, out_WRITE_QUEUE_OUT_PACKET_ID    );
    215 //INSTANCE_SC_SIGNAL (_Write_queue, out_WRITE_QUEUE_OUT_OPERATION    );
    216 //INSTANCE_SC_SIGNAL (_Write_queue, out_WRITE_QUEUE_OUT_TYPE         );
    217   INSTANCE_SC_SIGNAL (_Write_queue, out_WRITE_QUEUE_OUT_FLAGS        );
    218   INSTANCE_SC_SIGNAL (_Write_queue, out_WRITE_QUEUE_OUT_EXCEPTION    );
    219   INSTANCE_SC_SIGNAL (_Write_queue, out_WRITE_QUEUE_OUT_NO_SEQUENCE  );
    220   INSTANCE_SC_SIGNAL (_Write_queue, out_WRITE_QUEUE_OUT_ADDRESS      );
    221   INSTANCE_SC_SIGNAL (_Write_queue, out_WRITE_QUEUE_OUT_DATA         );
     214  INSTANCE0_SC_SIGNAL(_Write_queue, out_WRITE_QUEUE_OUT_PACKET_ID    );
     215//INSTANCE0_SC_SIGNAL(_Write_queue, out_WRITE_QUEUE_OUT_OPERATION    );
     216//INSTANCE0_SC_SIGNAL(_Write_queue, out_WRITE_QUEUE_OUT_TYPE         );
     217  INSTANCE0_SC_SIGNAL(_Write_queue, out_WRITE_QUEUE_OUT_FLAGS        );
     218  INSTANCE0_SC_SIGNAL(_Write_queue, out_WRITE_QUEUE_OUT_EXCEPTION    );
     219  INSTANCE0_SC_SIGNAL(_Write_queue, out_WRITE_QUEUE_OUT_NO_SEQUENCE  );
     220  INSTANCE0_SC_SIGNAL(_Write_queue, out_WRITE_QUEUE_OUT_ADDRESS      );
     221  INSTANCE0_SC_SIGNAL(_Write_queue, out_WRITE_QUEUE_OUT_DATA         );
    222222  INSTANCE1_SC_SIGNAL(_Write_queue, out_GPR_WRITE_VAL                , _param->_nb_gpr_write);
    223223  INSTANCE1_SC_SIGNAL(_Write_queue,  in_GPR_WRITE_ACK                , _param->_nb_gpr_write);

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

    r97 r112  
    5151    // -----[ Interface "Write_queue_in" ]--------------------------------   
    5252     {
    53        ALLOC_INTERFACE ("write_queue_in", IN, WEST, "Input of write_queue");
     53       ALLOC0_INTERFACE_BEGIN ("write_queue_in", IN, WEST, "Input of write_queue");
    5454       
    55        ALLOC_VALACK_IN ( in_WRITE_QUEUE_IN_VAL,VAL);
    56        ALLOC_VALACK_OUT(out_WRITE_QUEUE_IN_ACK,ACK);
    57        ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_CONTEXT_ID   ,"context_id"   ,Tcontext_t        ,_param->_size_context_id       );
    58        ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_FRONT_END_ID ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id     );
    59        ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id    );
    60        ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_PACKET_ID    ,"packet_id"    ,Tpacket_t         ,_param->_size_rob_ptr          );
    61 //     ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_OPERATION    ,"operation"    ,Toperation_t      ,_param->_size_operation        );
    62 //     ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_TYPE         ,"type"         ,Ttype_t           ,_param->_size_type             );
    63        ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_WRITE_RD     ,"write_rd"     ,Tcontrol_t        ,1                              );
    64        ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_NUM_REG_RD   ,"num_reg_rd"   ,Tgeneral_address_t,_param->_size_general_register );
    65        ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_DATA_RD      ,"data_rd"      ,Tgeneral_data_t   ,_param->_size_general_data     );
    66        ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_WRITE_RE     ,"write_re"     ,Tcontrol_t        ,1                              );
    67        ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_NUM_REG_RE   ,"num_reg_re"   ,Tspecial_address_t,_param->_size_special_register );
    68        ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_DATA_RE      ,"data_re"      ,Tspecial_data_t   ,_param->_size_special_data     );
    69        ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_EXCEPTION    ,"exception"    ,Texception_t      ,_param->_size_exception        );
    70        ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t        ,1                              );
    71        ALLOC_SIGNAL_IN ( in_WRITE_QUEUE_IN_ADDRESS      ,"address"      ,Taddress_t        ,_param->_size_instruction_address);
     55       ALLOC0_VALACK_IN ( in_WRITE_QUEUE_IN_VAL,VAL);
     56       ALLOC0_VALACK_OUT(out_WRITE_QUEUE_IN_ACK,ACK);
     57       ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_CONTEXT_ID   ,"context_id"   ,Tcontext_t        ,_param->_size_context_id       );
     58       ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_FRONT_END_ID ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id     );
     59       ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id    );
     60       ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_PACKET_ID    ,"packet_id"    ,Tpacket_t         ,_param->_size_rob_ptr          );
     61//     ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_OPERATION    ,"operation"    ,Toperation_t      ,_param->_size_operation        );
     62//     ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_TYPE         ,"type"         ,Ttype_t           ,_param->_size_type             );
     63       ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_WRITE_RD     ,"write_rd"     ,Tcontrol_t        ,1                              );
     64       ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_NUM_REG_RD   ,"num_reg_rd"   ,Tgeneral_address_t,_param->_size_general_register );
     65       ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_DATA_RD      ,"data_rd"      ,Tgeneral_data_t   ,_param->_size_general_data     );
     66       ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_WRITE_RE     ,"write_re"     ,Tcontrol_t        ,1                              );
     67       ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_NUM_REG_RE   ,"num_reg_re"   ,Tspecial_address_t,_param->_size_special_register );
     68       ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_DATA_RE      ,"data_re"      ,Tspecial_data_t   ,_param->_size_special_data     );
     69       ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_EXCEPTION    ,"exception"    ,Texception_t      ,_param->_size_exception        );
     70       ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t        ,1                              );
     71       ALLOC0_SIGNAL_IN ( in_WRITE_QUEUE_IN_ADDRESS      ,"address"      ,Taddress_t        ,_param->_size_instruction_address);
     72
     73       ALLOC0_INTERFACE_END();
    7274     }
    7375
    7476    // -----[ Interface "Write_queue_out" ]-------------------------------
    7577     {
    76        ALLOC_INTERFACE ("write_queue_out", OUT, EAST, "Output of write_queue");
     78       ALLOC0_INTERFACE_BEGIN("write_queue_out", OUT, EAST, "Output of write_queue");
    7779       
    78        ALLOC_VALACK_OUT(out_WRITE_QUEUE_OUT_VAL,VAL);
    79        ALLOC_VALACK_IN ( in_WRITE_QUEUE_OUT_ACK,ACK);
    80        ALLOC_SIGNAL_OUT(out_WRITE_QUEUE_OUT_CONTEXT_ID   ,"context_id"   ,Tcontext_t     ,_param->_size_context_id   );
    81        ALLOC_SIGNAL_OUT(out_WRITE_QUEUE_OUT_FRONT_END_ID ,"front_end_id" ,Tcontext_t     ,_param->_size_front_end_id );
    82        ALLOC_SIGNAL_OUT(out_WRITE_QUEUE_OUT_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t     ,_param->_size_ooo_engine_id);
    83        ALLOC_SIGNAL_OUT(out_WRITE_QUEUE_OUT_PACKET_ID    ,"packet_id"    ,Tpacket_t      ,_param->_size_rob_ptr      );
    84 //     ALLOC_SIGNAL_OUT(out_WRITE_QUEUE_OUT_OPERATION    ,"operation"    ,Toperation_t   ,_param->_size_operation    );
    85 //     ALLOC_SIGNAL_OUT(out_WRITE_QUEUE_OUT_TYPE         ,"type"         ,Ttype_t        ,_param->_size_type         );
    86        ALLOC_SIGNAL_OUT(out_WRITE_QUEUE_OUT_FLAGS        ,"flags"        ,Tspecial_data_t,_param->_size_special_data );
    87        ALLOC_SIGNAL_OUT(out_WRITE_QUEUE_OUT_EXCEPTION    ,"exception"    ,Texception_t   ,_param->_size_exception    );
    88        ALLOC_SIGNAL_OUT(out_WRITE_QUEUE_OUT_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t     ,1                          );
    89        ALLOC_SIGNAL_OUT(out_WRITE_QUEUE_OUT_ADDRESS      ,"address"      ,Taddress_t     ,_param->_size_instruction_address);
    90        ALLOC_SIGNAL_OUT(out_WRITE_QUEUE_OUT_DATA         ,"data"         ,Tgeneral_data_t,_param->_size_general_data );
     80       ALLOC0_VALACK_OUT(out_WRITE_QUEUE_OUT_VAL,VAL);
     81       ALLOC0_VALACK_IN ( in_WRITE_QUEUE_OUT_ACK,ACK);
     82       ALLOC0_SIGNAL_OUT(out_WRITE_QUEUE_OUT_CONTEXT_ID   ,"context_id"   ,Tcontext_t     ,_param->_size_context_id   );
     83       ALLOC0_SIGNAL_OUT(out_WRITE_QUEUE_OUT_FRONT_END_ID ,"front_end_id" ,Tcontext_t     ,_param->_size_front_end_id );
     84       ALLOC0_SIGNAL_OUT(out_WRITE_QUEUE_OUT_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t     ,_param->_size_ooo_engine_id);
     85       ALLOC0_SIGNAL_OUT(out_WRITE_QUEUE_OUT_PACKET_ID    ,"packet_id"    ,Tpacket_t      ,_param->_size_rob_ptr      );
     86//     ALLOC0_SIGNAL_OUT(out_WRITE_QUEUE_OUT_OPERATION    ,"operation"    ,Toperation_t   ,_param->_size_operation    );
     87//     ALLOC0_SIGNAL_OUT(out_WRITE_QUEUE_OUT_TYPE         ,"type"         ,Ttype_t        ,_param->_size_type         );
     88       ALLOC0_SIGNAL_OUT(out_WRITE_QUEUE_OUT_FLAGS        ,"flags"        ,Tspecial_data_t,_param->_size_special_data );
     89       ALLOC0_SIGNAL_OUT(out_WRITE_QUEUE_OUT_EXCEPTION    ,"exception"    ,Texception_t   ,_param->_size_exception    );
     90       ALLOC0_SIGNAL_OUT(out_WRITE_QUEUE_OUT_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t     ,1                          );
     91       ALLOC0_SIGNAL_OUT(out_WRITE_QUEUE_OUT_ADDRESS      ,"address"      ,Taddress_t     ,_param->_size_instruction_address);
     92       ALLOC0_SIGNAL_OUT(out_WRITE_QUEUE_OUT_DATA         ,"data"         ,Tgeneral_data_t,_param->_size_general_data );
     93
     94       ALLOC0_INTERFACE_END();
    9195     }
    9296
    9397    // -----[ Interface "gpr_write" ]-------------------------------------
    9498     {
    95        ALLOC1_INTERFACE("gpr_write", OUT, SOUTH ,"Output of write_queue", _param->_nb_gpr_write);
     99       ALLOC1_INTERFACE_BEGIN("gpr_write", OUT, SOUTH ,"Output of write_queue", _param->_nb_gpr_write);
    96100
    97101       ALLOC1_VALACK_OUT(out_GPR_WRITE_VAL,VAL);
    … …  
    100104       ALLOC1_SIGNAL_OUT(out_GPR_WRITE_NUM_REG      ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
    101105       ALLOC1_SIGNAL_OUT(out_GPR_WRITE_DATA         ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data    );
     106
     107       ALLOC1_INTERFACE_END(_param->_nb_gpr_write);
    102108     }
    103109
    104110    // -----[ Interface "spr_write" ]-------------------------------------
    105111     {
    106        ALLOC1_INTERFACE("spr_write", OUT, SOUTH ,"Output of write_queue", _param->_nb_spr_write);
     112       ALLOC1_INTERFACE_BEGIN("spr_write", OUT, SOUTH ,"Output of write_queue", _param->_nb_spr_write);
    107113
    108114       ALLOC1_VALACK_OUT(out_SPR_WRITE_VAL,VAL);
    … …  
    111117       ALLOC1_SIGNAL_OUT(out_SPR_WRITE_NUM_REG      ,"num_reg"      ,Tspecial_address_t,_param->_size_special_register);
    112118       ALLOC1_SIGNAL_OUT(out_SPR_WRITE_DATA         ,"data"         ,Tspecial_data_t   ,_param->_size_special_data    );
     119
     120       ALLOC1_INTERFACE_END(_param->_nb_spr_write);
    113121     }
    114122
    115123    // -----[ Interface "bypass_write" ]----------------------------------
    116124     {
    117        ALLOC1_INTERFACE("bypass_write", OUT, NORTH ,"Output of internal write_queue", _param->_nb_bypass_write);
     125       ALLOC1_INTERFACE_BEGIN("bypass_write", OUT, NORTH ,"Output of internal write_queue", _param->_nb_bypass_write);
    118126       
    119127       ALLOC1_SIGNAL_OUT(out_BYPASS_WRITE_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id   );
    … …  
    124132       ALLOC1_SIGNAL_OUT(out_BYPASS_WRITE_SPR_NUM_REG  ,"spr_num_reg"  ,Tspecial_address_t,_param->_size_special_register);
    125133       ALLOC1_SIGNAL_OUT(out_BYPASS_WRITE_SPR_DATA     ,"spr_data"     ,Tspecial_data_t   ,_param->_size_special_data    );
     134
     135       ALLOC1_INTERFACE_END(_param->_nb_bypass_write);
    126136     }
     137
    127138    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    128139

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

    r97 r112  
    77
    88#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/include/Write_queue.h"
     9#include "Behavioural/include/Allocation.h"
    910
    1011namespace morpheo                    {
    … …  
    2930        delete    in_NRESET;
    3031       
    31         // -----[ Interface "Write_queue_in" ]--------------------------------   
    32         delete      in_WRITE_QUEUE_IN_VAL          ;
    33         delete     out_WRITE_QUEUE_IN_ACK          ;
    34         if (_param->_have_port_context_id)
    35         delete      in_WRITE_QUEUE_IN_CONTEXT_ID   ;
    36         if (_param->_have_port_front_end_id)
    37         delete      in_WRITE_QUEUE_IN_FRONT_END_ID ;
    38         if (_param->_have_port_ooo_engine_id)
    39         delete      in_WRITE_QUEUE_IN_OOO_ENGINE_ID;
    40         if (_param->_have_port_rob_ptr  )
    41         delete      in_WRITE_QUEUE_IN_PACKET_ID    ;
    42 //      delete      in_WRITE_QUEUE_IN_OPERATION    ;
    43 //      delete      in_WRITE_QUEUE_IN_TYPE         ;
    44         delete      in_WRITE_QUEUE_IN_WRITE_RD     ;
    45         delete      in_WRITE_QUEUE_IN_NUM_REG_RD   ;
    46         delete      in_WRITE_QUEUE_IN_DATA_RD      ;
    47         delete      in_WRITE_QUEUE_IN_WRITE_RE     ;
    48         delete      in_WRITE_QUEUE_IN_NUM_REG_RE   ;
    49         delete      in_WRITE_QUEUE_IN_DATA_RE      ;
    50         delete      in_WRITE_QUEUE_IN_EXCEPTION    ;
    51         delete      in_WRITE_QUEUE_IN_NO_SEQUENCE  ;
    52         delete      in_WRITE_QUEUE_IN_ADDRESS      ;
    53 
    54         // -----[ Interface "Write_queue_out" ]-------------------------------   
    55         delete     out_WRITE_QUEUE_OUT_VAL          ;
    56         delete      in_WRITE_QUEUE_OUT_ACK          ;
    57         if (_param->_have_port_context_id)
    58         delete     out_WRITE_QUEUE_OUT_CONTEXT_ID   ;
    59         if (_param->_have_port_front_end_id)
    60         delete     out_WRITE_QUEUE_OUT_FRONT_END_ID ;
    61         if (_param->_have_port_ooo_engine_id)
    62         delete     out_WRITE_QUEUE_OUT_OOO_ENGINE_ID;
    63         if (_param->_have_port_rob_ptr  )
    64         delete     out_WRITE_QUEUE_OUT_PACKET_ID    ;
    65 //      delete     out_WRITE_QUEUE_OUT_OPERATION    ;
    66 //      delete     out_WRITE_QUEUE_OUT_TYPE         ;
    67         delete     out_WRITE_QUEUE_OUT_FLAGS        ;
    68         delete     out_WRITE_QUEUE_OUT_EXCEPTION    ;
    69         delete     out_WRITE_QUEUE_OUT_NO_SEQUENCE  ;
    70         delete     out_WRITE_QUEUE_OUT_ADDRESS      ;
    71         delete     out_WRITE_QUEUE_OUT_DATA         ;
    72 
    73         // -----[ Interface "gpr_write" ]-------------------------------------
    74         delete []  out_GPR_WRITE_VAL               ;
    75         delete []   in_GPR_WRITE_ACK               ;
    76         if (_param->_have_port_ooo_engine_id)
    77         delete []  out_GPR_WRITE_OOO_ENGINE_ID     ;
    78         delete []  out_GPR_WRITE_NUM_REG           ;
    79         delete []  out_GPR_WRITE_DATA              ;
    80        
    81         // -----[ Interface "spr_write" ]-------------------------------------
    82         delete []  out_SPR_WRITE_VAL               ;
    83         delete []   in_SPR_WRITE_ACK               ;
    84         if (_param->_have_port_ooo_engine_id)
    85         delete []  out_SPR_WRITE_OOO_ENGINE_ID     ;
    86         delete []  out_SPR_WRITE_NUM_REG           ;
    87         delete []  out_SPR_WRITE_DATA              ;
    88 
    89         // -----[ Interface "bypass_write" ]----------------------------------
    90         if (_param->_have_port_ooo_engine_id)
    91         delete []  out_BYPASS_WRITE_OOO_ENGINE_ID ;
    92         delete []  out_BYPASS_WRITE_GPR_VAL       ;
    93         delete []  out_BYPASS_WRITE_GPR_NUM_REG   ;
    94         delete []  out_BYPASS_WRITE_GPR_DATA      ;
    95         delete []  out_BYPASS_WRITE_SPR_VAL       ;
    96         delete []  out_BYPASS_WRITE_SPR_NUM_REG   ;
    97         delete []  out_BYPASS_WRITE_SPR_DATA      ;
     32        DELETE0_SIGNAL( in_WRITE_QUEUE_IN_VAL           ,1);
     33        DELETE0_SIGNAL(out_WRITE_QUEUE_IN_ACK           ,1);
     34        DELETE0_SIGNAL( in_WRITE_QUEUE_IN_CONTEXT_ID    ,_param->_size_context_id       );
     35        DELETE0_SIGNAL( in_WRITE_QUEUE_IN_FRONT_END_ID  ,_param->_size_front_end_id     );
     36        DELETE0_SIGNAL( in_WRITE_QUEUE_IN_OOO_ENGINE_ID ,_param->_size_ooo_engine_id    );
     37        DELETE0_SIGNAL( in_WRITE_QUEUE_IN_PACKET_ID     ,_param->_size_rob_ptr          );
     38//      DELETE0_SIGNAL( in_WRITE_QUEUE_IN_OPERATION     ,_param->_size_operation        );
     39//      DELETE0_SIGNAL( in_WRITE_QUEUE_IN_TYPE          ,_param->_size_type             );
     40        DELETE0_SIGNAL( in_WRITE_QUEUE_IN_WRITE_RD      ,1                              );
     41        DELETE0_SIGNAL( in_WRITE_QUEUE_IN_NUM_REG_RD    ,_param->_size_general_register );
     42        DELETE0_SIGNAL( in_WRITE_QUEUE_IN_DATA_RD       ,_param->_size_general_data     );
     43        DELETE0_SIGNAL( in_WRITE_QUEUE_IN_WRITE_RE      ,1                              );
     44        DELETE0_SIGNAL( in_WRITE_QUEUE_IN_NUM_REG_RE    ,_param->_size_special_register );
     45        DELETE0_SIGNAL( in_WRITE_QUEUE_IN_DATA_RE       ,_param->_size_special_data     );
     46        DELETE0_SIGNAL( in_WRITE_QUEUE_IN_EXCEPTION     ,_param->_size_exception        );
     47        DELETE0_SIGNAL( in_WRITE_QUEUE_IN_NO_SEQUENCE   ,1                              );
     48        DELETE0_SIGNAL( in_WRITE_QUEUE_IN_ADDRESS       ,_param->_size_instruction_address);
     49       
     50        DELETE0_SIGNAL(out_WRITE_QUEUE_OUT_VAL          ,1);
     51        DELETE0_SIGNAL( in_WRITE_QUEUE_OUT_ACK          ,1);
     52        DELETE0_SIGNAL(out_WRITE_QUEUE_OUT_CONTEXT_ID   ,_param->_size_context_id   );
     53        DELETE0_SIGNAL(out_WRITE_QUEUE_OUT_FRONT_END_ID ,_param->_size_front_end_id );
     54        DELETE0_SIGNAL(out_WRITE_QUEUE_OUT_OOO_ENGINE_ID,_param->_size_ooo_engine_id);
     55        DELETE0_SIGNAL(out_WRITE_QUEUE_OUT_PACKET_ID    ,_param->_size_rob_ptr      );
     56//      DELETE0_SIGNAL(out_WRITE_QUEUE_OUT_OPERATION    ,_param->_size_operation    );
     57//      DELETE0_SIGNAL(out_WRITE_QUEUE_OUT_TYPE         ,_param->_size_type         );
     58        DELETE0_SIGNAL(out_WRITE_QUEUE_OUT_FLAGS        ,_param->_size_special_data );
     59        DELETE0_SIGNAL(out_WRITE_QUEUE_OUT_EXCEPTION    ,_param->_size_exception    );
     60        DELETE0_SIGNAL(out_WRITE_QUEUE_OUT_NO_SEQUENCE  ,1                          );
     61        DELETE0_SIGNAL(out_WRITE_QUEUE_OUT_ADDRESS      ,_param->_size_instruction_address);
     62        DELETE0_SIGNAL(out_WRITE_QUEUE_OUT_DATA         ,_param->_size_general_data );
     63       
     64        DELETE1_SIGNAL(out_GPR_WRITE_VAL          , _param->_nb_gpr_write,1);
     65        DELETE1_SIGNAL( in_GPR_WRITE_ACK          , _param->_nb_gpr_write,1);
     66        DELETE1_SIGNAL(out_GPR_WRITE_OOO_ENGINE_ID, _param->_nb_gpr_write,_param->_size_ooo_engine_id   );
     67        DELETE1_SIGNAL(out_GPR_WRITE_NUM_REG      , _param->_nb_gpr_write,_param->_size_general_register);
     68        DELETE1_SIGNAL(out_GPR_WRITE_DATA         , _param->_nb_gpr_write,_param->_size_general_data    );
     69       
     70        DELETE1_SIGNAL(out_SPR_WRITE_VAL          , _param->_nb_spr_write,1);
     71        DELETE1_SIGNAL( in_SPR_WRITE_ACK          , _param->_nb_spr_write,1);
     72        DELETE1_SIGNAL(out_SPR_WRITE_OOO_ENGINE_ID, _param->_nb_spr_write,_param->_size_ooo_engine_id   );
     73        DELETE1_SIGNAL(out_SPR_WRITE_NUM_REG      , _param->_nb_spr_write,_param->_size_special_register);
     74        DELETE1_SIGNAL(out_SPR_WRITE_DATA         , _param->_nb_spr_write,_param->_size_special_data    );
     75       
     76        DELETE1_SIGNAL(out_BYPASS_WRITE_OOO_ENGINE_ID,_param->_nb_bypass_write,_param->_size_ooo_engine_id   );
     77        DELETE1_SIGNAL(out_BYPASS_WRITE_GPR_VAL      ,_param->_nb_bypass_write,1                             );
     78        DELETE1_SIGNAL(out_BYPASS_WRITE_GPR_NUM_REG  ,_param->_nb_bypass_write,_param->_size_general_register);
     79        DELETE1_SIGNAL(out_BYPASS_WRITE_GPR_DATA     ,_param->_nb_bypass_write,_param->_size_general_data    );
     80        DELETE1_SIGNAL(out_BYPASS_WRITE_SPR_VAL      ,_param->_nb_bypass_write,1                             );
     81        DELETE1_SIGNAL(out_BYPASS_WRITE_SPR_NUM_REG  ,_param->_nb_bypass_write,_param->_size_special_register);
     82        DELETE1_SIGNAL(out_BYPASS_WRITE_SPR_DATA     ,_param->_nb_bypass_write,_param->_size_special_data    );
    9883      }
    9984

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

    r97 r112  
    5757    // -----[ Interface "write_unit_in" ]--------------------------------   
    5858     {
    59        ALLOC_INTERFACE ("write_unit_in", IN, WEST, "Input of write_unit");
    60        
    61        ALLOC_VALACK_IN ( in_WRITE_UNIT_IN_VAL,VAL);
    62        ALLOC_VALACK_OUT(out_WRITE_UNIT_IN_ACK,ACK);
    63        ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_CONTEXT_ID   ,"context_id"   ,Tcontext_t        ,_param->_size_context_id       );
    64        ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_FRONT_END_ID ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id     );
    65        ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id    );
    66        ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_PACKET_ID    ,"packet_id"    ,Tpacket_t         ,_param->_size_rob_ptr          );
    67 //     ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_OPERATION    ,"operation"    ,Toperation_t      ,_param->_size_operation        );
    68 //     ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_TYPE         ,"type"         ,Ttype_t           ,_param->_size_type             );
    69        ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_WRITE_RD     ,"write_rd"     ,Tcontrol_t        ,1                              );
    70        ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_NUM_REG_RD   ,"num_reg_rd"   ,Tgeneral_address_t,_param->_size_general_register );
    71        ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_DATA_RD      ,"data_rd"      ,Tgeneral_data_t   ,_param->_size_general_data     );
    72        ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_WRITE_RE     ,"write_re"     ,Tcontrol_t        ,1                              );
    73        ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_NUM_REG_RE   ,"num_reg_re"   ,Tspecial_address_t,_param->_size_special_register );
    74        ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_DATA_RE      ,"data_re"      ,Tspecial_data_t   ,_param->_size_special_data     );
    75        ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_EXCEPTION    ,"exception"    ,Texception_t      ,_param->_size_exception        );
    76        ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t        ,1                              );
    77        ALLOC_SIGNAL_IN ( in_WRITE_UNIT_IN_ADDRESS      ,"address"      ,Taddress_t        ,_param->_size_instruction_address);
     59       ALLOC0_INTERFACE_BEGIN("write_unit_in", IN, WEST, "Input of write_unit");
     60       
     61       ALLOC0_VALACK_IN ( in_WRITE_UNIT_IN_VAL,VAL);
     62       ALLOC0_VALACK_OUT(out_WRITE_UNIT_IN_ACK,ACK);
     63       ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_CONTEXT_ID   ,"context_id"   ,Tcontext_t        ,_param->_size_context_id       );
     64       ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_FRONT_END_ID ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id     );
     65       ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id    );
     66       ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_PACKET_ID    ,"packet_id"    ,Tpacket_t         ,_param->_size_rob_ptr          );
     67//     ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_OPERATION    ,"operation"    ,Toperation_t      ,_param->_size_operation        );
     68//     ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_TYPE         ,"type"         ,Ttype_t           ,_param->_size_type             );
     69       ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_WRITE_RD     ,"write_rd"     ,Tcontrol_t        ,1                              );
     70       ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_NUM_REG_RD   ,"num_reg_rd"   ,Tgeneral_address_t,_param->_size_general_register );
     71       ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_DATA_RD      ,"data_rd"      ,Tgeneral_data_t   ,_param->_size_general_data     );
     72       ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_WRITE_RE     ,"write_re"     ,Tcontrol_t        ,1                              );
     73       ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_NUM_REG_RE   ,"num_reg_re"   ,Tspecial_address_t,_param->_size_special_register );
     74       ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_DATA_RE      ,"data_re"      ,Tspecial_data_t   ,_param->_size_special_data     );
     75       ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_EXCEPTION    ,"exception"    ,Texception_t      ,_param->_size_exception        );
     76       ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t        ,1                              );
     77       ALLOC0_SIGNAL_IN ( in_WRITE_UNIT_IN_ADDRESS      ,"address"      ,Taddress_t        ,_param->_size_instruction_address);
     78
     79       ALLOC0_INTERFACE_END();
    7880     }
    7981
    8082    // -----[ Interface "write_unit_out" ]-------------------------------
    8183     {
    82        ALLOC_INTERFACE ("write_unit_out", OUT, EAST, "Output of write_unit");
    83        
    84        ALLOC_VALACK_OUT(out_WRITE_UNIT_OUT_VAL,VAL);
    85        ALLOC_VALACK_IN ( in_WRITE_UNIT_OUT_ACK,ACK);
    86        ALLOC_SIGNAL_OUT(out_WRITE_UNIT_OUT_CONTEXT_ID   ,"context_id"   ,Tcontext_t     ,_param->_size_context_id   );
    87        ALLOC_SIGNAL_OUT(out_WRITE_UNIT_OUT_FRONT_END_ID ,"front_end_id" ,Tcontext_t     ,_param->_size_front_end_id );
    88        ALLOC_SIGNAL_OUT(out_WRITE_UNIT_OUT_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t     ,_param->_size_ooo_engine_id);
    89        ALLOC_SIGNAL_OUT(out_WRITE_UNIT_OUT_PACKET_ID    ,"packet_id"    ,Tpacket_t      ,_param->_size_rob_ptr      );
    90 //     ALLOC_SIGNAL_OUT(out_WRITE_UNIT_OUT_OPERATION    ,"operation"    ,Toperation_t   ,_param->_size_operation    );
    91 //     ALLOC_SIGNAL_OUT(out_WRITE_UNIT_OUT_TYPE         ,"type"         ,Ttype_t        ,_param->_size_type         );
    92        ALLOC_SIGNAL_OUT(out_WRITE_UNIT_OUT_FLAGS        ,"flags"        ,Tspecial_data_t,_param->_size_special_data );
    93        ALLOC_SIGNAL_OUT(out_WRITE_UNIT_OUT_EXCEPTION    ,"exception"    ,Texception_t   ,_param->_size_exception    );
    94        ALLOC_SIGNAL_OUT(out_WRITE_UNIT_OUT_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t     ,1                          );
    95        ALLOC_SIGNAL_OUT(out_WRITE_UNIT_OUT_ADDRESS      ,"address"      ,Taddress_t     ,_param->_size_instruction_address);
    96        ALLOC_SIGNAL_OUT(out_WRITE_UNIT_OUT_DATA         ,"data"         ,Tgeneral_data_t,_param->_size_general_data );
     84       ALLOC0_INTERFACE_BEGIN("write_unit_out", OUT, EAST, "Output of write_unit");
     85       
     86       ALLOC0_VALACK_OUT(out_WRITE_UNIT_OUT_VAL,VAL);
     87       ALLOC0_VALACK_IN ( in_WRITE_UNIT_OUT_ACK,ACK);
     88       ALLOC0_SIGNAL_OUT(out_WRITE_UNIT_OUT_CONTEXT_ID   ,"context_id"   ,Tcontext_t     ,_param->_size_context_id   );
     89       ALLOC0_SIGNAL_OUT(out_WRITE_UNIT_OUT_FRONT_END_ID ,"front_end_id" ,Tcontext_t     ,_param->_size_front_end_id );
     90       ALLOC0_SIGNAL_OUT(out_WRITE_UNIT_OUT_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t     ,_param->_size_ooo_engine_id);
     91       ALLOC0_SIGNAL_OUT(out_WRITE_UNIT_OUT_PACKET_ID    ,"packet_id"    ,Tpacket_t      ,_param->_size_rob_ptr      );
     92//     ALLOC0_SIGNAL_OUT(out_WRITE_UNIT_OUT_OPERATION    ,"operation"    ,Toperation_t   ,_param->_size_operation    );
     93//     ALLOC0_SIGNAL_OUT(out_WRITE_UNIT_OUT_TYPE         ,"type"         ,Ttype_t        ,_param->_size_type         );
     94       ALLOC0_SIGNAL_OUT(out_WRITE_UNIT_OUT_FLAGS        ,"flags"        ,Tspecial_data_t,_param->_size_special_data );
     95       ALLOC0_SIGNAL_OUT(out_WRITE_UNIT_OUT_EXCEPTION    ,"exception"    ,Texception_t   ,_param->_size_exception    );
     96       ALLOC0_SIGNAL_OUT(out_WRITE_UNIT_OUT_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t     ,1                          );
     97       ALLOC0_SIGNAL_OUT(out_WRITE_UNIT_OUT_ADDRESS      ,"address"      ,Taddress_t     ,_param->_size_instruction_address);
     98       ALLOC0_SIGNAL_OUT(out_WRITE_UNIT_OUT_DATA         ,"data"         ,Tgeneral_data_t,_param->_size_general_data );
     99
     100       ALLOC0_INTERFACE_END();
    97101     }
    98102
    99103    // -----[ Interface "gpr_write" ]-------------------------------------
    100104     {
    101        ALLOC1_INTERFACE("gpr_write", OUT, SOUTH ,"Output of write_unit", _param->_nb_gpr_write);
     105       ALLOC1_INTERFACE_BEGIN("gpr_write", OUT, SOUTH ,"Output of write_unit", _param->_nb_gpr_write);
    102106
    103107       ALLOC1_VALACK_OUT(out_GPR_WRITE_VAL,VAL);
    … …  
    106110       ALLOC1_SIGNAL_OUT(out_GPR_WRITE_NUM_REG      ,"num_reg"      ,Tgeneral_address_t,_param->_size_general_register);
    107111       ALLOC1_SIGNAL_OUT(out_GPR_WRITE_DATA         ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data    );
     112
     113       ALLOC1_INTERFACE_END(_param->_nb_gpr_write);
    108114     }
    109115
    110116    // -----[ Interface "spr_write" ]-------------------------------------
    111117     {
    112        ALLOC1_INTERFACE("spr_write", OUT, SOUTH ,"Output of write_unit", _param->_nb_spr_write);
     118       ALLOC1_INTERFACE_BEGIN("spr_write", OUT, SOUTH ,"Output of write_unit", _param->_nb_spr_write);
    113119
    114120       ALLOC1_VALACK_OUT(out_SPR_WRITE_VAL,VAL);
    … …  
    117123       ALLOC1_SIGNAL_OUT(out_SPR_WRITE_NUM_REG      ,"num_reg"      ,Tspecial_address_t,_param->_size_special_register);
    118124       ALLOC1_SIGNAL_OUT(out_SPR_WRITE_DATA         ,"data"         ,Tspecial_data_t   ,_param->_size_special_data    );
     125
     126       ALLOC1_INTERFACE_END(_param->_nb_spr_write);
    119127     }
    120128
    121129    // -----[ Interface "bypass_write" ]----------------------------------
    122130     {
    123        ALLOC1_INTERFACE("bypass_write", OUT, NORTH ,"Output of internal write_unit", _param->_nb_bypass_write);
     131       ALLOC1_INTERFACE_BEGIN("bypass_write", OUT, NORTH ,"Output of internal write_unit", _param->_nb_bypass_write);
    124132       
    125133       ALLOC1_SIGNAL_OUT(out_BYPASS_WRITE_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id   );
    … …  
    130138       ALLOC1_SIGNAL_OUT(out_BYPASS_WRITE_SPR_NUM_REG  ,"spr_num_reg"  ,Tspecial_address_t,_param->_size_special_register);
    131139       ALLOC1_SIGNAL_OUT(out_BYPASS_WRITE_SPR_DATA     ,"spr_data"     ,Tspecial_data_t   ,_param->_size_special_data    );
    132      }
    133 
     140
     141       ALLOC1_INTERFACE_END(_param->_nb_bypass_write);
     142     }
    134143
    135144    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   

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

    r97 r112  
    77
    88#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/include/Write_unit.h"
     9#include "Behavioural/include/Allocation.h"
    910
    1011namespace morpheo                    {
    … …  
    2829        delete    in_NRESET;
    2930
    30         // -----[ Interface "write_unit_in" ]--------------------------------   
    31         delete      in_WRITE_UNIT_IN_VAL          ;
    32         delete     out_WRITE_UNIT_IN_ACK          ;
    33         if (_param->_have_port_context_id)
    34         delete      in_WRITE_UNIT_IN_CONTEXT_ID   ;
    35         if (_param->_have_port_front_end_id)
    36         delete      in_WRITE_UNIT_IN_FRONT_END_ID ;
    37         if (_param->_have_port_ooo_engine_id)
    38         delete      in_WRITE_UNIT_IN_OOO_ENGINE_ID;
    39         if (_param->_have_port_rob_ptr)
    40         delete      in_WRITE_UNIT_IN_PACKET_ID    ;
    41 //      delete      in_WRITE_UNIT_IN_OPERATION    ;
    42 //      delete      in_WRITE_UNIT_IN_TYPE         ;
    43         delete      in_WRITE_UNIT_IN_WRITE_RD     ;
    44         delete      in_WRITE_UNIT_IN_NUM_REG_RD   ;
    45         delete      in_WRITE_UNIT_IN_DATA_RD      ;
    46         delete      in_WRITE_UNIT_IN_WRITE_RE     ;
    47         delete      in_WRITE_UNIT_IN_NUM_REG_RE   ;
    48         delete      in_WRITE_UNIT_IN_DATA_RE      ;
    49         delete      in_WRITE_UNIT_IN_EXCEPTION    ;
    50         delete      in_WRITE_UNIT_IN_NO_SEQUENCE  ;
    51         delete      in_WRITE_UNIT_IN_ADDRESS      ;
     31        DELETE0_SIGNAL( in_WRITE_UNIT_IN_VAL          ,1);
     32        DELETE0_SIGNAL(out_WRITE_UNIT_IN_ACK          ,1);
     33        DELETE0_SIGNAL( in_WRITE_UNIT_IN_CONTEXT_ID   ,_param->_size_context_id       );
     34        DELETE0_SIGNAL( in_WRITE_UNIT_IN_FRONT_END_ID ,_param->_size_front_end_id     );
     35        DELETE0_SIGNAL( in_WRITE_UNIT_IN_OOO_ENGINE_ID,_param->_size_ooo_engine_id    );
     36        DELETE0_SIGNAL( in_WRITE_UNIT_IN_PACKET_ID    ,_param->_size_rob_ptr          );
     37//      DELETE0_SIGNAL( in_WRITE_UNIT_IN_OPERATION    ,_param->_size_operation        );
     38//      DELETE0_SIGNAL( in_WRITE_UNIT_IN_TYPE         ,_param->_size_type             );
     39        DELETE0_SIGNAL( in_WRITE_UNIT_IN_WRITE_RD     ,1                              );
     40        DELETE0_SIGNAL( in_WRITE_UNIT_IN_NUM_REG_RD   ,_param->_size_general_register );
     41        DELETE0_SIGNAL( in_WRITE_UNIT_IN_DATA_RD      ,_param->_size_general_data     );
     42        DELETE0_SIGNAL( in_WRITE_UNIT_IN_WRITE_RE     ,1                              );
     43        DELETE0_SIGNAL( in_WRITE_UNIT_IN_NUM_REG_RE   ,_param->_size_special_register );
     44        DELETE0_SIGNAL( in_WRITE_UNIT_IN_DATA_RE      ,_param->_size_special_data     );
     45        DELETE0_SIGNAL( in_WRITE_UNIT_IN_EXCEPTION    ,_param->_size_exception        );
     46        DELETE0_SIGNAL( in_WRITE_UNIT_IN_NO_SEQUENCE  ,1                              );
     47        DELETE0_SIGNAL( in_WRITE_UNIT_IN_ADDRESS      ,_param->_size_instruction_address);
     48       
     49        DELETE0_SIGNAL(out_WRITE_UNIT_OUT_VAL          ,1);
     50        DELETE0_SIGNAL( in_WRITE_UNIT_OUT_ACK          ,1);
     51        DELETE0_SIGNAL(out_WRITE_UNIT_OUT_CONTEXT_ID   ,_param->_size_context_id   );
     52        DELETE0_SIGNAL(out_WRITE_UNIT_OUT_FRONT_END_ID ,_param->_size_front_end_id );
     53        DELETE0_SIGNAL(out_WRITE_UNIT_OUT_OOO_ENGINE_ID,_param->_size_ooo_engine_id);
     54        DELETE0_SIGNAL(out_WRITE_UNIT_OUT_PACKET_ID    ,_param->_size_rob_ptr      );
     55//      DELETE0_SIGNAL(out_WRITE_UNIT_OUT_OPERATION    ,_param->_size_operation    );
     56//      DELETE0_SIGNAL(out_WRITE_UNIT_OUT_TYPE         ,_param->_size_type         );
     57        DELETE0_SIGNAL(out_WRITE_UNIT_OUT_FLAGS        ,_param->_size_special_data );
     58        DELETE0_SIGNAL(out_WRITE_UNIT_OUT_EXCEPTION    ,_param->_size_exception    );
     59        DELETE0_SIGNAL(out_WRITE_UNIT_OUT_NO_SEQUENCE  ,1                          );
     60        DELETE0_SIGNAL(out_WRITE_UNIT_OUT_ADDRESS      ,_param->_size_instruction_address);
     61        DELETE0_SIGNAL(out_WRITE_UNIT_OUT_DATA         ,_param->_size_general_data );
     62       
     63        DELETE1_SIGNAL(out_GPR_WRITE_VAL          , _param->_nb_gpr_write,1);
     64        DELETE1_SIGNAL( in_GPR_WRITE_ACK          , _param->_nb_gpr_write,1);
     65        DELETE1_SIGNAL(out_GPR_WRITE_OOO_ENGINE_ID, _param->_nb_gpr_write,_param->_size_ooo_engine_id   );
     66        DELETE1_SIGNAL(out_GPR_WRITE_NUM_REG      , _param->_nb_gpr_write,_param->_size_general_register);
     67        DELETE1_SIGNAL(out_GPR_WRITE_DATA         , _param->_nb_gpr_write,_param->_size_general_data    );
     68       
     69        DELETE1_SIGNAL(out_SPR_WRITE_VAL          , _param->_nb_spr_write,1);
     70        DELETE1_SIGNAL( in_SPR_WRITE_ACK          , _param->_nb_spr_write,1);
     71        DELETE1_SIGNAL(out_SPR_WRITE_OOO_ENGINE_ID, _param->_nb_spr_write,_param->_size_ooo_engine_id   );
     72        DELETE1_SIGNAL(out_SPR_WRITE_NUM_REG      , _param->_nb_spr_write,_param->_size_special_register);
     73        DELETE1_SIGNAL(out_SPR_WRITE_DATA         , _param->_nb_spr_write,_param->_size_special_data    );
     74       
     75        DELETE1_SIGNAL(out_BYPASS_WRITE_OOO_ENGINE_ID, _param->_nb_bypass_write,_param->_size_ooo_engine_id   );
     76        DELETE1_SIGNAL(out_BYPASS_WRITE_GPR_VAL      , _param->_nb_bypass_write,1                             );
     77        DELETE1_SIGNAL(out_BYPASS_WRITE_GPR_NUM_REG  , _param->_nb_bypass_write,_param->_size_general_register);
     78        DELETE1_SIGNAL(out_BYPASS_WRITE_GPR_DATA     , _param->_nb_bypass_write,_param->_size_general_data    );
     79        DELETE1_SIGNAL(out_BYPASS_WRITE_SPR_VAL      , _param->_nb_bypass_write,1                             );
     80        DELETE1_SIGNAL(out_BYPASS_WRITE_SPR_NUM_REG  , _param->_nb_bypass_write,_param->_size_special_register);
     81        DELETE1_SIGNAL(out_BYPASS_WRITE_SPR_DATA     , _param->_nb_bypass_write,_param->_size_special_data    );
     82      }
    5283
    53         // -----[ Interface "write_unit_out" ]-------------------------------   
    54         delete     out_WRITE_UNIT_OUT_VAL          ;
    55         delete      in_WRITE_UNIT_OUT_ACK          ;
    56         if (_param->_have_port_context_id)
    57         delete     out_WRITE_UNIT_OUT_CONTEXT_ID   ;
    58         if (_param->_have_port_front_end_id)
    59         delete     out_WRITE_UNIT_OUT_FRONT_END_ID ;
    60         if (_param->_have_port_ooo_engine_id)
    61         delete     out_WRITE_UNIT_OUT_OOO_ENGINE_ID;
    62         if (_param->_have_port_rob_ptr)
    63         delete     out_WRITE_UNIT_OUT_PACKET_ID    ;
    64 //      delete     out_WRITE_UNIT_OUT_OPERATION    ;
    65 //      delete     out_WRITE_UNIT_OUT_TYPE         ;
    66         delete     out_WRITE_UNIT_OUT_FLAGS        ;
    67         delete     out_WRITE_UNIT_OUT_EXCEPTION    ;
    68         delete     out_WRITE_UNIT_OUT_NO_SEQUENCE  ;
    69         delete     out_WRITE_UNIT_OUT_ADDRESS      ;
    70         delete     out_WRITE_UNIT_OUT_DATA         ;
    71 
    72         // -----[ Interface "gpr_write" ]-------------------------------------
    73         delete []  out_GPR_WRITE_VAL               ;
    74         delete []   in_GPR_WRITE_ACK               ;
    75         if (_param->_have_port_ooo_engine_id)
    76         delete []  out_GPR_WRITE_OOO_ENGINE_ID     ;
    77         delete []  out_GPR_WRITE_NUM_REG           ;
    78         delete []  out_GPR_WRITE_DATA              ;
    79        
    80         // -----[ Interface "spr_write" ]-------------------------------------
    81         delete []  out_SPR_WRITE_VAL               ;
    82         delete []   in_SPR_WRITE_ACK               ;
    83         if (_param->_have_port_ooo_engine_id)
    84         delete []  out_SPR_WRITE_OOO_ENGINE_ID     ;
    85         delete []  out_SPR_WRITE_NUM_REG           ;
    86         delete []  out_SPR_WRITE_DATA              ;
    87 
    88         // -----[ Interface "bypass_write" ]----------------------------------
    89         if (_param->_have_port_ooo_engine_id)
    90         delete []  out_BYPASS_WRITE_OOO_ENGINE_ID ;
    91         delete []  out_BYPASS_WRITE_GPR_VAL       ;
    92         delete []  out_BYPASS_WRITE_GPR_NUM_REG   ;
    93         delete []  out_BYPASS_WRITE_GPR_DATA      ;
    94         delete []  out_BYPASS_WRITE_SPR_VAL       ;
    95         delete []  out_BYPASS_WRITE_SPR_NUM_REG   ;
    96         delete []  out_BYPASS_WRITE_SPR_DATA      ;
    97 
    98       }
    9984    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    10085

  • 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

    r97 r112  
    5858    // ~~~~~[ Interface "execute_unit_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    5959     {
    60        ALLOC2_INTERFACE("execute_unit_out", IN, EAST, "Output of execution_unit", _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
     60       ALLOC2_INTERFACE_BEGIN("execute_unit_out", IN, EAST, "Output of execution_unit", _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
    6161
    6262       _ALLOC2_VALACK_IN ( in_EXECUTE_UNIT_OUT_VAL,VAL, _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
    … …  
    7777       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t        ,1                             , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
    7878       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_ADDRESS      ,"address"      ,Taddress_t        ,_param->_size_instruction_address, _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
     79
     80       ALLOC2_INTERFACE_END(_param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
    7981     }
    8082
    8183    // ~~~~~[ Interface "write_unit_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    8284     {
    83        ALLOC1_INTERFACE("write_unit_in", OUT, WEST, "Input of write_unit", _param->_nb_write_unit);
     85       ALLOC1_INTERFACE_BEGIN("write_unit_in", OUT, WEST, "Input of write_unit", _param->_nb_write_unit);
    8486
    8587       ALLOC1_VALACK_OUT(out_WRITE_UNIT_IN_VAL,VAL);
    … …  
    100102       ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t        ,1                             );
    101103       ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_ADDRESS      ,"address"      ,Taddress_t        ,_param->_size_instruction_address);
     104
     105       ALLOC1_INTERFACE_END(_param->_nb_write_unit);
    102106     }
    103107    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    … …  
    105109    if (usage_is_set(_usage,USE_SYSTEMC))
    106110      {
    107      _destination = new std::list<uint32_t> ** [_param->_nb_execute_unit];
    108      for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
    109        {
    110          _destination [i] = new std::list<uint32_t> * [_param->_nb_execute_unit_port[i]];
    111          for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
    112            {
    113              _destination [i][j] = new std::list<uint32_t> [_param->_nb_thread];
    114            }
    115        }
     111        ALLOC3(_destination,std::list<uint32_t>,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1],_param->_nb_thread);
    116112      }
    117113

  • 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

    r97 r112  
    6565        DELETE1_SIGNAL(out_WRITE_UNIT_IN_ADDRESS      , _param->_nb_write_unit,_param->_size_general_data    );
    6666     
    67         delete [] _destination;
     67        DELETE3(_destination,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1],_param->_nb_thread);
    6868      }
     69
    6970    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    7071

  • 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

    r88 r112  
    5757    // ~~~~~[ Interface "read_unit_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    5858     {
    59        ALLOC2_INTERFACE("read_unit_out", IN, EAST, "Output of read_unit",_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     59       ALLOC2_INTERFACE_BEGIN("read_unit_out", IN, EAST, "Output of read_unit",_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
    6060
    6161       _ALLOC2_VALACK_IN ( in_READ_UNIT_OUT_VAL,VAL,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
    … …  
    7878       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_WRITE_RE             ,"WRITE_RE"             ,Tcontrol_t        ,1                              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
    7979       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_NUM_REG_RE           ,"NUM_REG_RE"           ,Tspecial_address_t,_param->_size_special_register ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     80
     81       ALLOC2_INTERFACE_END(_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
    8082     }
    8183    // ~~~~~[ Interface "execute_unit_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    8284     {
    83        ALLOC2_INTERFACE("execute_unit_in", OUT, WEST, "Input of execute_unit", _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
     85       ALLOC2_INTERFACE_BEGIN("execute_unit_in", OUT, WEST, "Input of execute_unit", _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
    8486       
    8587       _ALLOC2_VALACK_OUT(out_EXECUTE_UNIT_IN_VAL,VAL, _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
    … …  
    102104       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_DATA_RB              ,"DATA_RB"              ,Tgeneral_data_t   ,_param->_size_general_data     , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
    103105       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_NUM_REG_RD           ,"NUM_REG_RD"           ,Tgeneral_address_t,_param->_size_general_register , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
     106
     107       ALLOC2_INTERFACE_END(_param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
    104108     }
    105109
    … …  
    107111     if (usage_is_set(_usage,USE_SYSTEMC))
    108112       {
    109      _destination = new std::list<destination_t> ** [_param->_nb_read_unit];
    110      for (uint32_t i=0; i<_param->_nb_read_unit; i++)
    111        {
    112          _destination [i] = new std::list<destination_t> * [_param->_nb_thread];
    113          for (uint32_t j=0; j<_param->_nb_thread; j++)
    114            {
    115              _destination [i][j] = new std::list<destination_t> [_param->_nb_type];
    116            }
    117        }
     113         ALLOC3(_destination,std::list<destination_t>,_param->_nb_read_unit,_param->_nb_thread,_param->_nb_type);;
    118114       }
    119115

  • 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

    r88 r112  
    6969         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_NUM_REG_RD           , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_general_register );
    7070
    71          delete [] _destination;
     71         DELETE3(_destination,_param->_nb_read_unit,_param->_nb_thread,_param->_nb_type);;
    7272      }
    7373    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   

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

    r88 r112  
    77
    88#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/include/Register_unit_Glue.h"
     9#include "Behavioural/include/Allocation.h"
    910
    1011namespace morpheo                    {
    … …  
    5051    out_CONST_1      = interface->set_signal_out <Tcontrol_t> ("const_1",1);
    5152
    52     // ~~~~~[ Interface "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    53    in_GPR_READ_VAL               = new SC_IN (Tcontrol_t        )   * [_param->_nb_gpr_read];
    54   out_GPR_READ_ACK               = new SC_OUT(Tcontrol_t        )   * [_param->_nb_gpr_read];
    55   if (_param->_have_port_ooo_engine_id == true)
    56    in_GPR_READ_OOO_ENGINE_ID     = new SC_IN (Tcontext_t        )   * [_param->_nb_gpr_read];
    57   out_GPR_READ_DATA              = new SC_OUT(Tgeneral_data_t   )   * [_param->_nb_gpr_read];
    58   out_GPR_READ_DATA_VAL          = new SC_OUT(Tcontrol_t        )   * [_param->_nb_gpr_read];
    59 
    60   out_GPR_READ_REGISTERFILE_VAL  = new SC_OUT(Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    61    in_GPR_READ_REGISTERFILE_ACK  = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    62    in_GPR_READ_REGISTERFILE_DATA = new SC_IN (Tgeneral_data_t   )  ** [_param->_nb_ooo_engine];
    63 
    64   out_GPR_READ_STATUS_VAL        = new SC_OUT(Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    65    in_GPR_READ_STATUS_ACK        = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    66    in_GPR_READ_STATUS_DATA_VAL   = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    67 
    68    for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    69      {
    70        out_GPR_READ_REGISTERFILE_VAL  [i] = new SC_OUT(Tcontrol_t        )  * [_param->_nb_gpr_read];
    71         in_GPR_READ_REGISTERFILE_ACK  [i] = new SC_IN (Tcontrol_t        )  * [_param->_nb_gpr_read];
    72         in_GPR_READ_REGISTERFILE_DATA [i] = new SC_IN (Tgeneral_data_t   )  * [_param->_nb_gpr_read];
    73 
    74        out_GPR_READ_STATUS_VAL        [i] = new SC_OUT(Tcontrol_t        )  * [_param->_nb_gpr_read];
    75         in_GPR_READ_STATUS_ACK        [i] = new SC_IN (Tcontrol_t        )  * [_param->_nb_gpr_read];
    76         in_GPR_READ_STATUS_DATA_VAL   [i] = new SC_IN (Tcontrol_t        )  * [_param->_nb_gpr_read];
    77      }
    78 
    79    for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
    80      {
    81        Interface_fifo * interface = _interfaces->set_interface("gpr_read_"+toString(j)
    82 #ifdef POSITION
    83                                                           ,IN
    84                                                           ,NORTH,
    85                                                           "Interface to read generalist register"
    86 #endif
    87                                                           );
    88      
    89         in_GPR_READ_VAL           [j] = interface->set_signal_valack_in  (VAL);
    90        out_GPR_READ_ACK           [j] = interface->set_signal_valack_out (ACK);
    91        if (_param->_have_port_ooo_engine_id == true)
    92         in_GPR_READ_OOO_ENGINE_ID [j] = interface->set_signal_in <Tcontext_t     > ("ooo_engine_id", _param->_size_ooo_engine_id);
    93        out_GPR_READ_DATA          [j] = interface->set_signal_out<Tgeneral_data_t> ("data"         , _param->_size_general_data);
    94        out_GPR_READ_DATA_VAL      [j] = interface->set_signal_out<Tcontrol_t     > ("data_val"     , 1);
    95 
    96        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    97          {
    98            {
    99              Interface_fifo * interface = _interfaces->set_interface("gpr_read_registerfile_"+toString(i)+"_"+toString(j)
    100 #ifdef POSITION
    101                                                                 ,IN
    102                                                                 ,NORTH,
    103                                                                 "Interface to read generalist register - from/to register file"
    104 #endif
    105                                                                 );
    106              
    107              out_GPR_READ_REGISTERFILE_VAL  [i][j] = interface->set_signal_valack_out (VAL);
    108               in_GPR_READ_REGISTERFILE_ACK  [i][j] = interface->set_signal_valack_in  (ACK);
    109               in_GPR_READ_REGISTERFILE_DATA [i][j] = interface->set_signal_in <Tgeneral_data_t> ("data"         , _param->_size_general_data);
    110            }
    111            {
    112              Interface_fifo * interface = _interfaces->set_interface("gpr_read_status_"+toString(i)+"_"+toString(j)
    113 #ifdef POSITION
    114                                                                 ,IN
    115                                                                 ,NORTH,
    116                                                                 "Interface to read generalist register - from/to status"
    117 #endif
    118                                                                 );
    119 
    120 
    121              out_GPR_READ_STATUS_VAL        [i][j] = interface->set_signal_valack_out (VAL);
    122               in_GPR_READ_STATUS_ACK        [i][j] = interface->set_signal_valack_in  (ACK);
    123               in_GPR_READ_STATUS_DATA_VAL   [i][j] = interface->set_signal_in <Tcontrol_t     > ("data_val"     , 1);
    124            }
    125          }
    126      }
    127 
    128     // ~~~~~[ Interface "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    129    in_SPR_READ_VAL               = new SC_IN (Tcontrol_t        )   * [_param->_nb_spr_read];
    130   out_SPR_READ_ACK               = new SC_OUT(Tcontrol_t        )   * [_param->_nb_spr_read];
    131   if (_param->_have_port_ooo_engine_id == true)
    132    in_SPR_READ_OOO_ENGINE_ID     = new SC_IN (Tcontext_t        )   * [_param->_nb_spr_read];
    133   out_SPR_READ_DATA              = new SC_OUT(Tspecial_data_t   )   * [_param->_nb_spr_read];
    134   out_SPR_READ_DATA_VAL          = new SC_OUT(Tcontrol_t        )   * [_param->_nb_spr_read];
    135 
    136   out_SPR_READ_REGISTERFILE_VAL  = new SC_OUT(Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    137    in_SPR_READ_REGISTERFILE_ACK  = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    138    in_SPR_READ_REGISTERFILE_DATA = new SC_IN (Tspecial_data_t   )  ** [_param->_nb_ooo_engine];
    139 
    140   out_SPR_READ_STATUS_VAL        = new SC_OUT(Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    141    in_SPR_READ_STATUS_ACK        = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    142    in_SPR_READ_STATUS_DATA_VAL   = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    143 
    144    for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    145      {
    146        out_SPR_READ_REGISTERFILE_VAL  [i] = new SC_OUT(Tcontrol_t        )  * [_param->_nb_spr_read];
    147         in_SPR_READ_REGISTERFILE_ACK  [i] = new SC_IN (Tcontrol_t        )  * [_param->_nb_spr_read];
    148         in_SPR_READ_REGISTERFILE_DATA [i] = new SC_IN (Tspecial_data_t   )  * [_param->_nb_spr_read];
    149 
    150        out_SPR_READ_STATUS_VAL        [i] = new SC_OUT(Tcontrol_t        )  * [_param->_nb_spr_read];
    151         in_SPR_READ_STATUS_ACK        [i] = new SC_IN (Tcontrol_t        )  * [_param->_nb_spr_read];
    152         in_SPR_READ_STATUS_DATA_VAL   [i] = new SC_IN (Tcontrol_t        )  * [_param->_nb_spr_read];
    153      }
    154 
    155    for (uint32_t j=0; j<_param->_nb_spr_read; j++)
    156      {
    157        Interface_fifo * interface = _interfaces->set_interface("spr_read_"+toString(j)
    158 #ifdef POSITION
    159                                                           ,IN
    160                                                           ,NORTH,
    161                                                           "Interface to read special register"
    162 #endif
    163                                                           );
    164      
    165         in_SPR_READ_VAL           [j] = interface->set_signal_valack_in  (VAL);
    166        out_SPR_READ_ACK           [j] = interface->set_signal_valack_out (ACK);
    167        if (_param->_have_port_ooo_engine_id == true)
    168         in_SPR_READ_OOO_ENGINE_ID [j] = interface->set_signal_in <Tcontext_t     > ("ooo_engine_id", _param->_size_ooo_engine_id);
    169        out_SPR_READ_DATA          [j] = interface->set_signal_out<Tspecial_data_t> ("data"         , _param->_size_special_data);
    170        out_SPR_READ_DATA_VAL      [j] = interface->set_signal_out<Tcontrol_t     > ("data_val"     , 1);
    171 
    172        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    173          {
    174            {
    175              Interface_fifo * interface = _interfaces->set_interface("spr_read_registerfile_"+toString(i)+"_"+toString(j)
    176 #ifdef POSITION
    177                                                                 ,IN
    178                                                                 ,NORTH,
    179                                                                 "Interface to read special register - from/to register file"
    180 #endif
    181                                                                 );
    182              
    183              out_SPR_READ_REGISTERFILE_VAL  [i][j] = interface->set_signal_valack_out (VAL);
    184               in_SPR_READ_REGISTERFILE_ACK  [i][j] = interface->set_signal_valack_in  (ACK);
    185               in_SPR_READ_REGISTERFILE_DATA [i][j] = interface->set_signal_in <Tspecial_data_t> ("data"         , _param->_size_special_data);
    186            }
    187            {
    188              Interface_fifo * interface = _interfaces->set_interface("spr_read_status_"+toString(i)+"_"+toString(j)
    189 #ifdef POSITION
    190                                                                 ,IN
    191                                                                 ,NORTH,
    192                                                                 "Interface to read special register - from/to status"
    193 #endif
    194                                                                 );
    195 
    196 
    197              out_SPR_READ_STATUS_VAL        [i][j] = interface->set_signal_valack_out (VAL);
    198               in_SPR_READ_STATUS_ACK        [i][j] = interface->set_signal_valack_in  (ACK);
    199               in_SPR_READ_STATUS_DATA_VAL   [i][j] = interface->set_signal_in <Tcontrol_t     > ("data_val"     , 1);
    200            }
    201          }
    202      }
    203 
    204     // ~~~~~[ Interface "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    205    in_GPR_WRITE_VAL               = new SC_IN (Tcontrol_t        )   * [_param->_nb_gpr_write];
    206   out_GPR_WRITE_ACK               = new SC_OUT(Tcontrol_t        )   * [_param->_nb_gpr_write];
    207   if (_param->_have_port_ooo_engine_id == true)
    208   in_GPR_WRITE_OOO_ENGINE_ID     = new SC_IN (Tcontext_t        )   * [_param->_nb_gpr_write];
    209 
    210   out_GPR_WRITE_REGISTERFILE_VAL  = new SC_OUT(Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    211    in_GPR_WRITE_REGISTERFILE_ACK  = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    212 
    213   out_GPR_WRITE_STATUS_VAL        = new SC_OUT(Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    214    in_GPR_WRITE_STATUS_ACK        = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    215 
    216    for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    217      {
    218        out_GPR_WRITE_REGISTERFILE_VAL  [i] = new SC_OUT(Tcontrol_t        )  * [_param->_nb_gpr_write];
    219         in_GPR_WRITE_REGISTERFILE_ACK  [i] = new SC_IN (Tcontrol_t        )  * [_param->_nb_gpr_write];
    220 
    221        out_GPR_WRITE_STATUS_VAL        [i] = new SC_OUT(Tcontrol_t        )  * [_param->_nb_gpr_write];
    222         in_GPR_WRITE_STATUS_ACK        [i] = new SC_IN (Tcontrol_t        )  * [_param->_nb_gpr_write];
    223      }
    224 
    225    for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
    226      {
    227        Interface_fifo * interface = _interfaces->set_interface("gpr_write_"+toString(j)
    228 #ifdef POSITION
    229                                                           ,IN
    230                                                           ,NORTH,
    231                                                           "Interface to write generalist register"
    232 #endif
    233                                                           );
    234      
    235         in_GPR_WRITE_VAL           [j] = interface->set_signal_valack_in  (VAL);
    236        out_GPR_WRITE_ACK           [j] = interface->set_signal_valack_out (ACK);
    237        if (_param->_have_port_ooo_engine_id == true)
    238         in_GPR_WRITE_OOO_ENGINE_ID [j] = interface->set_signal_in <Tcontext_t     > ("ooo_engine_id", _param->_size_ooo_engine_id);
    239 
    240        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    241          {
    242            {
    243              Interface_fifo * interface = _interfaces->set_interface("gpr_write_registerfile_"+toString(i)+"_"+toString(j)
    244 #ifdef POSITION
    245                                                                 ,IN
    246                                                                 ,NORTH,
    247                                                                 "Interface to write generalist register - from/to register file"
    248 #endif
    249                                                                 );
    250              
    251              out_GPR_WRITE_REGISTERFILE_VAL  [i][j] = interface->set_signal_valack_out (VAL);
    252               in_GPR_WRITE_REGISTERFILE_ACK  [i][j] = interface->set_signal_valack_in  (ACK);
    253            }
    254            {
    255              Interface_fifo * interface = _interfaces->set_interface("gpr_write_status_"+toString(i)+"_"+toString(j)
    256 #ifdef POSITION
    257                                                                 ,IN
    258                                                                 ,NORTH,
    259                                                                 "Interface to write generalist register - from/to status"
    260 #endif
    261                                                                 );
    262 
    263 
    264              out_GPR_WRITE_STATUS_VAL        [i][j] = interface->set_signal_valack_out (VAL);
    265               in_GPR_WRITE_STATUS_ACK        [i][j] = interface->set_signal_valack_in  (ACK);
    266            }
    267          }
    268      }
    269 
    270     // ~~~~~[ Interface "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    271    in_SPR_WRITE_VAL               = new SC_IN (Tcontrol_t        )   * [_param->_nb_spr_write];
    272   out_SPR_WRITE_ACK               = new SC_OUT(Tcontrol_t        )   * [_param->_nb_spr_write];
    273   if (_param->_have_port_ooo_engine_id == true)
    274    in_SPR_WRITE_OOO_ENGINE_ID     = new SC_IN (Tcontext_t        )   * [_param->_nb_spr_write];
    275 
    276   out_SPR_WRITE_REGISTERFILE_VAL  = new SC_OUT(Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    277    in_SPR_WRITE_REGISTERFILE_ACK  = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    278 
    279   out_SPR_WRITE_STATUS_VAL        = new SC_OUT(Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    280    in_SPR_WRITE_STATUS_ACK        = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    281 
    282    for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    283      {
    284        out_SPR_WRITE_REGISTERFILE_VAL  [i] = new SC_OUT(Tcontrol_t        )  * [_param->_nb_spr_write];
    285         in_SPR_WRITE_REGISTERFILE_ACK  [i] = new SC_IN (Tcontrol_t        )  * [_param->_nb_spr_write];
    286 
    287        out_SPR_WRITE_STATUS_VAL        [i] = new SC_OUT(Tcontrol_t        )  * [_param->_nb_spr_write];
    288         in_SPR_WRITE_STATUS_ACK        [i] = new SC_IN (Tcontrol_t        )  * [_param->_nb_spr_write];
    289      }
    290 
    291    for (uint32_t j=0; j<_param->_nb_spr_write; j++)
    292      {
    293        Interface_fifo * interface = _interfaces->set_interface("spr_write_"+toString(j)
    294 #ifdef POSITION
    295                                                           ,IN
    296                                                           ,NORTH,
    297                                                           "Interface to write special register"
    298 #endif
    299                                                           );
    300      
    301         in_SPR_WRITE_VAL           [j] = interface->set_signal_valack_in  (VAL);
    302        out_SPR_WRITE_ACK           [j] = interface->set_signal_valack_out (ACK);
    303        if (_param->_have_port_ooo_engine_id == true)
    304         in_SPR_WRITE_OOO_ENGINE_ID [j] = interface->set_signal_in <Tcontext_t     > ("ooo_engine_id", _param->_size_ooo_engine_id);
    305 
    306        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    307          {
    308            {
    309              Interface_fifo * interface = _interfaces->set_interface("spr_write_registerfile_"+toString(i)+"_"+toString(j)
    310 #ifdef POSITION
    311                                                                 ,IN
    312                                                                 ,NORTH,
    313                                                                 "Interface to write special register - from/to register file"
    314 #endif
    315                                                                 );
    316              
    317              out_SPR_WRITE_REGISTERFILE_VAL  [i][j] = interface->set_signal_valack_out (VAL);
    318               in_SPR_WRITE_REGISTERFILE_ACK  [i][j] = interface->set_signal_valack_in  (ACK);
    319            }
    320            {
    321              Interface_fifo * interface = _interfaces->set_interface("spr_write_status_"+toString(i)+"_"+toString(j)
    322 #ifdef POSITION
    323                                                                 ,IN
    324                                                                 ,NORTH,
    325                                                                 "Interface to write special register - from/to status"
    326 #endif
    327                                                                 );
    328 
    329 
    330              out_SPR_WRITE_STATUS_VAL        [i][j] = interface->set_signal_valack_out (VAL);
    331               in_SPR_WRITE_STATUS_ACK        [i][j] = interface->set_signal_valack_in  (ACK);
    332            }
    333          }
    334      }
    335 
    336    // ~~~~~[ Interface "insert_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    337     in_INSERT_ROB_VAL                  = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
    338    out_INSERT_ROB_ACK                  = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
    339     in_INSERT_ROB_RD_USE               = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
    340     in_INSERT_ROB_RE_USE               = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
    341    out_INSERT_ROB_GPR_STATUS_VAL       = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
    342     in_INSERT_ROB_GPR_STATUS_ACK       = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
    343    out_INSERT_ROB_SPR_STATUS_VAL       = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
    344     in_INSERT_ROB_SPR_STATUS_ACK       = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
    345 
    346     for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    347       {
    348         uint32_t x=_param->_nb_inst_insert_rob [i];
    349 
    350         in_INSERT_ROB_VAL                  [i] = new SC_IN (Tcontrol_t) * [x];
    351        out_INSERT_ROB_ACK                  [i] = new SC_OUT(Tcontrol_t) * [x];
    352         in_INSERT_ROB_RD_USE               [i] = new SC_IN (Tcontrol_t) * [x];
    353         in_INSERT_ROB_RE_USE               [i] = new SC_IN (Tcontrol_t) * [x];
    354        out_INSERT_ROB_GPR_STATUS_VAL       [i] = new SC_OUT(Tcontrol_t) * [x];
    355         in_INSERT_ROB_GPR_STATUS_ACK       [i] = new SC_IN (Tcontrol_t) * [x];
    356        out_INSERT_ROB_SPR_STATUS_VAL       [i] = new SC_OUT(Tcontrol_t) * [x];
    357         in_INSERT_ROB_SPR_STATUS_ACK       [i] = new SC_IN (Tcontrol_t) * [x];
    358 
    359         for (uint32_t j=0; j<x; j++)
    360           {
    361             {
    362               Interface_fifo * interface = _interfaces->set_interface("insert_rob_"+toString(i)+"_"+toString(j)
    363 #ifdef POSITION
    364                                                                       ,IN
    365                                                                       ,WEST
    366                                                                       ,"Interface to update status (insert)"
    367 #endif
    368                                                                       );
    369 
    370                in_INSERT_ROB_VAL                  [i][j] = interface->set_signal_valack_in (VAL);
    371               out_INSERT_ROB_ACK                  [i][j] = interface->set_signal_valack_out(ACK);
    372                in_INSERT_ROB_RD_USE               [i][j] = interface->set_signal_in <Tcontrol_t> ("rd_use", 1);
    373                in_INSERT_ROB_RE_USE               [i][j] = interface->set_signal_in <Tcontrol_t> ("re_use", 1);
    374             }
    375             {
    376               Interface_fifo * interface = _interfaces->set_interface("insert_rob_gpr_status_"+toString(i)+"_"+toString(j)
    377 #ifdef POSITION
    378                                                                       ,IN
    379                                                                       ,EAST
    380                                                                       ,"Interface to update status (insert)"
    381 #endif
    382                                                                       );
    383 
    384               out_INSERT_ROB_GPR_STATUS_VAL       [i][j] = interface->set_signal_valack_out(VAL);
    385                in_INSERT_ROB_GPR_STATUS_ACK       [i][j] = interface->set_signal_valack_in (ACK);
    386             }
    387             {
    388               Interface_fifo * interface = _interfaces->set_interface("insert_rob_spr_status_"+toString(i)+"_"+toString(j)
    389 #ifdef POSITION
    390                                                                       ,IN
    391                                                                       ,EAST
    392                                                                       ,"Interface to update status (insert)"
    393 #endif
    394                                                                       );
    395 
    396               out_INSERT_ROB_SPR_STATUS_VAL       [i][j] = interface->set_signal_valack_out(VAL);
    397                in_INSERT_ROB_SPR_STATUS_ACK       [i][j] = interface->set_signal_valack_in (ACK);
    398             }
    399           }
    400       }
     53    // ~~~~~[ Interface "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     54    {
     55      ALLOC1_INTERFACE_BEGIN("gpr_read",IN,NORTH,_("Interface to read generalist register"),_param->_nb_gpr_read);
     56
     57      ALLOC1_VALACK_IN ( in_GPR_READ_VAL           ,VAL);
     58      ALLOC1_VALACK_OUT(out_GPR_READ_ACK           ,ACK);
     59      ALLOC1_SIGNAL_IN ( in_GPR_READ_OOO_ENGINE_ID ,"ooo_engine_id",Tcontext_t     , _param->_size_ooo_engine_id);
     60      ALLOC1_SIGNAL_OUT(out_GPR_READ_DATA          ,"data"         ,Tgeneral_data_t, _param->_size_general_data);
     61      ALLOC1_SIGNAL_OUT(out_GPR_READ_DATA_VAL      ,"data_val"     ,Tcontrol_t     , 1);
     62
     63      ALLOC1_INTERFACE_END(_param->_nb_gpr_read);
     64    }
     65
     66    {
     67      ALLOC2_INTERFACE_BEGIN("gpr_read_registerfile",IN,NORTH,_("Interface to read generalist register - from/to register file"),_param->_nb_ooo_engine,_param->_nb_gpr_read);
     68     
     69      ALLOC2_VALACK_OUT(out_GPR_READ_REGISTERFILE_VAL ,VAL);
     70      ALLOC2_VALACK_IN ( in_GPR_READ_REGISTERFILE_ACK ,ACK);
     71      ALLOC2_SIGNAL_IN ( in_GPR_READ_REGISTERFILE_DATA,"data",Tgeneral_data_t,_param->_size_general_data);
     72     
     73      ALLOC2_INTERFACE_END(_param->_nb_ooo_engine,_param->_nb_gpr_read);
     74    }
     75   
     76    {
     77      ALLOC2_INTERFACE_BEGIN("gpr_read_status",IN,NORTH,_("Interface to read generalist register - from/to register file"),_param->_nb_ooo_engine,_param->_nb_gpr_read);
     78     
     79      ALLOC2_VALACK_OUT(out_GPR_READ_STATUS_VAL      ,VAL);
     80      ALLOC2_VALACK_IN ( in_GPR_READ_STATUS_ACK      ,ACK);
     81      ALLOC2_SIGNAL_IN ( in_GPR_READ_STATUS_DATA_VAL,"data_val",Tcontrol_t,1);
     82
     83      ALLOC2_INTERFACE_END(_param->_nb_ooo_engine,_param->_nb_gpr_read);
     84    }
     85
     86    // ~~~~~[ Interface "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     87    {
     88      ALLOC1_INTERFACE_BEGIN("spr_read",IN,NORTH,_("Interface to read generalist register"),_param->_nb_spr_read);
     89
     90      ALLOC1_VALACK_IN ( in_SPR_READ_VAL           ,VAL);
     91      ALLOC1_VALACK_OUT(out_SPR_READ_ACK           ,ACK);
     92      ALLOC1_SIGNAL_IN ( in_SPR_READ_OOO_ENGINE_ID ,"ooo_engine_id",Tcontext_t     , _param->_size_ooo_engine_id);
     93      ALLOC1_SIGNAL_OUT(out_SPR_READ_DATA          ,"data"         ,Tspecial_data_t, _param->_size_special_data);
     94      ALLOC1_SIGNAL_OUT(out_SPR_READ_DATA_VAL      ,"data_val"     ,Tcontrol_t     , 1);
     95
     96      ALLOC1_INTERFACE_END(_param->_nb_spr_read);
     97    }
     98   
     99    {
     100      ALLOC2_INTERFACE_BEGIN("spr_read_registerfile",IN,NORTH,_("Interface to read generalist register - from/to register file"),_param->_nb_ooo_engine,_param->_nb_spr_read);
     101     
     102      ALLOC2_VALACK_OUT(out_SPR_READ_REGISTERFILE_VAL ,VAL);
     103      ALLOC2_VALACK_IN ( in_SPR_READ_REGISTERFILE_ACK ,ACK);
     104      ALLOC2_SIGNAL_IN ( in_SPR_READ_REGISTERFILE_DATA,"data",Tspecial_data_t,_param->_size_special_data);
     105     
     106      ALLOC2_INTERFACE_END(_param->_nb_ooo_engine,_param->_nb_spr_read);
     107    }
     108   
     109    {
     110      ALLOC2_INTERFACE_BEGIN("spr_read_status",IN,NORTH,_("Interface to read generalist register - from/to status"),_param->_nb_ooo_engine,_param->_nb_spr_read);
     111     
     112      ALLOC2_VALACK_OUT(out_SPR_READ_STATUS_VAL      ,VAL);
     113      ALLOC2_VALACK_IN ( in_SPR_READ_STATUS_ACK      ,ACK);
     114      ALLOC2_SIGNAL_IN ( in_SPR_READ_STATUS_DATA_VAL,"data_val",Tcontrol_t,1);
     115     
     116      ALLOC2_INTERFACE_END(_param->_nb_ooo_engine,_param->_nb_spr_read);
     117    }
     118
     119    // ~~~~~[ Interface "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     120    {
     121      ALLOC1_INTERFACE_BEGIN("gpr_write",IN,NORTH,_("Interface to write generalist register"),_param->_nb_gpr_write);
     122     
     123      ALLOC1_VALACK_IN ( in_GPR_WRITE_VAL          ,VAL);
     124      ALLOC1_VALACK_OUT(out_GPR_WRITE_ACK          ,ACK);
     125      ALLOC1_SIGNAL_IN ( in_GPR_WRITE_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t, _param->_size_ooo_engine_id);
     126
     127      ALLOC1_INTERFACE_END(_param->_nb_gpr_write);
     128    }
     129   
     130    {
     131      ALLOC2_INTERFACE_BEGIN("gpr_write_registerfile",IN,NORTH,_("Interface to write generalist register - from/to registerfile"),_param->_nb_ooo_engine,_param->_nb_gpr_write);
     132     
     133      ALLOC2_VALACK_OUT(out_GPR_WRITE_REGISTERFILE_VAL,VAL);
     134      ALLOC2_VALACK_IN ( in_GPR_WRITE_REGISTERFILE_ACK,ACK);
     135
     136      ALLOC2_INTERFACE_END(_param->_nb_ooo_engine,_param->_nb_gpr_write);
     137    }
     138   
     139    {
     140      ALLOC2_INTERFACE_BEGIN("gpr_write_status",IN,NORTH,_("Interface to write generalist register - from/to status"),_param->_nb_ooo_engine,_param->_nb_gpr_write);
     141     
     142      ALLOC2_VALACK_OUT(out_GPR_WRITE_STATUS_VAL,VAL);
     143      ALLOC2_VALACK_IN ( in_GPR_WRITE_STATUS_ACK,ACK);
     144
     145      ALLOC2_INTERFACE_END(_param->_nb_ooo_engine,_param->_nb_gpr_write);
     146    }
     147
     148    // ~~~~~[ Interface "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     149    {
     150      ALLOC1_INTERFACE_BEGIN("spr_write",IN,NORTH,_("Interface to write generalist register"),_param->_nb_spr_write);
     151     
     152      ALLOC1_VALACK_IN ( in_SPR_WRITE_VAL          ,VAL);
     153      ALLOC1_VALACK_OUT(out_SPR_WRITE_ACK          ,ACK);
     154      ALLOC1_SIGNAL_IN ( in_SPR_WRITE_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t, _param->_size_ooo_engine_id);
     155
     156      ALLOC1_INTERFACE_END(_param->_nb_spr_write);
     157    }
     158   
     159    {
     160      ALLOC2_INTERFACE_BEGIN("spr_write_registerfile",IN,NORTH,_("Interface to write generalist register - from/to registerfile"),_param->_nb_ooo_engine,_param->_nb_spr_write);
     161     
     162      ALLOC2_VALACK_OUT(out_SPR_WRITE_REGISTERFILE_VAL,VAL);
     163      ALLOC2_VALACK_IN ( in_SPR_WRITE_REGISTERFILE_ACK,ACK);
     164
     165      ALLOC2_INTERFACE_END(_param->_nb_ooo_engine,_param->_nb_spr_write);
     166    }
     167   
     168    {
     169      ALLOC2_INTERFACE_BEGIN("spr_write_status",IN,NORTH,_("Interface to write generalist register - from/to status"),_param->_nb_ooo_engine,_param->_nb_spr_write);
     170     
     171      ALLOC2_VALACK_OUT(out_SPR_WRITE_STATUS_VAL,VAL);
     172      ALLOC2_VALACK_IN ( in_SPR_WRITE_STATUS_ACK,ACK);
     173
     174      ALLOC2_INTERFACE_END(_param->_nb_ooo_engine,_param->_nb_spr_write);
     175    }
     176
     177    // ~~~~~[ Interface "insert_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     178    {
     179      ALLOC2_INTERFACE_BEGIN("insert_rob",IN,WEST,_("Interface to update status (insert)"),_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
     180     
     181      _ALLOC2_VALACK_IN ( in_INSERT_ROB_VAL   ,VAL                   ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
     182      _ALLOC2_VALACK_OUT(out_INSERT_ROB_ACK   ,ACK                   ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
     183      _ALLOC2_SIGNAL_IN ( in_INSERT_ROB_RD_USE,"rd_use",Tcontrol_t, 1,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
     184      _ALLOC2_SIGNAL_IN ( in_INSERT_ROB_RE_USE,"re_use",Tcontrol_t, 1,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
     185
     186      ALLOC2_INTERFACE_END(_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
     187    }
     188   
     189    {
     190      ALLOC2_INTERFACE_BEGIN("insert_rob_gpr_status",IN,WEST,_("Interface to update status (insert)"),_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
     191     
     192      _ALLOC2_VALACK_OUT(out_INSERT_ROB_GPR_STATUS_VAL,VAL,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
     193      _ALLOC2_VALACK_IN ( in_INSERT_ROB_GPR_STATUS_ACK,ACK,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
     194
     195      ALLOC2_INTERFACE_END(_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
     196    }
     197   
     198    {
     199      ALLOC2_INTERFACE_BEGIN("insert_rob_spr_status",IN,WEST,_("Interface to update status (insert)"),_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
     200     
     201      _ALLOC2_VALACK_OUT(out_INSERT_ROB_SPR_STATUS_VAL,VAL,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
     202      _ALLOC2_VALACK_IN ( in_INSERT_ROB_SPR_STATUS_ACK,ACK,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
     203
     204      ALLOC2_INTERFACE_END(_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
     205    }
    401206
    402207//     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

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

    r88 r112  
    77
    88#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/include/Register_unit_Glue.h"
     9#include "Behavioural/include/Allocation.h"
    910
    1011namespace morpheo                    {
    … …  
    2627      {
    2728//#if defined(STATISTICS) or defined(VHDL_TESTBENCH)
    28     delete    in_CLOCK ;
     29    delete  in_CLOCK ;
    2930//#endif
    30     delete    in_NRESET;
     31    delete  in_NRESET;
     32    delete out_CONST_0;
     33    delete out_CONST_1;
    3134
    32     // ~~~~~[ Interface "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    33     delete []  in_GPR_READ_VAL               ;
    34     delete [] out_GPR_READ_ACK               ;
    35     if (_param->_have_port_ooo_engine_id == true)
    36     delete []  in_GPR_READ_OOO_ENGINE_ID     ;
    37     delete [] out_GPR_READ_DATA              ;
    38     delete [] out_GPR_READ_DATA_VAL          ;
     35    DELETE1_SIGNAL( in_GPR_READ_VAL           ,_param->_nb_gpr_read,1  );
     36    DELETE1_SIGNAL(out_GPR_READ_ACK           ,_param->_nb_gpr_read,1  );
     37    DELETE1_SIGNAL( in_GPR_READ_OOO_ENGINE_ID ,_param->_nb_gpr_read,_param->_size_ooo_engine_id);
     38    DELETE1_SIGNAL(out_GPR_READ_DATA          ,_param->_nb_gpr_read,_param->_size_general_data);
     39    DELETE1_SIGNAL(out_GPR_READ_DATA_VAL      ,_param->_nb_gpr_read,1);
     40   
     41    DELETE2_SIGNAL(out_GPR_READ_REGISTERFILE_VAL ,_param->_nb_ooo_engine,_param->_nb_gpr_read,1  );
     42    DELETE2_SIGNAL( in_GPR_READ_REGISTERFILE_ACK ,_param->_nb_ooo_engine,_param->_nb_gpr_read,1  );
     43    DELETE2_SIGNAL( in_GPR_READ_REGISTERFILE_DATA,_param->_nb_ooo_engine,_param->_nb_gpr_read,_param->_size_general_data);
    3944
    40     delete [] out_GPR_READ_REGISTERFILE_VAL  ;
    41     delete []  in_GPR_READ_REGISTERFILE_ACK  ;
    42     delete []  in_GPR_READ_REGISTERFILE_DATA ;
     45    DELETE2_SIGNAL(out_GPR_READ_STATUS_VAL     ,_param->_nb_ooo_engine,_param->_nb_gpr_read,1  );
     46    DELETE2_SIGNAL( in_GPR_READ_STATUS_ACK     ,_param->_nb_ooo_engine,_param->_nb_gpr_read,1  );
     47    DELETE2_SIGNAL( in_GPR_READ_STATUS_DATA_VAL,_param->_nb_ooo_engine,_param->_nb_gpr_read,1);
    4348
    44     delete [] out_GPR_READ_STATUS_VAL        ;
    45     delete []  in_GPR_READ_STATUS_ACK        ;
    46     delete []  in_GPR_READ_STATUS_DATA_VAL   ;
     49    DELETE1_SIGNAL( in_SPR_READ_VAL           ,_param->_nb_spr_read,1  );
     50    DELETE1_SIGNAL(out_SPR_READ_ACK           ,_param->_nb_spr_read,1  );
     51    DELETE1_SIGNAL( in_SPR_READ_OOO_ENGINE_ID ,_param->_nb_spr_read,_param->_size_ooo_engine_id);
     52    DELETE1_SIGNAL(out_SPR_READ_DATA          ,_param->_nb_spr_read,_param->_size_special_data);
     53    DELETE1_SIGNAL(out_SPR_READ_DATA_VAL      ,_param->_nb_spr_read,1);
     54   
     55    DELETE2_SIGNAL(out_SPR_READ_REGISTERFILE_VAL ,_param->_nb_ooo_engine,_param->_nb_spr_read,1  );
     56    DELETE2_SIGNAL( in_SPR_READ_REGISTERFILE_ACK ,_param->_nb_ooo_engine,_param->_nb_spr_read,1  );
     57    DELETE2_SIGNAL( in_SPR_READ_REGISTERFILE_DATA,_param->_nb_ooo_engine,_param->_nb_spr_read,_param->_size_special_data);
     58   
     59    DELETE2_SIGNAL(out_SPR_READ_STATUS_VAL     ,_param->_nb_ooo_engine,_param->_nb_spr_read,1  );
     60    DELETE2_SIGNAL( in_SPR_READ_STATUS_ACK     ,_param->_nb_ooo_engine,_param->_nb_spr_read,1  );
     61    DELETE2_SIGNAL( in_SPR_READ_STATUS_DATA_VAL,_param->_nb_ooo_engine,_param->_nb_spr_read,1);
     62   
     63    DELETE1_SIGNAL( in_GPR_WRITE_VAL          ,_param->_nb_gpr_write,1  );
     64    DELETE1_SIGNAL(out_GPR_WRITE_ACK          ,_param->_nb_gpr_write,1  );
     65    DELETE1_SIGNAL( in_GPR_WRITE_OOO_ENGINE_ID,_param->_nb_gpr_write,_param->_size_ooo_engine_id);
    4766
     67   
     68    DELETE2_SIGNAL(out_GPR_WRITE_REGISTERFILE_VAL,_param->_nb_ooo_engine,_param->_nb_gpr_write,1  );
     69    DELETE2_SIGNAL( in_GPR_WRITE_REGISTERFILE_ACK,_param->_nb_ooo_engine,_param->_nb_gpr_write,1  );
    4870
    49     // ~~~~~[ Interface "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    50     delete []  in_SPR_READ_VAL               ;
    51     delete [] out_SPR_READ_ACK               ;
    52     if (_param->_have_port_ooo_engine_id == true)
    53     delete []  in_SPR_READ_OOO_ENGINE_ID     ;
    54     delete [] out_SPR_READ_DATA              ;
    55     delete [] out_SPR_READ_DATA_VAL          ;
     71    DELETE2_SIGNAL(out_GPR_WRITE_STATUS_VAL,_param->_nb_ooo_engine,_param->_nb_gpr_write,1  );
     72    DELETE2_SIGNAL( in_GPR_WRITE_STATUS_ACK,_param->_nb_ooo_engine,_param->_nb_gpr_write,1  );
    5673
    57     delete [] out_SPR_READ_REGISTERFILE_VAL  ;
    58     delete []  in_SPR_READ_REGISTERFILE_ACK  ;
    59     delete []  in_SPR_READ_REGISTERFILE_DATA ;
     74    DELETE1_SIGNAL( in_SPR_WRITE_VAL          ,_param->_nb_spr_write,1  );
     75    DELETE1_SIGNAL(out_SPR_WRITE_ACK          ,_param->_nb_spr_write,1  );
     76    DELETE1_SIGNAL( in_SPR_WRITE_OOO_ENGINE_ID,_param->_nb_spr_write,_param->_size_ooo_engine_id);
    6077
    61     delete [] out_SPR_READ_STATUS_VAL        ;
    62     delete []  in_SPR_READ_STATUS_ACK        ;
    63     delete []  in_SPR_READ_STATUS_DATA_VAL   ;
     78    DELETE2_SIGNAL(out_SPR_WRITE_REGISTERFILE_VAL,_param->_nb_ooo_engine,_param->_nb_spr_write,1  );
     79    DELETE2_SIGNAL( in_SPR_WRITE_REGISTERFILE_ACK,_param->_nb_ooo_engine,_param->_nb_spr_write,1  );
    6480
    65     // ~~~~~[ Interface "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    66     delete []  in_GPR_WRITE_VAL               ;
    67     delete [] out_GPR_WRITE_ACK               ;
    68     if (_param->_have_port_ooo_engine_id == true)
    69     delete []  in_GPR_WRITE_OOO_ENGINE_ID     ;
     81    DELETE2_SIGNAL(out_SPR_WRITE_STATUS_VAL,_param->_nb_ooo_engine,_param->_nb_spr_write,1  );
     82    DELETE2_SIGNAL( in_SPR_WRITE_STATUS_ACK,_param->_nb_ooo_engine,_param->_nb_spr_write,1  );
    7083
    71     delete [] out_GPR_WRITE_REGISTERFILE_VAL  ;
    72     delete []  in_GPR_WRITE_REGISTERFILE_ACK  ;
     84    DELETE2_SIGNAL( in_INSERT_ROB_VAL   ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1],1);
     85    DELETE2_SIGNAL(out_INSERT_ROB_ACK   ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1],1);
     86    DELETE2_SIGNAL( in_INSERT_ROB_RD_USE,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1],1);
     87    DELETE2_SIGNAL( in_INSERT_ROB_RE_USE,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1],1);
    7388
    74     delete [] out_GPR_WRITE_STATUS_VAL        ;
    75     delete []  in_GPR_WRITE_STATUS_ACK        ;
     89    DELETE2_SIGNAL(out_INSERT_ROB_GPR_STATUS_VAL,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1],1);
     90    DELETE2_SIGNAL( in_INSERT_ROB_GPR_STATUS_ACK,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1],1);
    7691
    77     // ~~~~~[ Interface "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    78     delete []  in_SPR_WRITE_VAL               ;
    79     delete [] out_SPR_WRITE_ACK               ;
    80     if (_param->_have_port_ooo_engine_id == true)
    81     delete []  in_SPR_WRITE_OOO_ENGINE_ID     ;
    82 
    83     delete [] out_SPR_WRITE_REGISTERFILE_VAL  ;
    84     delete []  in_SPR_WRITE_REGISTERFILE_ACK  ;
    85 
    86     delete [] out_SPR_WRITE_STATUS_VAL        ;
    87     delete []  in_SPR_WRITE_STATUS_ACK        ;
    88 
    89     // ~~~~~[ Interface "insert_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    90     delete []  in_INSERT_ROB_VAL                  ;
    91     delete [] out_INSERT_ROB_ACK                  ;
    92     delete []  in_INSERT_ROB_RD_USE               ;
    93     delete []  in_INSERT_ROB_RE_USE               ;
    94     delete [] out_INSERT_ROB_GPR_STATUS_VAL       ;
    95     delete []  in_INSERT_ROB_GPR_STATUS_ACK       ;
    96     delete [] out_INSERT_ROB_SPR_STATUS_VAL       ;
    97     delete []  in_INSERT_ROB_SPR_STATUS_ACK       ;
    98 
    99 //     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    100 //     delete []  in_RETIRE_ROB_VAL                      ;
    101 //     delete [] out_RETIRE_ROB_ACK                      ;
    102 //     delete []  in_RETIRE_ROB_RD_OLD_USE               ;
    103 //     delete []  in_RETIRE_ROB_RD_NEW_USE               ;
    104 //     delete []  in_RETIRE_ROB_RE_OLD_USE               ;
    105 //     delete []  in_RETIRE_ROB_RE_NEW_USE               ;
    106 //     delete [] out_RETIRE_ROB_GPR_STATUS_OLD_VAL       ;
    107 //     delete [] out_RETIRE_ROB_GPR_STATUS_NEW_VAL       ;
    108 //     delete []  in_RETIRE_ROB_GPR_STATUS_OLD_ACK       ;
    109 //     delete []  in_RETIRE_ROB_GPR_STATUS_NEW_ACK       ;
    110 //     delete [] out_RETIRE_ROB_SPR_STATUS_OLD_VAL       ;
    111 //     delete [] out_RETIRE_ROB_SPR_STATUS_NEW_VAL       ;
    112 //     delete []  in_RETIRE_ROB_SPR_STATUS_OLD_ACK       ;
    113 //     delete []  in_RETIRE_ROB_SPR_STATUS_NEW_ACK       ;
     92    DELETE2_SIGNAL(out_INSERT_ROB_SPR_STATUS_VAL,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1],1);
     93    DELETE2_SIGNAL( in_INSERT_ROB_SPR_STATUS_ACK,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1],1);
    11494      }
    11595    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   

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

    r88 r112  
    77
    88#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/include/Register_unit.h"
     9#include "Behavioural/include/Allocation.h"
    910
    1011namespace morpheo {
    … …  
    5253
    5354    // ~~~~~[ Interface "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    54     in_GPR_READ_VAL                 = new SC_IN (Tcontrol_t        )   * [_param->_nb_gpr_read];
    55     out_GPR_READ_ACK                 = new SC_OUT(Tcontrol_t        )   * [_param->_nb_gpr_read];
    56     if (_param->_have_port_ooo_engine_id == true)
    57       in_GPR_READ_OOO_ENGINE_ID       = new SC_IN (Tcontext_t        )   * [_param->_nb_gpr_read];
    58     in_GPR_READ_NUM_REG             = new SC_IN (Tgeneral_address_t)   * [_param->_nb_gpr_read];
    59     out_GPR_READ_DATA                = new SC_OUT(Tgeneral_data_t   )   * [_param->_nb_gpr_read];
    60     out_GPR_READ_DATA_VAL            = new SC_OUT(Tcontrol_t        )   * [_param->_nb_gpr_read];
    61      
    62     for (uint32_t i=0; i<_param->_nb_gpr_read; i++)
    63       {
    64         Interface_fifo * interface = _interfaces->set_interface("gpr_read_"+toString(i)
    65 #ifdef POSITION
    66                                                                 ,IN
    67                                                                 ,NORTH
    68                                                                 ,"Interface to read the register file"
    69 #endif
    70                                                                 );
    71          
    72         in_GPR_READ_VAL           [i]= interface->set_signal_valack_in  (VAL);
    73         out_GPR_READ_ACK           [i]= interface->set_signal_valack_out (ACK);
    74         if (_param->_have_port_ooo_engine_id == true)
    75           in_GPR_READ_OOO_ENGINE_ID [i]= interface->set_signal_in <Tcontext_t        > ("ooo_engine_id" , _param->_size_ooo_engine_id);
    76         in_GPR_READ_NUM_REG       [i]= interface->set_signal_in <Tgeneral_address_t> ("num_reg"       , _param->_size_gpr_address);
    77         out_GPR_READ_DATA          [i]= interface->set_signal_out<Tgeneral_data_t   > ("data"          , _param->_size_general_data);
    78         out_GPR_READ_DATA_VAL      [i]= interface->set_signal_out<Tcontrol_t        > ("data_val"      , 1);
    79       }
     55    {
     56      ALLOC1_INTERFACE_BEGIN("gpr_read",IN,NORTH,_("Interface to read the register file"),_param->_nb_gpr_read);
     57     
     58      ALLOC1_VALACK_IN ( in_GPR_READ_VAL          ,VAL);
     59      ALLOC1_VALACK_OUT(out_GPR_READ_ACK          ,ACK);
     60      ALLOC1_SIGNAL_IN ( in_GPR_READ_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id);
     61      ALLOC1_SIGNAL_IN ( in_GPR_READ_NUM_REG      ,"num_reg"      ,Tgeneral_address_t,_param->_size_gpr_address);
     62      ALLOC1_SIGNAL_OUT(out_GPR_READ_DATA         ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data);
     63      ALLOC1_SIGNAL_OUT(out_GPR_READ_DATA_VAL     ,"data_val"     ,Tcontrol_t        ,1);
     64
     65      ALLOC1_INTERFACE_END(_param->_nb_gpr_read);
     66    }
    8067
    8168    // ~~~~~[ Interface "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    82     in_GPR_WRITE_VAL                 = new SC_IN (Tcontrol_t        )   * [_param->_nb_gpr_write];
    83     out_GPR_WRITE_ACK                 = new SC_OUT(Tcontrol_t        )   * [_param->_nb_gpr_write];
    84     if (_param->_have_port_ooo_engine_id == true)
    85       in_GPR_WRITE_OOO_ENGINE_ID       = new SC_IN (Tcontext_t        )   * [_param->_nb_gpr_write];
    86     in_GPR_WRITE_NUM_REG             = new SC_IN (Tgeneral_address_t)   * [_param->_nb_gpr_write];
    87     in_GPR_WRITE_DATA                = new SC_IN (Tgeneral_data_t   )   * [_param->_nb_gpr_write];
    88      
    89     for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
    90       {
    91         Interface_fifo * interface = _interfaces->set_interface("gpr_write_"+toString(i)
    92 #ifdef POSITION
    93                                                                 ,IN
    94                                                                 ,NORTH,
    95                                                                 "Interface to write the register file"
    96 #endif
    97                                                                 );
    98          
    99         in_GPR_WRITE_VAL           [i]= interface->set_signal_valack_in  (VAL);
    100         out_GPR_WRITE_ACK           [i]= interface->set_signal_valack_out (ACK);
    101         if (_param->_have_port_ooo_engine_id == true)
    102           in_GPR_WRITE_OOO_ENGINE_ID [i]= interface->set_signal_in <Tcontext_t        > ("ooo_engine_id" , _param->_size_ooo_engine_id);
    103         in_GPR_WRITE_NUM_REG       [i]= interface->set_signal_in <Tgeneral_address_t> ("num_reg"       , _param->_size_gpr_address);
    104         in_GPR_WRITE_DATA          [i]= interface->set_signal_in <Tgeneral_data_t   > ("data"          , _param->_size_general_data);
    105       }
     69    {
     70      ALLOC1_INTERFACE_BEGIN("gpr_write",IN,NORTH,_("Interface to write the register file"),_param->_nb_gpr_write);
     71
     72      ALLOC1_VALACK_IN ( in_GPR_WRITE_VAL          ,VAL);
     73      ALLOC1_VALACK_OUT(out_GPR_WRITE_ACK          ,ACK);
     74      ALLOC1_SIGNAL_IN ( in_GPR_WRITE_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id);
     75      ALLOC1_SIGNAL_IN ( in_GPR_WRITE_NUM_REG      ,"num_reg"      ,Tgeneral_address_t,_param->_size_gpr_address);
     76      ALLOC1_SIGNAL_IN ( in_GPR_WRITE_DATA         ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data);
     77
     78      ALLOC1_INTERFACE_END(_param->_nb_gpr_write);
     79    }
    10680
    10781    // ~~~~~[ Interface "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    108     in_SPR_READ_VAL                 = new SC_IN (Tcontrol_t        )   * [_param->_nb_spr_read];
    109     out_SPR_READ_ACK                 = new SC_OUT(Tcontrol_t        )   * [_param->_nb_spr_read];
    110     if (_param->_have_port_ooo_engine_id == true)
    111       in_SPR_READ_OOO_ENGINE_ID       = new SC_IN (Tcontext_t        )   * [_param->_nb_spr_read];
    112     in_SPR_READ_NUM_REG             = new SC_IN (Tspecial_address_t)   * [_param->_nb_spr_read];
    113     out_SPR_READ_DATA                = new SC_OUT(Tspecial_data_t   )   * [_param->_nb_spr_read];
    114     out_SPR_READ_DATA_VAL            = new SC_OUT(Tcontrol_t        )   * [_param->_nb_spr_read];
    115      
    116     for (uint32_t i=0; i<_param->_nb_spr_read; i++)
    117       {
    118         Interface_fifo * interface = _interfaces->set_interface("spr_read_"+toString(i)
    119 #ifdef POSITION
    120                                                                 ,IN
    121                                                                 ,NORTH,
    122                                                                 "Interface to read the register file"
    123 #endif
    124                                                                 );
    125          
    126         in_SPR_READ_VAL           [i]= interface->set_signal_valack_in  (VAL);
    127         out_SPR_READ_ACK           [i]= interface->set_signal_valack_out (ACK);
    128         if (_param->_have_port_ooo_engine_id == true)
    129           in_SPR_READ_OOO_ENGINE_ID [i]= interface->set_signal_in <Tcontext_t        > ("ooo_engine_id" , _param->_size_ooo_engine_id);
    130         in_SPR_READ_NUM_REG       [i]= interface->set_signal_in <Tspecial_address_t> ("num_reg"       , _param->_size_spr_address);
    131         out_SPR_READ_DATA          [i]= interface->set_signal_out<Tspecial_data_t   > ("data"          , _param->_size_special_data);
    132         out_SPR_READ_DATA_VAL      [i]= interface->set_signal_out<Tcontrol_t        > ("data_val"      , 1);
    133       }
     82    {
     83      ALLOC1_INTERFACE_BEGIN("spr_read",IN,NORTH,_("Interface to read the register file"),_param->_nb_spr_read);
     84     
     85      ALLOC1_VALACK_IN ( in_SPR_READ_VAL          ,VAL);
     86      ALLOC1_VALACK_OUT(out_SPR_READ_ACK          ,ACK);
     87      ALLOC1_SIGNAL_IN ( in_SPR_READ_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id);
     88      ALLOC1_SIGNAL_IN ( in_SPR_READ_NUM_REG      ,"num_reg"      ,Tspecial_address_t,_param->_size_spr_address);
     89      ALLOC1_SIGNAL_OUT(out_SPR_READ_DATA         ,"data"         ,Tspecial_data_t   ,_param->_size_special_data);
     90      ALLOC1_SIGNAL_OUT(out_SPR_READ_DATA_VAL     ,"data_val"     ,Tcontrol_t        ,1);
     91
     92      ALLOC1_INTERFACE_END(_param->_nb_spr_read);
     93    }
    13494
    13595    // ~~~~~[ Interface "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    136     in_SPR_WRITE_VAL                 = new SC_IN (Tcontrol_t        )   * [_param->_nb_spr_write];
    137     out_SPR_WRITE_ACK                 = new SC_OUT(Tcontrol_t        )   * [_param->_nb_spr_write];
    138     if (_param->_have_port_ooo_engine_id == true)
    139       in_SPR_WRITE_OOO_ENGINE_ID       = new SC_IN (Tcontext_t        )   * [_param->_nb_spr_write];
    140     in_SPR_WRITE_NUM_REG             = new SC_IN (Tspecial_address_t)   * [_param->_nb_spr_write];
    141     in_SPR_WRITE_DATA                = new SC_IN (Tspecial_data_t   )   * [_param->_nb_spr_write];
    142      
    143     for (uint32_t i=0; i<_param->_nb_spr_write; i++)
    144       {
    145         Interface_fifo * interface = _interfaces->set_interface("spr_write_"+toString(i)
    146 #ifdef POSITION
    147                                                                 ,IN
    148                                                                 ,NORTH,
    149                                                                 "Interface to write the register file"
    150 #endif
    151                                                                 );
    152          
    153         in_SPR_WRITE_VAL           [i]= interface->set_signal_valack_in  (VAL);
    154         out_SPR_WRITE_ACK           [i]= interface->set_signal_valack_out (ACK);
    155         if (_param->_have_port_ooo_engine_id == true)
    156           in_SPR_WRITE_OOO_ENGINE_ID [i]= interface->set_signal_in <Tcontext_t        > ("ooo_engine_id" , _param->_size_ooo_engine_id);
    157         in_SPR_WRITE_NUM_REG       [i]= interface->set_signal_in <Tspecial_address_t> ("num_reg"       , _param->_size_spr_address);
    158         in_SPR_WRITE_DATA          [i]= interface->set_signal_in <Tspecial_data_t   > ("data"          , _param->_size_special_data);
    159       }
    160 
    161     // ~~~~~[ Interface "insert_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    162     in_INSERT_ROB_VAL        = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    163     out_INSERT_ROB_ACK        = new SC_OUT(Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    164     in_INSERT_ROB_RD_USE     = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    165     in_INSERT_ROB_RD_NUM_REG = new SC_IN (Tgeneral_address_t)  ** [_param->_nb_ooo_engine];
    166     in_INSERT_ROB_RE_USE     = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    167     in_INSERT_ROB_RE_NUM_REG = new SC_IN (Tspecial_address_t)  ** [_param->_nb_ooo_engine];
    168 
    169     for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    170       {
    171         uint32_t x=_param->_nb_inst_insert_rob [i];
    172 
    173         in_INSERT_ROB_VAL        [i] = new SC_IN (Tcontrol_t        )  * [x];
    174         out_INSERT_ROB_ACK        [i] = new SC_OUT(Tcontrol_t        )  * [x];
    175         in_INSERT_ROB_RD_USE     [i] = new SC_IN (Tcontrol_t        )  * [x];
    176         in_INSERT_ROB_RD_NUM_REG [i] = new SC_IN (Tgeneral_address_t)  * [x];
    177         in_INSERT_ROB_RE_USE     [i] = new SC_IN (Tcontrol_t        )  * [x];
    178         in_INSERT_ROB_RE_NUM_REG [i] = new SC_IN (Tspecial_address_t)  * [x];
    179 
    180         for (uint32_t j=0; j<x; j++)
    181           {
    182             Interface_fifo * interface = _interfaces->set_interface("insert_rob_"+toString(i)+"_"+toString(j)
    183 #ifdef POSITION
    184                                                                     ,IN
    185                                                                     ,WEST
    186                                                                     ,"Interface to update status (insert)"
    187 #endif
    188                                                                     );
    189 
    190 
    191             in_INSERT_ROB_VAL        [i][j] = interface->set_signal_valack_in  (VAL);
    192             out_INSERT_ROB_ACK        [i][j] = interface->set_signal_valack_out (ACK);
    193             in_INSERT_ROB_RD_USE     [i][j] = interface->set_signal_in <Tcontrol_t        > ("rd_use"    , 1);
    194             in_INSERT_ROB_RD_NUM_REG [i][j] = interface->set_signal_in <Tgeneral_address_t> ("rd_num_reg", _param->_size_gpr_address);
    195             in_INSERT_ROB_RE_USE     [i][j] = interface->set_signal_in <Tcontrol_t        > ("re_use"    , 1);
    196             in_INSERT_ROB_RE_NUM_REG [i][j] = interface->set_signal_in <Tspecial_address_t> ("re_num_reg", _param->_size_spr_address);
    197              
    198           }
    199       }
     96    {
     97      ALLOC1_INTERFACE_BEGIN("spr_write",IN,NORTH,_("Interface to write the register file"),_param->_nb_spr_write);
     98
     99      ALLOC1_VALACK_IN ( in_SPR_WRITE_VAL          ,VAL);
     100      ALLOC1_VALACK_OUT(out_SPR_WRITE_ACK          ,ACK);
     101      ALLOC1_SIGNAL_IN ( in_SPR_WRITE_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id);
     102      ALLOC1_SIGNAL_IN ( in_SPR_WRITE_NUM_REG      ,"num_reg"      ,Tspecial_address_t,_param->_size_spr_address);
     103      ALLOC1_SIGNAL_IN ( in_SPR_WRITE_DATA         ,"data"         ,Tspecial_data_t   ,_param->_size_special_data);
     104
     105      ALLOC1_INTERFACE_END(_param->_nb_spr_write);
     106    }
     107
     108    // ~~~~~[ Interface "insert_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     109    {
     110      ALLOC2_INTERFACE_BEGIN("insert_rob",IN,WEST,_("Interface to update status (insert)"),_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
     111     
     112      _ALLOC2_VALACK_IN ( in_INSERT_ROB_VAL       ,VAL                                                      ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
     113      _ALLOC2_VALACK_OUT(out_INSERT_ROB_ACK       ,ACK                                                      ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
     114      _ALLOC2_SIGNAL_IN ( in_INSERT_ROB_RD_USE    ,"rd_use"    ,Tcontrol_t        ,1                        ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
     115      _ALLOC2_SIGNAL_IN ( in_INSERT_ROB_RD_NUM_REG,"rd_num_reg",Tgeneral_address_t,_param->_size_gpr_address,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
     116      _ALLOC2_SIGNAL_IN ( in_INSERT_ROB_RE_USE    ,"re_use"    ,Tcontrol_t        ,1                        ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
     117      _ALLOC2_SIGNAL_IN ( in_INSERT_ROB_RE_NUM_REG,"re_num_reg",Tspecial_address_t,_param->_size_spr_address,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
     118     
     119      ALLOC2_INTERFACE_END(_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1]);
     120    }
    200121
    201122//     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

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

    r88 r112  
    77
    88#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/include/Register_unit.h"
     9#include "Behavioural/include/Allocation.h"
    910
    1011namespace morpheo                    {
    … …  
    2425    if (usage_is_set(_usage,USE_SYSTEMC))
    2526      {
    26 //#if defined(STATISTICS) or defined(VHDL_TESTBENCH)
    27     delete     in_CLOCK ;
    28 //#endif
    29     delete     in_NRESET;
     27        delete     in_CLOCK ;
     28        delete     in_NRESET;
    3029
    31     delete []  in_GPR_READ_VAL                 ;
    32     delete [] out_GPR_READ_ACK                 ;
    33     if (_param->_have_port_ooo_engine_id == true)
    34       delete []  in_GPR_READ_OOO_ENGINE_ID       ;
    35     delete []  in_GPR_READ_NUM_REG             ;
    36     delete [] out_GPR_READ_DATA                ;
    37     delete [] out_GPR_READ_DATA_VAL            ;
    38     delete []  in_GPR_WRITE_VAL                ;
    39     delete [] out_GPR_WRITE_ACK                ;
    40     if (_param->_have_port_ooo_engine_id == true)
    41       delete []  in_GPR_WRITE_OOO_ENGINE_ID      ;
    42     delete []  in_GPR_WRITE_NUM_REG            ;
    43     delete []  in_GPR_WRITE_DATA               ;
    44     delete []  in_SPR_READ_VAL                 ;
    45     delete [] out_SPR_READ_ACK                 ;
    46     if (_param->_have_port_ooo_engine_id == true)
    47       delete []  in_SPR_READ_OOO_ENGINE_ID       ;
    48     delete []  in_SPR_READ_NUM_REG             ;
    49     delete [] out_SPR_READ_DATA                ;
    50     delete [] out_SPR_READ_DATA_VAL            ;
    51     delete []  in_SPR_WRITE_VAL                ;
    52     delete [] out_SPR_WRITE_ACK                ;
    53     if (_param->_have_port_ooo_engine_id == true)
    54       delete []  in_SPR_WRITE_OOO_ENGINE_ID      ;
    55     delete []  in_SPR_WRITE_NUM_REG            ;
    56     delete []  in_SPR_WRITE_DATA               ;
    57     delete []  in_INSERT_ROB_VAL               ;
    58     delete [] out_INSERT_ROB_ACK               ;
    59     delete []  in_INSERT_ROB_RD_USE            ;
    60     delete []  in_INSERT_ROB_RD_NUM_REG        ;
    61     delete []  in_INSERT_ROB_RE_USE            ;
    62     delete []  in_INSERT_ROB_RE_NUM_REG        ;
     30        DELETE1_SIGNAL( in_GPR_READ_VAL           ,_param->_nb_gpr_read,1);
     31        DELETE1_SIGNAL(out_GPR_READ_ACK           ,_param->_nb_gpr_read,1);
     32        DELETE1_SIGNAL( in_GPR_READ_OOO_ENGINE_ID ,_param->_nb_gpr_read,_param->_size_ooo_engine_id);
     33        DELETE1_SIGNAL( in_GPR_READ_NUM_REG       ,_param->_nb_gpr_read,_param->_size_gpr_address);
     34        DELETE1_SIGNAL(out_GPR_READ_DATA          ,_param->_nb_gpr_read,_param->_size_general_data);
     35        DELETE1_SIGNAL(out_GPR_READ_DATA_VAL      ,_param->_nb_gpr_read,1);
     36       
     37        DELETE1_SIGNAL( in_GPR_WRITE_VAL          ,_param->_nb_gpr_write,1);
     38        DELETE1_SIGNAL(out_GPR_WRITE_ACK          ,_param->_nb_gpr_write,1);
     39        DELETE1_SIGNAL( in_GPR_WRITE_OOO_ENGINE_ID,_param->_nb_gpr_write,_param->_size_ooo_engine_id);
     40        DELETE1_SIGNAL( in_GPR_WRITE_NUM_REG      ,_param->_nb_gpr_write,_param->_size_gpr_address);
     41        DELETE1_SIGNAL( in_GPR_WRITE_DATA         ,_param->_nb_gpr_write,_param->_size_general_data);
     42
     43        DELETE1_SIGNAL( in_SPR_READ_VAL           ,_param->_nb_spr_read,1);
     44        DELETE1_SIGNAL(out_SPR_READ_ACK           ,_param->_nb_spr_read,1);
     45        DELETE1_SIGNAL( in_SPR_READ_OOO_ENGINE_ID ,_param->_nb_spr_read,_param->_size_ooo_engine_id);
     46        DELETE1_SIGNAL( in_SPR_READ_NUM_REG       ,_param->_nb_spr_read,_param->_size_spr_address);
     47        DELETE1_SIGNAL(out_SPR_READ_DATA          ,_param->_nb_spr_read,_param->_size_special_data);
     48        DELETE1_SIGNAL(out_SPR_READ_DATA_VAL      ,_param->_nb_spr_read,1);
     49       
     50        DELETE1_SIGNAL( in_SPR_WRITE_VAL          ,_param->_nb_spr_write,1);
     51        DELETE1_SIGNAL(out_SPR_WRITE_ACK          ,_param->_nb_spr_write,1);
     52        DELETE1_SIGNAL( in_SPR_WRITE_OOO_ENGINE_ID,_param->_nb_spr_write,_param->_size_ooo_engine_id);
     53        DELETE1_SIGNAL( in_SPR_WRITE_NUM_REG      ,_param->_nb_spr_write,_param->_size_spr_address);
     54        DELETE1_SIGNAL( in_SPR_WRITE_DATA         ,_param->_nb_spr_write,_param->_size_special_data);
     55               
     56        DELETE2_SIGNAL( in_INSERT_ROB_VAL         ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1],1);
     57        DELETE2_SIGNAL(out_INSERT_ROB_ACK         ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1],1);
     58        DELETE2_SIGNAL( in_INSERT_ROB_RD_USE      ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1],1);
     59        DELETE2_SIGNAL( in_INSERT_ROB_RD_NUM_REG  ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1],_param->_size_gpr_address);
     60        DELETE2_SIGNAL( in_INSERT_ROB_RE_USE      ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1],1);
     61        DELETE2_SIGNAL( in_INSERT_ROB_RE_NUM_REG  ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob [it1],_param->_size_spr_address);
     62
    6363//     delete []  in_RETIRE_ROB_VAL               ;
    6464//     delete [] out_RETIRE_ROB_ACK               ;

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

    r97 r112  
    5555    // ~~~~~[ Interface "execute_loop_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    5656     {
    57        ALLOC1_INTERFACE("execute_loop_in", IN, EAST, "Operation's Input", _param->_nb_read_unit);
     57       ALLOC1_INTERFACE_BEGIN("execute_loop_in", IN, EAST, "Operation's Input", _param->_nb_read_unit);
    5858
    5959       ALLOC1_VALACK_IN ( in_EXECUTE_LOOP_IN_VAL,VAL);
    … …  
    6666       ALLOC1_SIGNAL_IN ( in_EXECUTE_LOOP_IN_TYPE                 ,"type"                 ,Ttype_t           ,_param->_size_type);         
    6767       ALLOC1_SIGNAL_IN ( in_EXECUTE_LOOP_IN_STORE_QUEUE_PTR_WRITE,"store_queue_ptr_write",Tlsq_ptr_t        ,_param->_size_store_queue_ptr);
    68        if (_param->_have_port_load_queue_ptr)
    6968       ALLOC1_SIGNAL_IN ( in_EXECUTE_LOOP_IN_LOAD_QUEUE_PTR_WRITE ,"load_queue_ptr_write" ,Tlsq_ptr_t        ,_param->_size_load_queue_ptr);
    7069       ALLOC1_SIGNAL_IN ( in_EXECUTE_LOOP_IN_HAS_IMMEDIAT         ,"has_immediat"         ,Tcontrol_t        ,1);
    … …  
    8079       ALLOC1_SIGNAL_IN ( in_EXECUTE_LOOP_IN_WRITE_RE             ,"write_re"             ,Tcontrol_t        ,1);
    8180       ALLOC1_SIGNAL_IN ( in_EXECUTE_LOOP_IN_NUM_REG_RE           ,"num_reg_re"           ,Tspecial_address_t,_param->_size_special_register);
     81
     82       ALLOC1_INTERFACE_END(param->_nb_read_unit);
    8283     }
    8384    // ~~~~~[ Interface "execute_loop_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    8485     {
    85        ALLOC1_INTERFACE("execute_loop_out",OUT, EAST, "Operation's Output", _param->_nb_write_unit);
     86       ALLOC1_INTERFACE_BEGIN("execute_loop_out",OUT, EAST, "Operation's Output", _param->_nb_write_unit);
    8687
    8788       ALLOC1_VALACK_OUT(out_EXECUTE_LOOP_OUT_VAL,VAL);
    … …  
    9899       ALLOC1_SIGNAL_OUT(out_EXECUTE_LOOP_OUT_ADDRESS      ,"address"      ,Taddress_t     ,_param->_size_instruction_address);
    99100       ALLOC1_SIGNAL_OUT(out_EXECUTE_LOOP_OUT_DATA         ,"data"         ,Tgeneral_data_t,_param->_size_general_data);
     101
     102       ALLOC1_INTERFACE_END(_param->_nb_write_unit);
    100103     }
    101104    // ~~~~~[ Interface "dcache_req" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    102105     {
    103        ALLOC2_INTERFACE("dcache_req",OUT, NORTH, "Data cache port : request", _param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
     106       ALLOC2_INTERFACE_BEGIN("dcache_req",OUT, NORTH, "Data cache port : request", _param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
    104107       
    105108       _ALLOC2_VALACK_OUT(out_DCACHE_REQ_VAL,VAL, _param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
    … …  
    110113       _ALLOC2_SIGNAL_OUT(out_DCACHE_REQ_TYPE      ,"type"      ,Tdcache_type_t   ,_param->_size_dcache_type          , _param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
    111114       _ALLOC2_SIGNAL_OUT(out_DCACHE_REQ_WDATA     ,"wdata"     ,Tdcache_data_t   ,_param->_size_general_data         , _param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
     115
     116       ALLOC2_INTERFACE_END(_param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
    112117     }
     118
    113119    // ~~~~~[ Interface "dcache_rsp" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    114120     {
    115        ALLOC2_INTERFACE("dcache_rsp",IN, NORTH, "Data cache port : respons", _param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
     121       ALLOC2_INTERFACE_BEGIN("dcache_rsp",IN, NORTH, "Data cache port : respons", _param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
    116122
    117123       _ALLOC2_VALACK_IN ( in_DCACHE_RSP_VAL,VAL, _param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
    … …  
    121127       _ALLOC2_SIGNAL_IN ( in_DCACHE_RSP_RDATA     ,"rdata"     ,Tdcache_data_t ,_param->_size_general_data         , _param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
    122128       _ALLOC2_SIGNAL_IN ( in_DCACHE_RSP_ERROR     ,"error"     ,Tdcache_error_t,_param->_size_dcache_error         , _param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
     129
     130       ALLOC2_INTERFACE_END(_param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
    123131     }
     132
    124133    // ~~~~~[ Interface "insert_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    125134     {
    126        ALLOC2_INTERFACE("insert_rob",IN, EAST, "Rename's stage : insert a new instruction in the Re Order Buffer",_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
     135       ALLOC2_INTERFACE_BEGIN("insert_rob",IN, EAST, "Rename's stage : insert a new instruction in the Re Order Buffer",_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
    127136       
    128137       _ALLOC2_VALACK_IN ( in_INSERT_ROB_VAL,VAL,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
    … …  
    133142       _ALLOC2_SIGNAL_IN ( in_INSERT_ROB_RE_USE    ,"re_use"    ,Tcontrol_t        ,1                             ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
    134143       _ALLOC2_SIGNAL_IN ( in_INSERT_ROB_RE_NUM_REG,"re_num_reg",Tspecial_address_t,_param->_size_special_register,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
     144
     145       ALLOC2_INTERFACE_END(_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
    135146     }
     147
    136148//     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    137149//      {
Note: See TracChangeset for help on using the changeset viewer.