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

File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Note: See TracChangeset for help on using the changeset viewer.