Ignore:
Timestamp:
Dec 10, 2008, 7:31:39 PM (16 years ago)
Author:
rosiere
Message:

Almost complete design
with Test and test platform

File:
1 edited

Legend:

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

    r81 r88  
    3838    log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"Begin");
    3939
     40#if DEBUG_Read_unit_to_Execution_unit == true
     41    log_printf(INFO,Read_unit_to_Execution_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
     42
     43    std::cout << *param << std::endl;
     44#endif   
     45
    4046    log_printf(INFO,Read_unit_to_Execution_unit,FUNCTION,"Allocation");
    4147
     
    4753
    4854#ifdef STATISTICS
    49     if (_usage & USE_STATISTICS)
     55    if (usage_is_set(_usage,USE_STATISTICS))
    5056      {
    5157        log_printf(INFO,Read_unit_to_Execution_unit,FUNCTION,"Allocation of statistics");
     
    5662
    5763#ifdef VHDL
    58     if (_usage & USE_VHDL)
     64    if (usage_is_set(_usage,USE_VHDL))
    5965      {
    6066        // generate the vhdl
     
    6672
    6773#ifdef SYSTEMC
    68     if (_usage & USE_SYSTEMC)
     74    if (usage_is_set(_usage,USE_SYSTEMC))
    6975      {
    7076        log_printf(INFO,Read_unit_to_Execution_unit,FUNCTION,"Method - transition");
     
    8591
    8692        for (uint32_t i=0; i<_param->_nb_read_unit; i++)
    87           {
    88             sensitive << (*(in_READ_UNIT_OUT_VAL                   [i]))
    89                       << (*(in_READ_UNIT_OUT_OPERATION             [i]))
    90                       << (*(in_READ_UNIT_OUT_TYPE                  [i]))
    91                       << (*(in_READ_UNIT_OUT_HAS_IMMEDIAT          [i]))
    92                       << (*(in_READ_UNIT_OUT_IMMEDIAT              [i]))
    93                       << (*(in_READ_UNIT_OUT_DATA_RA               [i]))
    94                       << (*(in_READ_UNIT_OUT_DATA_RB               [i]))
    95                       << (*(in_READ_UNIT_OUT_DATA_RC               [i]))
    96                       << (*(in_READ_UNIT_OUT_WRITE_RD              [i]))
    97                       << (*(in_READ_UNIT_OUT_NUM_REG_RD            [i]))
    98                       << (*(in_READ_UNIT_OUT_WRITE_RE              [i]))
    99                       << (*(in_READ_UNIT_OUT_NUM_REG_RE            [i]))
    100                       << (*(in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE [i]));
    101 
    102             if (_param->_have_port_load_queue_ptr)
    103             sensitive  << (*(in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE  [i]));
    104             if (_param->_have_port_context_id)
    105             sensitive  << (*(in_READ_UNIT_OUT_CONTEXT_ID            [i]));
    106             if (_param->_have_port_front_end_id)
    107             sensitive  << (*(in_READ_UNIT_OUT_FRONT_END_ID          [i]));
    108             if (_param->_have_port_ooo_engine_id)
    109             sensitive  << (*(in_READ_UNIT_OUT_OOO_ENGINE_ID         [i]));
    110             if (_param->_have_port_packet_id)
    111             sensitive  << (*(in_READ_UNIT_OUT_PACKET_ID             [i]));
    112           }
     93          for (uint32_t j=0; j<_param->_nb_read_unit_port[i]; j++)
     94            {
     95              sensitive << (*(in_READ_UNIT_OUT_VAL                   [i][j]))
     96                        << (*(in_READ_UNIT_OUT_OPERATION             [i][j]))
     97                        << (*(in_READ_UNIT_OUT_TYPE                  [i][j]))
     98                        << (*(in_READ_UNIT_OUT_HAS_IMMEDIAT          [i][j]))
     99                        << (*(in_READ_UNIT_OUT_IMMEDIAT              [i][j]))
     100                        << (*(in_READ_UNIT_OUT_DATA_RA               [i][j]))
     101                        << (*(in_READ_UNIT_OUT_DATA_RB               [i][j]))
     102                        << (*(in_READ_UNIT_OUT_DATA_RC               [i][j]))
     103                        << (*(in_READ_UNIT_OUT_WRITE_RD              [i][j]))
     104                        << (*(in_READ_UNIT_OUT_NUM_REG_RD            [i][j]))
     105                        << (*(in_READ_UNIT_OUT_WRITE_RE              [i][j]))
     106                        << (*(in_READ_UNIT_OUT_NUM_REG_RE            [i][j]))
     107                        << (*(in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE [i][j]));
     108
     109              if (_param->_have_port_load_queue_ptr)
     110              sensitive  << (*(in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE  [i][j]));
     111              if (_param->_have_port_context_id)
     112              sensitive  << (*(in_READ_UNIT_OUT_CONTEXT_ID            [i][j]));
     113              if (_param->_have_port_front_end_id)
     114              sensitive  << (*(in_READ_UNIT_OUT_FRONT_END_ID          [i][j]));
     115              if (_param->_have_port_ooo_engine_id)
     116              sensitive  << (*(in_READ_UNIT_OUT_OOO_ENGINE_ID         [i][j]));
     117              if (_param->_have_port_rob_ptr  )
     118              sensitive  << (*(in_READ_UNIT_OUT_PACKET_ID             [i][j]));
     119            }
    113120       
    114121        for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
    115           sensitive << (*(in_EXECUTE_UNIT_IN_ACK                 [i]));
     122          for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
     123            sensitive << (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
    116124       
    117125# ifdef SYSTEMCASS_SPECIFIC
    118126        // List dependency information
    119127        for (uint32_t i=0; i<_param->_nb_read_unit; i++)
     128          for (uint32_t j=0; j<_param->_nb_read_unit_port[i]; j++)
    120129          {
    121             (*(out_READ_UNIT_OUT_ACK [i])) (*(in_READ_UNIT_OUT_VAL           [i]));
    122             (*(out_READ_UNIT_OUT_ACK [i])) (*(in_READ_UNIT_OUT_TYPE          [i]));
     130            (*(out_READ_UNIT_OUT_ACK [i][j])) (*(in_READ_UNIT_OUT_VAL           [i][j]));
     131            (*(out_READ_UNIT_OUT_ACK [i][j])) (*(in_READ_UNIT_OUT_TYPE          [i][j]));
    123132            if (_param->_have_port_context_id)
    124             (*(out_READ_UNIT_OUT_ACK [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [i]));
     133            (*(out_READ_UNIT_OUT_ACK [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [i][j]));
    125134            if (_param->_have_port_front_end_id)
    126             (*(out_READ_UNIT_OUT_ACK [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [i]));
     135            (*(out_READ_UNIT_OUT_ACK [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [i][j]));
    127136            if (_param->_have_port_ooo_engine_id)
    128             (*(out_READ_UNIT_OUT_ACK [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [i]));
    129 
    130             for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
    131               (*(out_READ_UNIT_OUT_ACK [i])) (*(in_EXECUTE_UNIT_IN_ACK [j]));
     137            (*(out_READ_UNIT_OUT_ACK [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [i][j]));
     138
     139            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
     140              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
     141              (*(out_READ_UNIT_OUT_ACK [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [x][y]));
    132142          }
    133143
    134144        for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
     145          for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
    135146          {
    136             (*(out_EXECUTE_UNIT_IN_VAL [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
    137 
    138             for (uint32_t j=0; j<_param->_nb_read_unit; j++)
    139               {
    140                 (*(out_EXECUTE_UNIT_IN_VAL [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
    141                 (*(out_EXECUTE_UNIT_IN_VAL [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
    142                 if (_param->_have_port_context_id)
    143                 (*(out_EXECUTE_UNIT_IN_VAL [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
    144                 if (_param->_have_port_front_end_id)
    145                 (*(out_EXECUTE_UNIT_IN_VAL [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
    146                 if (_param->_have_port_ooo_engine_id)
    147                 (*(out_EXECUTE_UNIT_IN_VAL [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
     147            (*(out_EXECUTE_UNIT_IN_VAL [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
     148
     149            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
     150              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
     151              {
     152                (*(out_EXECUTE_UNIT_IN_VAL [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
     153                (*(out_EXECUTE_UNIT_IN_VAL [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
     154                if (_param->_have_port_context_id)
     155                (*(out_EXECUTE_UNIT_IN_VAL [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
     156                if (_param->_have_port_front_end_id)
     157                (*(out_EXECUTE_UNIT_IN_VAL [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
     158                if (_param->_have_port_ooo_engine_id)
     159                (*(out_EXECUTE_UNIT_IN_VAL [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
    148160              }
    149161
    150162            if (_param->_have_port_context_id)
    151163              {
    152             (*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
    153 
    154             for (uint32_t j=0; j<_param->_nb_read_unit; j++)
    155               {
    156                 (*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
    157                 (*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
    158                 if (_param->_have_port_context_id)
    159                 (*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
    160                 if (_param->_have_port_front_end_id)
    161                 (*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
    162                 if (_param->_have_port_ooo_engine_id)
    163                 (*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
     164            (*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
     165
     166            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
     167              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
     168              {
     169                (*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
     170                (*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
     171                if (_param->_have_port_context_id)
     172                (*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
     173                if (_param->_have_port_front_end_id)
     174                (*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
     175                if (_param->_have_port_ooo_engine_id)
     176                (*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
    164177              }
    165178              }
     
    167180            if (_param->_have_port_front_end_id)
    168181              {
    169             (*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
    170 
    171             for (uint32_t j=0; j<_param->_nb_read_unit; j++)
    172               {
    173                 (*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
    174                 (*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
    175                 if (_param->_have_port_context_id)
    176                 (*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
    177                 if (_param->_have_port_front_end_id)
    178                 (*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
    179                 if (_param->_have_port_ooo_engine_id)
    180                 (*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
     182            (*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
     183
     184            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
     185              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
     186              {
     187                (*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
     188                (*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
     189                if (_param->_have_port_context_id)
     190                (*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
     191                if (_param->_have_port_front_end_id)
     192                (*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
     193                if (_param->_have_port_ooo_engine_id)
     194                (*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
    181195              }
    182196              }
     
    184198            if (_param->_have_port_ooo_engine_id)
    185199              {
    186             (*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
    187 
    188             for (uint32_t j=0; j<_param->_nb_read_unit; j++)
    189               {
    190                 (*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
    191                 (*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
    192                 if (_param->_have_port_context_id)
    193                 (*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
    194                 if (_param->_have_port_front_end_id)
    195                 (*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
    196                 if (_param->_have_port_ooo_engine_id)
    197                 (*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
    198               }
    199               }
    200 
    201             if (_param->_have_port_packet_id)
    202               {
    203             (*(out_EXECUTE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
    204 
    205             for (uint32_t j=0; j<_param->_nb_read_unit; j++)
    206               {
    207                 (*(out_EXECUTE_UNIT_IN_PACKET_ID [i])) (*(in_READ_UNIT_OUT_PACKET_ID     [j]));
    208                 (*(out_EXECUTE_UNIT_IN_PACKET_ID [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
    209                 (*(out_EXECUTE_UNIT_IN_PACKET_ID [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
    210                 if (_param->_have_port_context_id)
    211                 (*(out_EXECUTE_UNIT_IN_PACKET_ID [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
    212                 if (_param->_have_port_front_end_id)
    213                 (*(out_EXECUTE_UNIT_IN_PACKET_ID [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
    214                 if (_param->_have_port_ooo_engine_id)
    215                 (*(out_EXECUTE_UNIT_IN_PACKET_ID [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
    216               }
    217               }
    218 
    219             (*(out_EXECUTE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
    220 
    221             for (uint32_t j=0; j<_param->_nb_read_unit; j++)
    222               {
    223                 (*(out_EXECUTE_UNIT_IN_OPERATION [i])) (*(in_READ_UNIT_OUT_OPERATION     [j]));
    224                 (*(out_EXECUTE_UNIT_IN_OPERATION [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
    225                 (*(out_EXECUTE_UNIT_IN_OPERATION [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
    226                 if (_param->_have_port_context_id)
    227                 (*(out_EXECUTE_UNIT_IN_OPERATION [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
    228                 if (_param->_have_port_front_end_id)
    229                 (*(out_EXECUTE_UNIT_IN_OPERATION [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
    230                 if (_param->_have_port_ooo_engine_id)
    231                 (*(out_EXECUTE_UNIT_IN_OPERATION [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
    232               }
    233 
    234             (*(out_EXECUTE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
    235 
    236             for (uint32_t j=0; j<_param->_nb_read_unit; j++)
    237               {
    238                 (*(out_EXECUTE_UNIT_IN_TYPE [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
    239                 (*(out_EXECUTE_UNIT_IN_TYPE [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
    240                 if (_param->_have_port_context_id)
    241                 (*(out_EXECUTE_UNIT_IN_TYPE [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
    242                 if (_param->_have_port_front_end_id)
    243                 (*(out_EXECUTE_UNIT_IN_TYPE [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
    244                 if (_param->_have_port_ooo_engine_id)
    245                 (*(out_EXECUTE_UNIT_IN_TYPE [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
    246               }
    247 
    248             (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
    249 
    250             for (uint32_t j=0; j<_param->_nb_read_unit; j++)
    251               {
    252                 (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE [j]));
    253                 (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_VAL                   [j]));
    254                 (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_TYPE                  [j]));
    255                 if (_param->_have_port_context_id)
    256                 (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID            [j]));
    257                 if (_param->_have_port_front_end_id)
    258                 (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID          [j]));
    259                 if (_param->_have_port_ooo_engine_id)
    260                 (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
     200            (*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
     201
     202            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
     203              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
     204              {
     205                (*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
     206                (*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
     207                if (_param->_have_port_context_id)
     208                (*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
     209                if (_param->_have_port_front_end_id)
     210                (*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
     211                if (_param->_have_port_ooo_engine_id)
     212                (*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
     213              }
     214              }
     215
     216            if (_param->_have_port_rob_ptr  )
     217              {
     218            (*(out_EXECUTE_UNIT_IN_PACKET_ID [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
     219
     220            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
     221              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
     222              {
     223                (*(out_EXECUTE_UNIT_IN_PACKET_ID [i][j])) (*(in_READ_UNIT_OUT_PACKET_ID     [x][y]));
     224                (*(out_EXECUTE_UNIT_IN_PACKET_ID [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
     225                (*(out_EXECUTE_UNIT_IN_PACKET_ID [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
     226                if (_param->_have_port_context_id)
     227                (*(out_EXECUTE_UNIT_IN_PACKET_ID [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
     228                if (_param->_have_port_front_end_id)
     229                (*(out_EXECUTE_UNIT_IN_PACKET_ID [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
     230                if (_param->_have_port_ooo_engine_id)
     231                (*(out_EXECUTE_UNIT_IN_PACKET_ID [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
     232              }
     233              }
     234
     235            (*(out_EXECUTE_UNIT_IN_OPERATION [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
     236
     237            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
     238              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
     239              {
     240                (*(out_EXECUTE_UNIT_IN_OPERATION [i][j])) (*(in_READ_UNIT_OUT_OPERATION     [x][y]));
     241                (*(out_EXECUTE_UNIT_IN_OPERATION [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
     242                (*(out_EXECUTE_UNIT_IN_OPERATION [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
     243                if (_param->_have_port_context_id)
     244                (*(out_EXECUTE_UNIT_IN_OPERATION [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
     245                if (_param->_have_port_front_end_id)
     246                (*(out_EXECUTE_UNIT_IN_OPERATION [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
     247                if (_param->_have_port_ooo_engine_id)
     248                (*(out_EXECUTE_UNIT_IN_OPERATION [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
     249              }
     250
     251            (*(out_EXECUTE_UNIT_IN_TYPE [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
     252
     253            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
     254              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
     255              {
     256                (*(out_EXECUTE_UNIT_IN_TYPE [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
     257                (*(out_EXECUTE_UNIT_IN_TYPE [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
     258                if (_param->_have_port_context_id)
     259                (*(out_EXECUTE_UNIT_IN_TYPE [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
     260                if (_param->_have_port_front_end_id)
     261                (*(out_EXECUTE_UNIT_IN_TYPE [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
     262                if (_param->_have_port_ooo_engine_id)
     263                (*(out_EXECUTE_UNIT_IN_TYPE [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
     264              }
     265
     266            (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
     267
     268            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
     269              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
     270              {
     271                (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE [x][y]));
     272                (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_VAL                   [x][y]));
     273                (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_TYPE                  [x][y]));
     274                if (_param->_have_port_context_id)
     275                (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID            [x][y]));
     276                if (_param->_have_port_front_end_id)
     277                (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID          [x][y]));
     278                if (_param->_have_port_ooo_engine_id)
     279                (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
    261280              }
    262281
    263282            if (_param->_have_port_load_queue_ptr)
    264283              {
    265             (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
    266 
    267             for (uint32_t j=0; j<_param->_nb_read_unit; j++)
    268               {
    269                 (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE [j]));
    270                 (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_VAL                  [j]));
    271                 (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_TYPE                 [j]));
    272                 if (_param->_have_port_context_id)
    273                 (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID           [j]));
    274                 if (_param->_have_port_front_end_id)
    275                 (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID         [j]));
    276                 if (_param->_have_port_ooo_engine_id)
    277                 (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID        [j]));
     284            (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
     285
     286            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
     287              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
     288              {
     289                (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE [x][y]));
     290                (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_VAL                  [x][y]));
     291                (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_TYPE                 [x][y]));
     292                if (_param->_have_port_context_id)
     293                (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID           [x][y]));
     294                if (_param->_have_port_front_end_id)
     295                (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID         [x][y]));
     296                if (_param->_have_port_ooo_engine_id)
     297                (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID        [x][y]));
    278298              }
    279299              }
    280300           
    281             (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
    282 
    283             for (uint32_t j=0; j<_param->_nb_read_unit; j++)
    284               {
    285                 (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_HAS_IMMEDIAT  [j]));
    286                 (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
    287                 (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
    288                 if (_param->_have_port_context_id)
    289                 (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
    290                 if (_param->_have_port_front_end_id)
    291                 (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
    292                 if (_param->_have_port_ooo_engine_id)
    293                 (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
    294               }
    295 
    296             (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
    297 
    298             for (uint32_t j=0; j<_param->_nb_read_unit; j++)
    299               {
    300                 (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_IMMEDIAT      [j]));
    301                 (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
    302                 (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
    303                 if (_param->_have_port_context_id)
    304                 (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
    305                 if (_param->_have_port_front_end_id)
    306                 (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
    307                 if (_param->_have_port_ooo_engine_id)
    308                 (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
    309               }
    310 
    311             (*(out_EXECUTE_UNIT_IN_DATA_RA [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
    312 
    313             for (uint32_t j=0; j<_param->_nb_read_unit; j++)
    314               {
    315                 (*(out_EXECUTE_UNIT_IN_DATA_RA [i])) (*(in_READ_UNIT_OUT_DATA_RA       [j]));
    316                 (*(out_EXECUTE_UNIT_IN_DATA_RA [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
    317                 (*(out_EXECUTE_UNIT_IN_DATA_RA [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
    318                 if (_param->_have_port_context_id)
    319                 (*(out_EXECUTE_UNIT_IN_DATA_RA [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
    320                 if (_param->_have_port_front_end_id)
    321                 (*(out_EXECUTE_UNIT_IN_DATA_RA [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
    322                 if (_param->_have_port_ooo_engine_id)
    323                 (*(out_EXECUTE_UNIT_IN_DATA_RA [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
    324               }
    325 
    326             (*(out_EXECUTE_UNIT_IN_DATA_RB [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
    327 
    328             for (uint32_t j=0; j<_param->_nb_read_unit; j++)
    329               {
    330                 (*(out_EXECUTE_UNIT_IN_DATA_RB [i])) (*(in_READ_UNIT_OUT_DATA_RB       [j]));
    331                 (*(out_EXECUTE_UNIT_IN_DATA_RB [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
    332                 (*(out_EXECUTE_UNIT_IN_DATA_RB [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
    333                 if (_param->_have_port_context_id)
    334                 (*(out_EXECUTE_UNIT_IN_DATA_RB [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
    335                 if (_param->_have_port_front_end_id)
    336                 (*(out_EXECUTE_UNIT_IN_DATA_RB [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
    337                 if (_param->_have_port_ooo_engine_id)
    338                 (*(out_EXECUTE_UNIT_IN_DATA_RB [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
    339               }
    340 
    341             (*(out_EXECUTE_UNIT_IN_DATA_RC [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
    342 
    343             for (uint32_t j=0; j<_param->_nb_read_unit; j++)
    344               {
    345                 (*(out_EXECUTE_UNIT_IN_DATA_RC [i])) (*(in_READ_UNIT_OUT_DATA_RC       [j]));
    346                 (*(out_EXECUTE_UNIT_IN_DATA_RC [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
    347                 (*(out_EXECUTE_UNIT_IN_DATA_RC [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
    348                 if (_param->_have_port_context_id)
    349                 (*(out_EXECUTE_UNIT_IN_DATA_RC [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
    350                 if (_param->_have_port_front_end_id)
    351                 (*(out_EXECUTE_UNIT_IN_DATA_RC [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
    352                 if (_param->_have_port_ooo_engine_id)
    353                 (*(out_EXECUTE_UNIT_IN_DATA_RC [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
    354               }
    355 
    356             (*(out_EXECUTE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
    357 
    358             for (uint32_t j=0; j<_param->_nb_read_unit; j++)
    359               {
    360                 (*(out_EXECUTE_UNIT_IN_WRITE_RD [i])) (*(in_READ_UNIT_OUT_WRITE_RD      [j]));
    361                 (*(out_EXECUTE_UNIT_IN_WRITE_RD [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
    362                 (*(out_EXECUTE_UNIT_IN_WRITE_RD [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
    363                 if (_param->_have_port_context_id)
    364                 (*(out_EXECUTE_UNIT_IN_WRITE_RD [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
    365                 if (_param->_have_port_front_end_id)
    366                 (*(out_EXECUTE_UNIT_IN_WRITE_RD [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
    367                 if (_param->_have_port_ooo_engine_id)
    368                 (*(out_EXECUTE_UNIT_IN_WRITE_RD [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
     301            (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
     302
     303            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
     304              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
     305              {
     306                (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_HAS_IMMEDIAT  [x][y]));
     307                (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
     308                (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
     309                if (_param->_have_port_context_id)
     310                (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
     311                if (_param->_have_port_front_end_id)
     312                (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
     313                if (_param->_have_port_ooo_engine_id)
     314                (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
     315              }
     316
     317            (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
     318
     319            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
     320              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
     321              {
     322                (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_IMMEDIAT      [x][y]));
     323                (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
     324                (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
     325                if (_param->_have_port_context_id)
     326                (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
     327                if (_param->_have_port_front_end_id)
     328                (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
     329                if (_param->_have_port_ooo_engine_id)
     330                (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
     331              }
     332
     333            (*(out_EXECUTE_UNIT_IN_DATA_RA [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
     334
     335            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
     336              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
     337              {
     338                (*(out_EXECUTE_UNIT_IN_DATA_RA [i][j])) (*(in_READ_UNIT_OUT_DATA_RA       [x][y]));
     339                (*(out_EXECUTE_UNIT_IN_DATA_RA [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
     340                (*(out_EXECUTE_UNIT_IN_DATA_RA [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
     341                if (_param->_have_port_context_id)
     342                (*(out_EXECUTE_UNIT_IN_DATA_RA [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
     343                if (_param->_have_port_front_end_id)
     344                (*(out_EXECUTE_UNIT_IN_DATA_RA [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
     345                if (_param->_have_port_ooo_engine_id)
     346                (*(out_EXECUTE_UNIT_IN_DATA_RA [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
     347              }
     348
     349            (*(out_EXECUTE_UNIT_IN_DATA_RB [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
     350
     351            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
     352              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
     353              {
     354                (*(out_EXECUTE_UNIT_IN_DATA_RB [i][j])) (*(in_READ_UNIT_OUT_DATA_RB       [x][y]));
     355                (*(out_EXECUTE_UNIT_IN_DATA_RB [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
     356                (*(out_EXECUTE_UNIT_IN_DATA_RB [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
     357                if (_param->_have_port_context_id)
     358                (*(out_EXECUTE_UNIT_IN_DATA_RB [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
     359                if (_param->_have_port_front_end_id)
     360                (*(out_EXECUTE_UNIT_IN_DATA_RB [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
     361                if (_param->_have_port_ooo_engine_id)
     362                (*(out_EXECUTE_UNIT_IN_DATA_RB [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
     363              }
     364
     365            (*(out_EXECUTE_UNIT_IN_DATA_RC [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
     366
     367            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
     368              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
     369              {
     370                (*(out_EXECUTE_UNIT_IN_DATA_RC [i][j])) (*(in_READ_UNIT_OUT_DATA_RC       [x][y]));
     371                (*(out_EXECUTE_UNIT_IN_DATA_RC [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
     372                (*(out_EXECUTE_UNIT_IN_DATA_RC [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
     373                if (_param->_have_port_context_id)
     374                (*(out_EXECUTE_UNIT_IN_DATA_RC [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
     375                if (_param->_have_port_front_end_id)
     376                (*(out_EXECUTE_UNIT_IN_DATA_RC [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
     377                if (_param->_have_port_ooo_engine_id)
     378                (*(out_EXECUTE_UNIT_IN_DATA_RC [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
     379              }
     380
     381            (*(out_EXECUTE_UNIT_IN_WRITE_RD [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
     382
     383            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
     384              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
     385              {
     386                (*(out_EXECUTE_UNIT_IN_WRITE_RD [i][j])) (*(in_READ_UNIT_OUT_WRITE_RD      [x][y]));
     387                (*(out_EXECUTE_UNIT_IN_WRITE_RD [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
     388                (*(out_EXECUTE_UNIT_IN_WRITE_RD [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
     389                if (_param->_have_port_context_id)
     390                (*(out_EXECUTE_UNIT_IN_WRITE_RD [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
     391                if (_param->_have_port_front_end_id)
     392                (*(out_EXECUTE_UNIT_IN_WRITE_RD [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
     393                if (_param->_have_port_ooo_engine_id)
     394                (*(out_EXECUTE_UNIT_IN_WRITE_RD [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
    369395              }
    370396           
    371             (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
    372 
    373             for (uint32_t j=0; j<_param->_nb_read_unit; j++)
    374               {
    375                 (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i])) (*(in_READ_UNIT_OUT_NUM_REG_RD    [j]));
    376                 (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
    377                 (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
    378                 if (_param->_have_port_context_id)
    379                 (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
    380                 if (_param->_have_port_front_end_id)
    381                 (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
    382                 if (_param->_have_port_ooo_engine_id)
    383                 (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
    384               }
    385 
    386             (*(out_EXECUTE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
    387 
    388             for (uint32_t j=0; j<_param->_nb_read_unit; j++)
    389               {
    390                 (*(out_EXECUTE_UNIT_IN_WRITE_RE [i])) (*(in_READ_UNIT_OUT_WRITE_RE      [j]));
    391                 (*(out_EXECUTE_UNIT_IN_WRITE_RE [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
    392                 (*(out_EXECUTE_UNIT_IN_WRITE_RE [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
    393                 if (_param->_have_port_context_id)
    394                 (*(out_EXECUTE_UNIT_IN_WRITE_RE [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
    395                 if (_param->_have_port_front_end_id)
    396                 (*(out_EXECUTE_UNIT_IN_WRITE_RE [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
    397                 if (_param->_have_port_ooo_engine_id)
    398                 (*(out_EXECUTE_UNIT_IN_WRITE_RE [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
    399               }
    400 
    401             (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
    402 
    403             for (uint32_t j=0; j<_param->_nb_read_unit; j++)
    404               {
    405                 (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i])) (*(in_READ_UNIT_OUT_NUM_REG_RE    [j]));
    406                 (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
    407                 (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
    408                 if (_param->_have_port_context_id)
    409                 (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
    410                 if (_param->_have_port_front_end_id)
    411                 (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
    412                 if (_param->_have_port_ooo_engine_id)
    413                 (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
     397            (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
     398
     399            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
     400              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
     401              {
     402                (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i][j])) (*(in_READ_UNIT_OUT_NUM_REG_RD    [x][y]));
     403                (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
     404                (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
     405                if (_param->_have_port_context_id)
     406                (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
     407                if (_param->_have_port_front_end_id)
     408                (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
     409                if (_param->_have_port_ooo_engine_id)
     410                (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
     411              }
     412
     413            (*(out_EXECUTE_UNIT_IN_WRITE_RE [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
     414
     415            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
     416              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
     417              {
     418                (*(out_EXECUTE_UNIT_IN_WRITE_RE [i][j])) (*(in_READ_UNIT_OUT_WRITE_RE      [x][y]));
     419                (*(out_EXECUTE_UNIT_IN_WRITE_RE [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
     420                (*(out_EXECUTE_UNIT_IN_WRITE_RE [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
     421                if (_param->_have_port_context_id)
     422                (*(out_EXECUTE_UNIT_IN_WRITE_RE [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
     423                if (_param->_have_port_front_end_id)
     424                (*(out_EXECUTE_UNIT_IN_WRITE_RE [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
     425                if (_param->_have_port_ooo_engine_id)
     426                (*(out_EXECUTE_UNIT_IN_WRITE_RE [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
     427              }
     428
     429            (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
     430
     431            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
     432              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
     433              {
     434                (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i][j])) (*(in_READ_UNIT_OUT_NUM_REG_RE    [x][y]));
     435                (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
     436                (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
     437                if (_param->_have_port_context_id)
     438                (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
     439                if (_param->_have_port_front_end_id)
     440                (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
     441                if (_param->_have_port_ooo_engine_id)
     442                (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
    414443              }
    415444          }
     
    428457
    429458#ifdef STATISTICS
    430     if (_usage & USE_STATISTICS)
     459    if (usage_is_set(_usage,USE_STATISTICS))
    431460      {
    432461        log_printf(INFO,Read_unit_to_Execution_unit,FUNCTION,"Generate Statistics file");
Note: See TracChangeset for help on using the changeset viewer.