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

Almost complete design
with Test and test platform

Location:
trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network
Files:
2 added
34 edited

Legend:

Unmodified
Added
Removed

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/Makefile

    r81 r88  
    2424library_clean                   : Execution_unit_to_Write_unit_library_clean
    2525
     26local_clean                     :
     27
    2628include                         $(DIR_COMPONENT)/Makefile.deps
    2729include                         $(DIR_MORPHEO)/Behavioural/Makefile.flags

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/config_min.cfg

    r81 r88  
    11Execution_unit_to_Write_unit
    222       2       *2      # nb_execute_unit       
     31       1       +1      # nb_execute_unit_port [0] [nb_execute_unit]
     41       1       +1      # nb_execute_unit_port [1] [nb_execute_unit]
    351       1       *2      # nb_write_unit           
    461       1       *2      # nb_context             
    … …  
    111316      16      *2      # nb_special_register   
    12140       1       +1      # priority
    13 1       1       +1      # table_routing        [0][0]
    14 1       1       +1      # table_routing        [1][0]
     151       1       +1      # table_routing        [0][0][0]
     161       1       +1      # table_routing        [1][0][0]
    15171       1       +1      # table_execute_thread [0][0]

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

    r81 r88  
    11Execution_unit_to_Write_unit
    224       4       *2      # nb_execute_unit       
     31       1       +1      # nb_execute_unit_port [0] [nb_execute_unit]
     41       1       +1      # nb_execute_unit_port [1] [nb_execute_unit]
     51       1       +1      # nb_execute_unit_port [2] [nb_execute_unit]
     61       1       +1      # nb_execute_unit_port [3] [nb_execute_unit]
    373       3       *2      # nb_write_unit           
    481       1       *2      # nb_context             
    … …  
    111516      16      *2      # nb_special_register   
    12160       1       +1      # priority
    13 1       1       +1      # table_routing [0][0]
    14 0       0       +1      # table_routing [0][1]
    15 0       0       +1      # table_routing [0][2]
    16 0       0       +1      # table_routing [1][0]
    17 1       1       +1      # table_routing [1][1]
    18 1       1       +1      # table_routing [1][2]
    19 0       0       +1      # table_routing [2][0]
    20 0       0       +1      # table_routing [2][1]
    21 1       1       +1      # table_routing [2][2]
    22 1       1       +1      # table_routing [3][0]
    23 1       1       +1      # table_routing [3][1]
    24 1       1       +1      # table_routing [3][2]
     171       1       +1      # table_routing [0][0][0]
     180       0       +1      # table_routing [0][1][0]
     190       0       +1      # table_routing [0][2][0]
     200       0       +1      # table_routing [1][0][0]
     211       1       +1      # table_routing [1][1][0]
     221       1       +1      # table_routing [1][2][0]
     230       0       +1      # table_routing [2][0][0]
     240       0       +1      # table_routing [2][1][0]
     251       1       +1      # table_routing [2][2][0]
     261       1       +1      # table_routing [3][0][0]
     271       1       +1      # table_routing [3][1][0]
     281       1       +1      # table_routing [3][2][0]
    25291       1       +1      # table_thread  [0][0]
    26301       1       +1      # table_thread  [1][0]

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

    r81 r88  
    11Execution_unit_to_Write_unit
    224       4       *2      # nb_execute_unit       
     31       1       +1      # nb_execute_unit_port [0] [nb_execute_unit]
     41       1       +1      # nb_execute_unit_port [1] [nb_execute_unit]
     51       1       +1      # nb_execute_unit_port [2] [nb_execute_unit]
     61       1       +1      # nb_execute_unit_port [3] [nb_execute_unit]
    373       3       *2      # nb_write_unit           
    482       2       *2      # nb_context             
    … …  
    111516      16      *2      # nb_special_register   
    12160       1       +1      # priority
    13 1       1       +1      # table_routing [0][0]
    14 0       0       +1      # table_routing [0][1]
    15 0       0       +1      # table_routing [0][2]
    16 0       0       +1      # table_routing [1][0]
    17 1       1       +1      # table_routing [1][1]
    18 1       1       +1      # table_routing [1][2]
    19 0       0       +1      # table_routing [2][0]
    20 0       0       +1      # table_routing [2][1]
    21 1       1       +1      # table_routing [2][2]
    22 1       1       +1      # table_routing [3][0]
    23 1       1       +1      # table_routing [3][1]
    24 1       1       +1      # table_routing [3][2]
     171       1       +1      # table_routing [0][0][0]
     180       0       +1      # table_routing [0][1][0]
     190       0       +1      # table_routing [0][2][0]
     200       0       +1      # table_routing [1][0][0]
     211       1       +1      # table_routing [1][1][0]
     221       1       +1      # table_routing [1][2][0]
     230       0       +1      # table_routing [2][0][0]
     240       0       +1      # table_routing [2][1][0]
     251       1       +1      # table_routing [2][2][0]
     261       1       +1      # table_routing [3][0][0]
     271       1       +1      # table_routing [3][1][0]
     281       1       +1      # table_routing [3][2][0]
    25291       1       +1      # table_thread  [0][0]
    26300       0       +1      # table_thread  [0][1]

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

    r81 r88  
    1515#include <sys/time.h>
    1616
     17#define NB_ITERATION  1
     18#define CYCLE_MAX     (128*NB_ITERATION)
     19
    1720#include "Common/include/Time.h"
    1821#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/include/Execution_unit_to_Write_unit.h"
     22#include "Common/include/Test.h"
    1923
    2024using namespace std;

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

    r81 r88  
    1414  err (_("<Usage> %s name_instance list_params.\n"),argv[0]);
    1515  err (_("list_params is :\n"));
    16   err (_("  * nb_execute_unit                                (uint32_t)\n"));
    17   err (_("  * nb_write_unit                                  (uint32_t)\n"));
    18   err (_("  * nb_context                                     (uint32_t)\n"));
    19   err (_("  * nb_front_end                                   (uint32_t)\n"));
    20   err (_("  * nb_ooo_engine                                  (uint32_t)\n"));
    21   err (_("  * nb_packet                                      (uint32_t)\n"));
    22   err (_("  * size_general_data                              (uint32_t)\n"));
    23   err (_("  * size_special_data                              (uint32_t)\n"));
    24   err (_("  * nb_general_register                            (uint32_t)\n"));
    25   err (_("  * nb_special_register                            (uint32_t)\n"));
    26   err (_("  * priority                                       (uint32_t)\n"));
    27   err (_("  * table_routing [nb_execute_unit][nb_write_unit] (bool    )\n"));
    28   err (_("  * table_thread  [nb_write_unit][nb_thread]       (bool    )\n"));
     16  err (_("  * nb_execute_unit                                                      (uint32_t)\n"));
     17  err (_("  * nb_execute_unit_port [nb_execute_unit]                               (uint32_t)\n"));
     18  err (_("  * nb_write_unit                                                        (uint32_t)\n"));
     19  err (_("  * nb_context                                                           (uint32_t)\n"));
     20  err (_("  * nb_front_end                                                         (uint32_t)\n"));
     21  err (_("  * nb_ooo_engine                                                        (uint32_t)\n"));
     22  err (_("  * nb_packet                                                            (uint32_t)\n"));
     23  err (_("  * size_general_data                                                    (uint32_t)\n"));
     24  err (_("  * size_special_data                                                    (uint32_t)\n"));
     25  err (_("  * nb_general_register                                                  (uint32_t)\n"));
     26  err (_("  * nb_special_register                                                  (uint32_t)\n"));
     27  err (_("  * priority                                                             (uint32_t)\n"));
     28  err (_("  * table_routing [nb_execute_unit][nb_execute_unit_port][nb_write_unit] (bool    )\n"));
     29  err (_("  * table_thread  [nb_write_unit][nb_thread]                             (bool    )\n"));
    2930
    3031  exit (1);
    … …  
    4344
    4445  const string   name      =      argv[x++];
    45   uint32_t    _nb_execute_unit      = atoi(argv[x++]);
    46   uint32_t    _nb_write_unit        = atoi(argv[x++]);
    47   uint32_t    _nb_context           = atoi(argv[x++]);
    48   uint32_t    _nb_front_end         = atoi(argv[x++]);
    49   uint32_t    _nb_ooo_engine        = atoi(argv[x++]);
    50   uint32_t    _nb_packet            = atoi(argv[x++]);
    51   uint32_t    _size_general_data    = atoi(argv[x++]);
    52   uint32_t    _size_special_data    = atoi(argv[x++]);
    53   uint32_t    _nb_general_register  = atoi(argv[x++]);
    54   uint32_t    _nb_special_register  = atoi(argv[x++]);
     46  uint32_t    _nb_execute_unit      = fromString<uint32_t>(argv[x++]);
     47
     48  if (static_cast<uint32_t>(argc) <= 2+NB_PARAMS+_nb_execute_unit)
     49    usage (argc, argv);
     50
     51  uint32_t    _sum_execute_unit_port = 0;
     52  uint32_t *  _nb_execute_unit_port = new uint32_t [_nb_execute_unit];
     53  for (uint32_t i=0; i<_nb_execute_unit; i++)
     54    {
     55      _nb_execute_unit_port [i] = fromString<uint32_t>(argv[x++]);
     56      _sum_execute_unit_port += _nb_execute_unit_port [i];
     57    }
     58
     59  uint32_t    _nb_write_unit        = fromString<uint32_t>(argv[x++]);
     60  uint32_t    _nb_context           = fromString<uint32_t>(argv[x++]);
     61  uint32_t    _nb_front_end         = fromString<uint32_t>(argv[x++]);
     62  uint32_t    _nb_ooo_engine        = fromString<uint32_t>(argv[x++]);
     63  uint32_t    _nb_packet            = fromString<uint32_t>(argv[x++]);
     64  uint32_t    _size_general_data    = fromString<uint32_t>(argv[x++]);
     65  uint32_t    _size_special_data    = fromString<uint32_t>(argv[x++]);
     66  uint32_t    _nb_general_register  = fromString<uint32_t>(argv[x++]);
     67  uint32_t    _nb_special_register  = fromString<uint32_t>(argv[x++]);
    5568  Tpriority_t _priority             = fromString<Tpriority_t>(argv[x++]);
    5669
    5770  uint32_t    _nb_thread            = get_nb_thread(_nb_context, _nb_front_end, _nb_ooo_engine);
    5871
    59   if (static_cast<uint32_t>(argc) != 2+NB_PARAMS+(_nb_write_unit*_nb_execute_unit)+(_nb_write_unit*_nb_thread))
     72  if (static_cast<uint32_t>(argc) != 2+NB_PARAMS+_nb_execute_unit+(_nb_write_unit*_sum_execute_unit_port)+(_nb_write_unit*_nb_thread))
    6073    usage (argc, argv);
    6174 
    62   bool ** _table_routing;
    63   bool ** _table_thread ;
     75  bool *** _table_routing;
     76  bool  ** _table_thread ;
    6477 
    65   _table_routing = new bool * [_nb_execute_unit];
     78  _table_routing = new bool ** [_nb_execute_unit];
    6679  for (uint32_t i=0; i<_nb_execute_unit; i++)
    6780    {
    68       _table_routing [i] = new bool [_nb_write_unit];
    69       for (uint32_t j=0; j<_nb_write_unit; j++)
    70         _table_routing [i][j] = atoi(argv[x++]);
     81      _table_routing [i] = new bool * [_nb_execute_unit_port [i]];
     82      for (uint32_t j=0; j<_nb_execute_unit_port [i]; j++)
     83        {
     84          _table_routing [i][j] = new bool [_nb_write_unit];
     85          for (uint32_t k=0; k<_nb_write_unit; k++)
     86            _table_routing [i][j][k] = fromString<bool>(argv[x++]);
     87        }
    7188    }
    7289
    … …  
    7794
    7895      for (uint32_t j=0; j<_nb_thread; j++)
    79         _table_thread [i][j] = atoi(argv[x++]);
     96        _table_thread [i][j] = fromString<bool>(argv[x++]);
    8097    }
    8198
     99  int _return = EXIT_SUCCESS;
    82100  try
    83101    {
    84102      morpheo::behavioural::core::multi_execute_loop::execute_loop::network::execution_unit_to_write_unit::Parameters * param = new morpheo::behavioural::core::multi_execute_loop::execute_loop::network::execution_unit_to_write_unit::Parameters
    85103        (_nb_execute_unit      ,
     104         _nb_execute_unit_port ,
    86105         _nb_write_unit        ,
    87106         _nb_context           ,
    … …  
    95114         _priority             ,
    96115         _table_routing        ,
    97          _table_thread
     116         _table_thread         ,
     117         true //is_toplevel
    98118         );
    99119     
    100       msg(_("%s"),param->print(1).c_str());
     120      msg(_("%s"),param->print(0).c_str());
    101121     
    102122      test (name,param);
    … …  
    104124  catch (morpheo::ErrorMorpheo & error)
    105125    {
    106       msg (_("<%s> : %s.\n"),name.c_str(), error.what ());
    107       exit (EXIT_FAILURE);
     126      msg (_("<%s> :\n%s"),name.c_str(), error.what ());
     127      _return = EXIT_FAILURE;
    108128    }
    109   catch (...)
     129 
     130  try
    110131    {
    111       err (_("<%s> : This test must generate a error.\n"),name.c_str());
    112       exit (EXIT_FAILURE);
     132      if (_return == EXIT_SUCCESS)
     133        TEST_OK("Execution_unit_to_Write_unit : no error");
     134      else
     135        TEST_KO("Execution_unit_to_Write_unit : a lot of error");
     136    }
     137  catch (morpheo::ErrorMorpheo & error)
     138    {
     139//       msg (_("<%s> :\n%s"),name.c_str(), error.what ());
     140      _return = EXIT_FAILURE;
    113141    }
    114142

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

    r82 r88  
    77 */
    88
    9 #define NB_ITERATION  1
    10 #define CYCLE_MAX     (128*NB_ITERATION)
    11 
    129#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/include/test.h"
    13 #include "Common/include/Test.h"
    1410#include "Common/include/BitManipulation.h"
    1511#include "Behavioural/include/Allocation.h"
    … …  
    7874#endif
    7975
     76  Tusage_t _usage = USE_ALL;
     77
     78//   _usage = usage_unset(_usage,USE_SYSTEMC              );
     79//   _usage = usage_unset(_usage,USE_VHDL                 );
     80//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
     81//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
     82//   _usage = usage_unset(_usage,USE_POSITION             );
     83   _usage = usage_unset(_usage,USE_STATISTICS           );
     84//   _usage = usage_unset(_usage,USE_INFORMATION          );
     85
    8086  Execution_unit_to_Write_unit * _Execution_unit_to_Write_unit = new Execution_unit_to_Write_unit
    8187    (name.c_str(),
    … …  
    8490#endif
    8591     _param,
    86      USE_ALL);
     92     _usage);
    8793 
    8894#ifdef SYSTEMC
    … …  
    95101  sc_signal<Tcontrol_t> *  in_NRESET = new sc_signal<Tcontrol_t> ("NRESET");
    96102
    97   ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_VAL          ," in_EXECUTE_UNIT_OUT_VAL          ",Tcontrol_t        ,_param->_nb_execute_unit);
    98   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_OUT_ACK          ,"out_EXECUTE_UNIT_OUT_ACK          ",Tcontrol_t        ,_param->_nb_execute_unit);
    99   ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_CONTEXT_ID   ," in_EXECUTE_UNIT_OUT_CONTEXT_ID   ",Tcontext_t        ,_param->_nb_execute_unit);
    100   ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_FRONT_END_ID ," in_EXECUTE_UNIT_OUT_FRONT_END_ID ",Tcontext_t        ,_param->_nb_execute_unit);
    101   ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID," in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID",Tcontext_t        ,_param->_nb_execute_unit);
    102   ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_PACKET_ID    ," in_EXECUTE_UNIT_OUT_PACKET_ID    ",Tpacket_t         ,_param->_nb_execute_unit);
    103 //ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_OPERATION    ," in_EXECUTE_UNIT_OUT_OPERATION    ",Toperation_t      ,_param->_nb_execute_unit);
    104   ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_TYPE         ," in_EXECUTE_UNIT_OUT_TYPE         ",Ttype_t           ,_param->_nb_execute_unit);
    105   ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_WRITE_RD     ," in_EXECUTE_UNIT_OUT_WRITE_RD     ",Tcontrol_t        ,_param->_nb_execute_unit);
    106   ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_NUM_REG_RD   ," in_EXECUTE_UNIT_OUT_NUM_REG_RD   ",Tgeneral_address_t,_param->_nb_execute_unit);
    107   ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_DATA_RD      ," in_EXECUTE_UNIT_OUT_DATA_RD      ",Tgeneral_data_t   ,_param->_nb_execute_unit);
    108   ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_WRITE_RE     ," in_EXECUTE_UNIT_OUT_WRITE_RE     ",Tcontrol_t        ,_param->_nb_execute_unit);
    109   ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_NUM_REG_RE   ," in_EXECUTE_UNIT_OUT_NUM_REG_RE   ",Tspecial_address_t,_param->_nb_execute_unit);
    110   ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_DATA_RE      ," in_EXECUTE_UNIT_OUT_DATA_RE      ",Tspecial_data_t   ,_param->_nb_execute_unit);
    111   ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_EXCEPTION    ," in_EXECUTE_UNIT_OUT_EXCEPTION    ",Texception_t      ,_param->_nb_execute_unit);
    112   ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ," in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ",Tcontrol_t        ,_param->_nb_execute_unit);
    113   ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_ADDRESS      ," in_EXECUTE_UNIT_OUT_ADDRESS      ",Tgeneral_data_t   ,_param->_nb_execute_unit);
     103  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_VAL          ," in_EXECUTE_UNIT_OUT_VAL          ",Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     104  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_OUT_ACK          ,"out_EXECUTE_UNIT_OUT_ACK          ",Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     105  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_CONTEXT_ID   ," in_EXECUTE_UNIT_OUT_CONTEXT_ID   ",Tcontext_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     106  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_FRONT_END_ID ," in_EXECUTE_UNIT_OUT_FRONT_END_ID ",Tcontext_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     107  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID," in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID",Tcontext_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     108  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_PACKET_ID    ," in_EXECUTE_UNIT_OUT_PACKET_ID    ",Tpacket_t         ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     109//ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_OPERATION    ," in_EXECUTE_UNIT_OUT_OPERATION    ",Toperation_t      ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     110  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_TYPE         ," in_EXECUTE_UNIT_OUT_TYPE         ",Ttype_t           ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     111  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_WRITE_RD     ," in_EXECUTE_UNIT_OUT_WRITE_RD     ",Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     112  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_NUM_REG_RD   ," in_EXECUTE_UNIT_OUT_NUM_REG_RD   ",Tgeneral_address_t,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     113  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_DATA_RD      ," in_EXECUTE_UNIT_OUT_DATA_RD      ",Tgeneral_data_t   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     114  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_WRITE_RE     ," in_EXECUTE_UNIT_OUT_WRITE_RE     ",Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     115  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_NUM_REG_RE   ," in_EXECUTE_UNIT_OUT_NUM_REG_RE   ",Tspecial_address_t,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     116  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_DATA_RE      ," in_EXECUTE_UNIT_OUT_DATA_RE      ",Tspecial_data_t   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     117  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_EXCEPTION    ," in_EXECUTE_UNIT_OUT_EXCEPTION    ",Texception_t      ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     118  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ," in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ",Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     119  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_ADDRESS      ," in_EXECUTE_UNIT_OUT_ADDRESS      ",Tgeneral_data_t   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     120
    114121  ALLOC1_SC_SIGNAL(out_WRITE_UNIT_IN_VAL             ,"out_WRITE_UNIT_IN_VAL             ",Tcontrol_t        ,_param->_nb_write_unit  );
    115122  ALLOC1_SC_SIGNAL( in_WRITE_UNIT_IN_ACK             ," in_WRITE_UNIT_IN_ACK             ",Tcontrol_t        ,_param->_nb_write_unit  );
    … …  
    139146  (*(_Execution_unit_to_Write_unit->in_NRESET))       (*(in_NRESET));
    140147
    141   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_VAL          ,_param->_nb_execute_unit);
    142   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit,out_EXECUTE_UNIT_OUT_ACK          ,_param->_nb_execute_unit);
     148  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_VAL          ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     149  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit,out_EXECUTE_UNIT_OUT_ACK          ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
    143150  if (_param->_have_port_context_id)
    144   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_CONTEXT_ID   ,_param->_nb_execute_unit);
     151  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_CONTEXT_ID   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
    145152  if (_param->_have_port_front_end_id)
    146   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_FRONT_END_ID ,_param->_nb_execute_unit);
     153  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_FRONT_END_ID ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
    147154  if (_param->_have_port_ooo_engine_id)
    148   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID,_param->_nb_execute_unit);
    149   if (_param->_have_port_packet_id)
    150   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_PACKET_ID    ,_param->_nb_execute_unit);
    151 //INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_OPERATION    ,_param->_nb_execute_unit);
    152   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_TYPE         ,_param->_nb_execute_unit);
    153   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_WRITE_RD     ,_param->_nb_execute_unit);
    154   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_NUM_REG_RD   ,_param->_nb_execute_unit);
    155   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_DATA_RD      ,_param->_nb_execute_unit);
    156   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_WRITE_RE     ,_param->_nb_execute_unit);
    157   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_NUM_REG_RE   ,_param->_nb_execute_unit);
    158   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_DATA_RE      ,_param->_nb_execute_unit);
    159   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_EXCEPTION    ,_param->_nb_execute_unit);
    160   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ,_param->_nb_execute_unit);
    161   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_ADDRESS      ,_param->_nb_execute_unit);
     155  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     156  if (_param->_have_port_rob_ptr  )
     157  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_PACKET_ID    ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     158//INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_OPERATION    ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     159  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_TYPE         ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     160  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_WRITE_RD     ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     161  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_NUM_REG_RD   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     162  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_DATA_RD      ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     163  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_WRITE_RE     ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     164  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_NUM_REG_RE   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     165  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_DATA_RE      ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     166  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_EXCEPTION    ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     167  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     168  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_ADDRESS      ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
    162169
    163170  INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit,out_WRITE_UNIT_IN_VAL             ,_param->_nb_write_unit  );
    … …  
    169176  if (_param->_have_port_ooo_engine_id)
    170177  INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit,out_WRITE_UNIT_IN_OOO_ENGINE_ID   ,_param->_nb_write_unit  );
    171   if (_param->_have_port_packet_id)
     178  if (_param->_have_port_rob_ptr  )
    172179  INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit,out_WRITE_UNIT_IN_PACKET_ID       ,_param->_nb_write_unit  );
    173180//INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit,out_WRITE_UNIT_IN_OPERATION       ,_param->_nb_write_unit  );
    … …  
    201208  const  int32_t percent_transaction_out = 75;
    202209
    203   set<Tcontext_t> execute_unit_thread [_param->_nb_execute_unit];
     210  set<Tcontext_t> execute_unit_thread [_param->_nb_execute_unit][_param->_max_nb_execute_unit_port];
    204211 
    205212  for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
    206     for (uint32_t j=0; j<_param->_nb_write_unit; j++)
    207       if (_param->_table_routing[i][j])
    208         for (uint32_t k=0; k<_param->_nb_thread; k++)
    209           if (_param->_table_thread[j][k])
    210             {
    211               execute_unit_thread [i].insert(k);
    212             }
     213    for (uint32_t ii=0; ii<_param->_nb_execute_unit_port[i]; ii++)
     214      for (uint32_t j=0; j<_param->_nb_write_unit; j++)
     215        if (_param->_table_routing[i][ii][j])
     216          for (uint32_t k=0; k<_param->_nb_thread; k++)
     217            if (_param->_table_thread[j][k])
     218              {
     219                execute_unit_thread [i][ii].insert(k);
     220              }
     221
    213222  SC_START(0);
    214223  LABEL("Initialisation");
    … …  
    225234      LABEL("Iteration %d",iteration);
    226235
    227       list<entry_t> request [_param->_nb_execute_unit];
     236      list<entry_t> request [_param->_nb_execute_unit][_param->_max_nb_execute_unit_port];
    228237
    229238      uint32_t nb_request_in;
    230239      for (nb_request_in=0; nb_request_in < _param->_nb_packet; )
    231240        for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
    232           {
    233             if (nb_request_in >= _param->_nb_packet)
    234               break;
    235 
    236             Tcontext_t context_id   ;
    237             Tcontext_t front_end_id ;
    238             Tcontext_t ooo_engine_id;
    239             Tcontext_t num_thread   ;
    240 
    241             // Find compatible thread
    242             do
    243               {
    244                 context_id    = range<Tcontext_t> (rand(), _param->_size_context_id   );
    245                 front_end_id  = range<Tcontext_t> (rand(), _param->_size_front_end_id );
    246                 ooo_engine_id = range<Tcontext_t> (rand(), _param->_size_ooo_engine_id);
    247                 num_thread    = get_num_thread (context_id   , _param->_size_context_id   ,
    248                                                 front_end_id , _param->_size_front_end_id ,
    249                                                 ooo_engine_id, _param->_size_ooo_engine_id);
    250               }
    251             while (execute_unit_thread[i].find(num_thread) == execute_unit_thread[i].end());
    252 
    253             request[i].push_back(entry_t (context_id   ,
    254                                           front_end_id ,
    255                                           ooo_engine_id,
    256                                           nb_request_in,
    257                                           //range<Toperation_t      > (rand(), _param->_size_operation       ),
    258                                           range<Ttype_t           > (rand(), _param->_size_type            ),
    259                                           range<Tcontrol_t        > (rand(), 2                             ),
    260                                           range<Tgeneral_address_t> (rand(), _param->_size_general_register),
    261                                           range<Tgeneral_data_t   > (rand(), _param->_size_general_data    ),
    262                                           range<Tcontrol_t        > (rand(), 2                             ),
    263                                           range<Tspecial_address_t> (rand(), _param->_size_special_register),
    264                                           range<Tspecial_data_t   > (rand(), _param->_size_special_data    ),
    265                                           range<Texception_t      > (rand(), _param->_size_exception       ),
    266                                           range<Tcontrol_t        > (rand(), 2                             ),
    267                                           range<Tgeneral_data_t   > (rand(), _param->_size_general_data    )
    268                                           ));
    269 
    270             nb_request_in++;
    271           }
     241          for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
     242            {
     243              if (nb_request_in >= _param->_nb_packet)
     244                break;
     245             
     246              Tcontext_t context_id   ;
     247              Tcontext_t front_end_id ;
     248              Tcontext_t ooo_engine_id;
     249              Tcontext_t num_thread   ;
     250             
     251              // Find compatible thread
     252              do
     253                {
     254                  context_id    = range<Tcontext_t> (rand(), _param->_size_context_id   );
     255                  front_end_id  = range<Tcontext_t> (rand(), _param->_size_front_end_id );
     256                  ooo_engine_id = range<Tcontext_t> (rand(), _param->_size_ooo_engine_id);
     257                  num_thread    = get_num_thread (context_id   , _param->_size_context_id   ,
     258                                                  front_end_id , _param->_size_front_end_id ,
     259                                                  ooo_engine_id, _param->_size_ooo_engine_id);
     260                }
     261              while (execute_unit_thread[i][j].find(num_thread) == execute_unit_thread[i][j].end());
     262             
     263              request[i][j].push_back(entry_t (context_id   ,
     264                                               front_end_id ,
     265                                               ooo_engine_id,
     266                                               nb_request_in,
     267                                               //range<Toperation_t      > (rand(), _param->_size_operation       ),
     268                                               range<Ttype_t           > (rand(), _param->_size_type            ),
     269                                               range<Tcontrol_t        > (rand(), 2                             ),
     270                                               range<Tgeneral_address_t> (rand(), _param->_size_general_register),
     271                                               range<Tgeneral_data_t   > (rand(), _param->_size_general_data    ),
     272                                               range<Tcontrol_t        > (rand(), 2                             ),
     273                                               range<Tspecial_address_t> (rand(), _param->_size_special_register),
     274                                               range<Tspecial_data_t   > (rand(), _param->_size_special_data    ),
     275                                               range<Texception_t      > (rand(), _param->_size_exception       ),
     276                                               range<Tcontrol_t        > (rand(), 2                             ),
     277                                               range<Tgeneral_data_t   > (rand(), _param->_size_general_data    )
     278                                               ));
     279             
     280              nb_request_in++;
     281            }
    272282
    273283      uint32_t   nb_request_out = 0;
    … …  
    276286        {
    277287          for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
    278             {
    279               bool val = not request[i].empty() and ((rand()%100) < percent_transaction_in);
     288            for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
     289              {
     290                bool val = not request[i][j].empty() and ((rand()%100) < percent_transaction_in);
    280291               
    281               in_EXECUTE_UNIT_OUT_VAL [i]->write(val);
    282 
    283               if (val)
    284                 {
    285                   in_EXECUTE_UNIT_OUT_CONTEXT_ID           [i] ->write(request[i].front()._context_id           );
    286                   in_EXECUTE_UNIT_OUT_FRONT_END_ID         [i] ->write(request[i].front()._front_end_id         );
    287                   in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID        [i] ->write(request[i].front()._ooo_engine_id        );
    288                   in_EXECUTE_UNIT_OUT_PACKET_ID            [i] ->write(request[i].front()._packet_id            );
    289 //                in_EXECUTE_UNIT_OUT_OPERATION            [i] ->write(request[i].front()._operation            );
    290                   in_EXECUTE_UNIT_OUT_TYPE                 [i] ->write(request[i].front()._type                 );
    291                   in_EXECUTE_UNIT_OUT_WRITE_RD             [i] ->write(request[i].front()._write_rd             );
    292                   in_EXECUTE_UNIT_OUT_NUM_REG_RD           [i] ->write(request[i].front()._num_reg_rd           );
    293                   in_EXECUTE_UNIT_OUT_DATA_RD              [i] ->write(request[i].front()._data_rd              );
    294                   in_EXECUTE_UNIT_OUT_WRITE_RE             [i] ->write(request[i].front()._write_re             );
    295                   in_EXECUTE_UNIT_OUT_NUM_REG_RE           [i] ->write(request[i].front()._num_reg_re           );
    296                   in_EXECUTE_UNIT_OUT_DATA_RE              [i] ->write(request[i].front()._data_re              );
    297                   in_EXECUTE_UNIT_OUT_EXCEPTION            [i] ->write(request[i].front()._exception            );
    298                   in_EXECUTE_UNIT_OUT_NO_SEQUENCE          [i] ->write(request[i].front()._no_sequence          );
    299                   in_EXECUTE_UNIT_OUT_ADDRESS              [i] ->write(request[i].front()._address              );
    300                 }
    301             }
     292                in_EXECUTE_UNIT_OUT_VAL [i][j]->write(val);
     293               
     294                if (val)
     295                  {
     296                    in_EXECUTE_UNIT_OUT_CONTEXT_ID           [i][j] ->write(request[i][j].front()._context_id           );
     297                    in_EXECUTE_UNIT_OUT_FRONT_END_ID         [i][j] ->write(request[i][j].front()._front_end_id         );
     298                    in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID        [i][j] ->write(request[i][j].front()._ooo_engine_id        );
     299                    in_EXECUTE_UNIT_OUT_PACKET_ID            [i][j] ->write(request[i][j].front()._packet_id            );
     300//                  in_EXECUTE_UNIT_OUT_OPERATION            [i][j] ->write(request[i][j].front()._operation            );
     301                    in_EXECUTE_UNIT_OUT_TYPE                 [i][j] ->write(request[i][j].front()._type                 );
     302                    in_EXECUTE_UNIT_OUT_WRITE_RD             [i][j] ->write(request[i][j].front()._write_rd             );
     303                    in_EXECUTE_UNIT_OUT_NUM_REG_RD           [i][j] ->write(request[i][j].front()._num_reg_rd           );
     304                    in_EXECUTE_UNIT_OUT_DATA_RD              [i][j] ->write(request[i][j].front()._data_rd              );
     305                    in_EXECUTE_UNIT_OUT_WRITE_RE             [i][j] ->write(request[i][j].front()._write_re             );
     306                    in_EXECUTE_UNIT_OUT_NUM_REG_RE           [i][j] ->write(request[i][j].front()._num_reg_re           );
     307                    in_EXECUTE_UNIT_OUT_DATA_RE              [i][j] ->write(request[i][j].front()._data_re              );
     308                    in_EXECUTE_UNIT_OUT_EXCEPTION            [i][j] ->write(request[i][j].front()._exception            );
     309                    in_EXECUTE_UNIT_OUT_NO_SEQUENCE          [i][j] ->write(request[i][j].front()._no_sequence          );
     310                    in_EXECUTE_UNIT_OUT_ADDRESS              [i][j] ->write(request[i][j].front()._address              );
     311                  }
     312              }
    302313
    303314          for (uint32_t i=0; i<_param->_nb_write_unit; i++)
    … …  
    307318
    308319          for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
    309             if (in_EXECUTE_UNIT_OUT_VAL [i]->read() and out_EXECUTE_UNIT_OUT_ACK [i]->read())
    310               {
    311                 LABEL("EXECUTE_UNIT_OUT   [%d] - Transaction accepted",i);
    312               }
    313 
     320            for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
     321              if (in_EXECUTE_UNIT_OUT_VAL [i][j]->read() and out_EXECUTE_UNIT_OUT_ACK [i][j]->read())
     322                {
     323                  LABEL("EXECUTE_UNIT_OUT   [%d][%d] - Transaction accepted",i,j);
     324                }
     325         
    314326          for (uint32_t i=0; i<_param->_nb_write_unit; i++)
    315327            if (out_WRITE_UNIT_IN_VAL [i]->read() and in_WRITE_UNIT_IN_ACK [i]->read())
    … …  
    318330                nb_request_out ++;
    319331               
    320                 Tpacket_t packet = (_param->_have_port_packet_id)?out_WRITE_UNIT_IN_PACKET_ID[i]->read():0;
    321                 LABEL("  * packet           : %d",packet);             
    322                 uint32_t execute_unit;
     332                Tpacket_t packet = (_param->_have_port_rob_ptr  )?out_WRITE_UNIT_IN_PACKET_ID[i]->read():0;
     333                LABEL("  * packet              : %d",packet);           
    323334
    324335                // find execute_unit
    325                 for (execute_unit=0; execute_unit<_param->_nb_execute_unit; execute_unit++)
    326                   if (packet == ((_param->_have_port_packet_id)?request[execute_unit].front()._packet_id:0))
    327                     break;
    328 
    329                 LABEL("  * execute_unit source : %d",execute_unit);
    330 
    331                 if (_param->_have_port_packet_id)
    332                 TEST(Tcontext_t        ,out_WRITE_UNIT_IN_PACKET_ID            [i]->read(), request[execute_unit].front()._packet_id            );
     336                uint32_t x = 0;
     337                uint32_t y = 0;
     338                bool     find = false;
     339                for (x=0; x<_param->_nb_execute_unit; x++)
     340                  {
     341                    for (y=0; y<_param->_nb_execute_unit_port[x]; y++)
     342                      if (packet == ((_param->_have_port_rob_ptr  )?request[x][y].front()._packet_id:0))
     343                        {
     344                          find = true;
     345                          break;
     346                        }
     347                    if (find)
     348                      break;
     349                  }
     350
     351                LABEL("  * execute_unit source : %d",x);
     352                LABEL("  * execute_unit port   : %d",y);
     353                TEST(bool,x<_param->_nb_execute_unit, true);
     354                TEST(bool,y<_param->_nb_execute_unit_port[x],true);
     355               
     356                if (_param->_have_port_rob_ptr  )
     357                TEST(Tpacket_t         ,packet                                            , request[x][y].front()._packet_id            );
    333358
    334359                // Authorised link ? execute_unit -> write_unit
    335                 TEST(bool, _param->_table_routing[execute_unit][i], true);
     360                TEST(bool, _param->_table_routing[x][y][i], true);
    336361
    337362                if (_param->_have_port_context_id)
    338                 TEST(Tcontext_t        ,out_WRITE_UNIT_IN_CONTEXT_ID           [i]->read(), request[execute_unit].front()._context_id           );
     363                TEST(Tcontext_t        ,out_WRITE_UNIT_IN_CONTEXT_ID           [i]->read(), request[x][y].front()._context_id           );
    339364                if (_param->_have_port_front_end_id)
    340                 TEST(Tcontext_t        ,out_WRITE_UNIT_IN_FRONT_END_ID         [i]->read(), request[execute_unit].front()._front_end_id         );
     365                TEST(Tcontext_t        ,out_WRITE_UNIT_IN_FRONT_END_ID         [i]->read(), request[x][y].front()._front_end_id         );
    341366                if (_param->_have_port_ooo_engine_id)
    342                 TEST(Tcontext_t        ,out_WRITE_UNIT_IN_OOO_ENGINE_ID        [i]->read(), request[execute_unit].front()._ooo_engine_id        );
    343 //              TEST(Toperation_t      ,out_WRITE_UNIT_IN_OPERATION            [i]->read(), request[execute_unit].front()._operation            );
    344                 TEST(Ttype_t           ,out_WRITE_UNIT_IN_TYPE                 [i]->read(), request[execute_unit].front()._type                 );
    345                 TEST(Tcontrol_t        ,out_WRITE_UNIT_IN_WRITE_RD             [i]->read(), request[execute_unit].front()._write_rd             );
    346                 TEST(Tgeneral_address_t,out_WRITE_UNIT_IN_NUM_REG_RD           [i]->read(), request[execute_unit].front()._num_reg_rd           );
    347                 TEST(Tgeneral_data_t   ,out_WRITE_UNIT_IN_DATA_RD              [i]->read(), request[execute_unit].front()._data_rd              );
    348                 TEST(Tcontrol_t        ,out_WRITE_UNIT_IN_WRITE_RE             [i]->read(), request[execute_unit].front()._write_re             );
    349                 TEST(Tspecial_address_t,out_WRITE_UNIT_IN_NUM_REG_RE           [i]->read(), request[execute_unit].front()._num_reg_re           );
    350                 TEST(Tspecial_data_t   ,out_WRITE_UNIT_IN_DATA_RE              [i]->read(), request[execute_unit].front()._data_re              );
    351                 TEST(Texception_t      ,out_WRITE_UNIT_IN_EXCEPTION            [i]->read(), request[execute_unit].front()._exception            );
    352                 TEST(Tcontrol_t        ,out_WRITE_UNIT_IN_NO_SEQUENCE          [i]->read(), request[execute_unit].front()._no_sequence          );
    353                 TEST(Tgeneral_data_t   ,out_WRITE_UNIT_IN_ADDRESS              [i]->read(), request[execute_unit].front()._address              );
     367                TEST(Tcontext_t        ,out_WRITE_UNIT_IN_OOO_ENGINE_ID        [i]->read(), request[x][y].front()._ooo_engine_id        );
     368//              TEST(Toperation_t      ,out_WRITE_UNIT_IN_OPERATION            [i]->read(), request[x][y].front()._operation            );
     369                TEST(Ttype_t           ,out_WRITE_UNIT_IN_TYPE                 [i]->read(), request[x][y].front()._type                 );
     370                TEST(Tcontrol_t        ,out_WRITE_UNIT_IN_WRITE_RD             [i]->read(), request[x][y].front()._write_rd             );
     371                TEST(Tgeneral_address_t,out_WRITE_UNIT_IN_NUM_REG_RD           [i]->read(), request[x][y].front()._num_reg_rd           );
     372                TEST(Tgeneral_data_t   ,out_WRITE_UNIT_IN_DATA_RD              [i]->read(), request[x][y].front()._data_rd              );
     373                TEST(Tcontrol_t        ,out_WRITE_UNIT_IN_WRITE_RE             [i]->read(), request[x][y].front()._write_re             );
     374                TEST(Tspecial_address_t,out_WRITE_UNIT_IN_NUM_REG_RE           [i]->read(), request[x][y].front()._num_reg_re           );
     375                TEST(Tspecial_data_t   ,out_WRITE_UNIT_IN_DATA_RE              [i]->read(), request[x][y].front()._data_re              );
     376                TEST(Texception_t      ,out_WRITE_UNIT_IN_EXCEPTION            [i]->read(), request[x][y].front()._exception            );
     377                TEST(Tcontrol_t        ,out_WRITE_UNIT_IN_NO_SEQUENCE          [i]->read(), request[x][y].front()._no_sequence          );
     378                TEST(Tgeneral_data_t   ,out_WRITE_UNIT_IN_ADDRESS              [i]->read(), request[x][y].front()._address              );
    354379               
    355                 request[execute_unit].pop_front();
     380                request[x][y].pop_front();
    356381              }
    357382          SC_START(1);
    … …  
    372397  delete in_NRESET;
    373398
    374   delete []  in_EXECUTE_UNIT_OUT_VAL          ;
    375   delete [] out_EXECUTE_UNIT_OUT_ACK          ;
    376   delete []  in_EXECUTE_UNIT_OUT_CONTEXT_ID   ;
    377   delete []  in_EXECUTE_UNIT_OUT_FRONT_END_ID ;
    378   delete []  in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID;
    379   delete []  in_EXECUTE_UNIT_OUT_PACKET_ID    ;
    380 //delete []  in_EXECUTE_UNIT_OUT_OPERATION    ;
    381   delete []  in_EXECUTE_UNIT_OUT_TYPE         ;
    382   delete []  in_EXECUTE_UNIT_OUT_WRITE_RD     ;
    383   delete []  in_EXECUTE_UNIT_OUT_NUM_REG_RD   ;
    384   delete []  in_EXECUTE_UNIT_OUT_DATA_RD      ;
    385   delete []  in_EXECUTE_UNIT_OUT_WRITE_RE     ;
    386   delete []  in_EXECUTE_UNIT_OUT_NUM_REG_RE   ;
    387   delete []  in_EXECUTE_UNIT_OUT_DATA_RE      ;
    388   delete []  in_EXECUTE_UNIT_OUT_EXCEPTION    ;
    389   delete []  in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ;
    390   delete []  in_EXECUTE_UNIT_OUT_ADDRESS      ;
    391 
    392   delete [] out_WRITE_UNIT_IN_VAL             ;
    393   delete []  in_WRITE_UNIT_IN_ACK             ;
    394   delete [] out_WRITE_UNIT_IN_CONTEXT_ID      ;
    395   delete [] out_WRITE_UNIT_IN_FRONT_END_ID    ;
    396   delete [] out_WRITE_UNIT_IN_OOO_ENGINE_ID   ;
    397   delete [] out_WRITE_UNIT_IN_PACKET_ID       ;
    398 //delete [] out_WRITE_UNIT_IN_OPERATION       ;
    399   delete [] out_WRITE_UNIT_IN_TYPE            ;
    400   delete [] out_WRITE_UNIT_IN_WRITE_RD        ;
    401   delete [] out_WRITE_UNIT_IN_NUM_REG_RD      ;
    402   delete [] out_WRITE_UNIT_IN_DATA_RD         ;
    403   delete [] out_WRITE_UNIT_IN_WRITE_RE        ;
    404   delete [] out_WRITE_UNIT_IN_NUM_REG_RE      ;
    405   delete [] out_WRITE_UNIT_IN_DATA_RE         ;
    406   delete [] out_WRITE_UNIT_IN_EXCEPTION       ;
    407   delete [] out_WRITE_UNIT_IN_NO_SEQUENCE     ;
    408   delete [] out_WRITE_UNIT_IN_ADDRESS         ;
     399  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_VAL          ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     400  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_OUT_ACK          ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     401  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_CONTEXT_ID   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     402  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_FRONT_END_ID ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     403  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     404  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_PACKET_ID    ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     405//DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_OPERATION    ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     406  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_TYPE         ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     407  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_WRITE_RD     ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     408  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_NUM_REG_RD   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     409  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_DATA_RD      ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     410  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_WRITE_RE     ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     411  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_NUM_REG_RE   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     412  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_DATA_RE      ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     413  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_EXCEPTION    ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     414  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     415  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_ADDRESS      ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     416
     417  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_VAL             ,_param->_nb_write_unit  );
     418  DELETE1_SC_SIGNAL( in_WRITE_UNIT_IN_ACK             ,_param->_nb_write_unit  );
     419  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_CONTEXT_ID      ,_param->_nb_write_unit  );
     420  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_FRONT_END_ID    ,_param->_nb_write_unit  );
     421  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_OOO_ENGINE_ID   ,_param->_nb_write_unit  );
     422  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_PACKET_ID       ,_param->_nb_write_unit  );
     423//DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_OPERATION       ,_param->_nb_write_unit  );
     424  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_TYPE            ,_param->_nb_write_unit  );
     425  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_WRITE_RD        ,_param->_nb_write_unit  );
     426  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_NUM_REG_RD      ,_param->_nb_write_unit  );
     427  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_DATA_RD         ,_param->_nb_write_unit  );
     428  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_WRITE_RE        ,_param->_nb_write_unit  );
     429  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_NUM_REG_RE      ,_param->_nb_write_unit  );
     430  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_DATA_RE         ,_param->_nb_write_unit  );
     431  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_EXCEPTION       ,_param->_nb_write_unit  );
     432  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_NO_SEQUENCE     ,_param->_nb_write_unit  );
     433  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_ADDRESS         ,_param->_nb_write_unit  );
    409434#endif
    410435

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

    r82 r88  
    6565
    6666    // ~~~~~[ Interface "execute_unit_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    67   public    : SC_IN (Tcontrol_t        )   **  in_EXECUTE_UNIT_OUT_VAL            ;
    68   public    : SC_OUT(Tcontrol_t        )   ** out_EXECUTE_UNIT_OUT_ACK            ;
    69   public    : SC_IN (Tcontext_t        )   **  in_EXECUTE_UNIT_OUT_CONTEXT_ID     ;
    70   public    : SC_IN (Tcontext_t        )   **  in_EXECUTE_UNIT_OUT_FRONT_END_ID   ;
    71   public    : SC_IN (Tcontext_t        )   **  in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID  ;
    72   public    : SC_IN (Tpacket_t         )   **  in_EXECUTE_UNIT_OUT_PACKET_ID      ;
    73 //public    : SC_IN (Toperation_t      )   **  in_EXECUTE_UNIT_OUT_OPERATION      ;
    74   public    : SC_IN (Ttype_t           )   **  in_EXECUTE_UNIT_OUT_TYPE           ;
    75   public    : SC_IN (Tcontrol_t        )   **  in_EXECUTE_UNIT_OUT_WRITE_RD       ;
    76   public    : SC_IN (Tgeneral_address_t)   **  in_EXECUTE_UNIT_OUT_NUM_REG_RD     ;
    77   public    : SC_IN (Tgeneral_data_t   )   **  in_EXECUTE_UNIT_OUT_DATA_RD        ;
    78   public    : SC_IN (Tcontrol_t        )   **  in_EXECUTE_UNIT_OUT_WRITE_RE       ;
    79   public    : SC_IN (Tspecial_address_t)   **  in_EXECUTE_UNIT_OUT_NUM_REG_RE     ;
    80   public    : SC_IN (Tspecial_data_t   )   **  in_EXECUTE_UNIT_OUT_DATA_RE        ;
    81   public    : SC_IN (Texception_t      )   **  in_EXECUTE_UNIT_OUT_EXCEPTION      ;
    82   public    : SC_IN (Tcontrol_t        )   **  in_EXECUTE_UNIT_OUT_NO_SEQUENCE    ;
    83   public    : SC_IN (Tgeneral_data_t   )   **  in_EXECUTE_UNIT_OUT_ADDRESS        ;
     67  public    : SC_IN (Tcontrol_t        )  ***  in_EXECUTE_UNIT_OUT_VAL            ;
     68  public    : SC_OUT(Tcontrol_t        )  *** out_EXECUTE_UNIT_OUT_ACK            ;
     69  public    : SC_IN (Tcontext_t        )  ***  in_EXECUTE_UNIT_OUT_CONTEXT_ID     ;
     70  public    : SC_IN (Tcontext_t        )  ***  in_EXECUTE_UNIT_OUT_FRONT_END_ID   ;
     71  public    : SC_IN (Tcontext_t        )  ***  in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID  ;
     72  public    : SC_IN (Tpacket_t         )  ***  in_EXECUTE_UNIT_OUT_PACKET_ID      ;
     73//public    : SC_IN (Toperation_t      )  ***  in_EXECUTE_UNIT_OUT_OPERATION      ;
     74  public    : SC_IN (Ttype_t           )  ***  in_EXECUTE_UNIT_OUT_TYPE           ;
     75  public    : SC_IN (Tcontrol_t        )  ***  in_EXECUTE_UNIT_OUT_WRITE_RD       ;
     76  public    : SC_IN (Tgeneral_address_t)  ***  in_EXECUTE_UNIT_OUT_NUM_REG_RD     ;
     77  public    : SC_IN (Tgeneral_data_t   )  ***  in_EXECUTE_UNIT_OUT_DATA_RD        ;
     78  public    : SC_IN (Tcontrol_t        )  ***  in_EXECUTE_UNIT_OUT_WRITE_RE       ;
     79  public    : SC_IN (Tspecial_address_t)  ***  in_EXECUTE_UNIT_OUT_NUM_REG_RE     ;
     80  public    : SC_IN (Tspecial_data_t   )  ***  in_EXECUTE_UNIT_OUT_DATA_RE        ;
     81  public    : SC_IN (Texception_t      )  ***  in_EXECUTE_UNIT_OUT_EXCEPTION      ;
     82  public    : SC_IN (Tcontrol_t        )  ***  in_EXECUTE_UNIT_OUT_NO_SEQUENCE    ;
     83  public    : SC_IN (Tgeneral_data_t   )  ***  in_EXECUTE_UNIT_OUT_ADDRESS        ;
    8484
    8585    // ~~~~~[ Interface "write_unit_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    … …  
    107107
    108108    // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    109   private   : std::list<uint32_t> ** _destination; // [nb_execute_unit][nb_thread];
     109  private   : std::list<uint32_t> *** _destination; //[nb_execute_unit][nb_execute_unit_port][nb_thread];
    110110#endif
    111111

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

    r81 r88  
    2626  {
    2727    //-----[ fields ]------------------------------------------------------------
    28   public : const uint32_t    _nb_execute_unit              ;
    29   public : const uint32_t    _nb_write_unit                ;
    30   public : const uint32_t    _nb_context                   ;
    31   public : const uint32_t    _nb_front_end                 ;
    32   public : const uint32_t    _nb_ooo_engine                ;
    33   public : const uint32_t    _nb_packet                    ;
    34   public : const uint32_t    _size_general_data            ;
    35   public : const uint32_t    _size_special_data            ;
    36   public : const uint32_t    _nb_general_register          ;
    37   public : const uint32_t    _nb_special_register          ;
    38   public : const Tpriority_t _priority                     ;
    39   public :       bool     ** _table_routing                ; //array [nb_execute_unit][nb_write_unit]
    40   public :       bool     ** _table_thread                 ; //array [nb_write_unit][nb_thread]
     28  public : uint32_t    _nb_execute_unit              ;
     29  public : uint32_t  * _nb_execute_unit_port         ;//[nb_execute_unit]
     30  public : uint32_t    _nb_write_unit                ;
     31  public : uint32_t    _nb_context                   ;
     32  public : uint32_t    _nb_front_end                 ;
     33  public : uint32_t    _nb_ooo_engine                ;
     34  public : uint32_t    _nb_packet                    ;
     35//public : uint32_t    _size_general_data            ;
     36//public : uint32_t    _size_special_data            ;
     37  public : uint32_t    _nb_general_register          ;
     38  public : uint32_t    _nb_special_register          ;
     39  public : Tpriority_t _priority                     ;
     40  public : bool    *** _table_routing                ; //[nb_execute_unit][nb_execute_unit_port][nb_write_unit]
     41  public : bool     ** _table_thread                 ; //[nb_write_unit][nb_thread]
    4142
    42   public : const uint32_t    _size_context_id              ;
    43   public : const uint32_t    _size_front_end_id            ;
    44   public : const uint32_t    _size_ooo_engine_id           ;
    45   public : const uint32_t    _size_packet_id               ;
    46   public : const uint32_t    _size_general_register        ;
    47   public : const uint32_t    _size_special_register        ;
     43  public : uint32_t    _max_nb_execute_unit_port     ;
     44//public : uint32_t    _size_context_id              ;
     45//public : uint32_t    _size_front_end_id            ;
     46//public : uint32_t    _size_ooo_engine_id           ;
     47//public : uint32_t    _size_packet_id               ;
     48//public : uint32_t    _size_general_register        ;
     49//public : uint32_t    _size_special_register        ;
    4850
    49   public : const bool        _have_port_context_id         ;
    50   public : const bool        _have_port_front_end_id       ;
    51   public : const bool        _have_port_ooo_engine_id      ;
    52   public : const bool        _have_port_packet_id          ;
     51//public : bool        _have_port_context_id         ;
     52//public : bool        _have_port_front_end_id       ;
     53//public : bool        _have_port_ooo_engine_id      ;
     54//public : bool        _have_port_packet_id          ;
    5355
    54   public : const uint32_t    _nb_thread                    ;
     56  public : uint32_t    _nb_thread                    ;
    5557
    5658    //-----[ methods ]-----------------------------------------------------------
    5759  public : Parameters  (uint32_t    nb_execute_unit              ,
     60                        uint32_t  * nb_execute_unit_port         ,
    5861                        uint32_t    nb_write_unit                ,
    5962                        uint32_t    nb_context                   ,
    … …  
    6669                        uint32_t    nb_special_register          ,
    6770                        Tpriority_t priority                     ,
    68                         bool     ** table_routing                ,
    69                         bool     ** table_thread                 );
    70   public : Parameters  (Parameters & param) ;
     71                        bool    *** table_routing                ,
     72                        bool     ** table_thread                 ,
     73                        bool        is_toplevel=false
     74                        );
     75//   public : Parameters  (Parameters & param) ;
    7176  public : ~Parameters ();
     77
     78  public :        void            copy       (void);
    7279
    7380  public :        Parameters_test msg_error  (void);

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

    r81 r88  
    3838    log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"Begin");
    3939
     40#if DEBUG_Execution_unit_to_Write_unit == true
     41    log_printf(INFO,Execution_unit_to_Write_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
     42
     43    std::cout << *param << std::endl;
     44#endif   
     45
    4046    log_printf(INFO,Execution_unit_to_Write_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,Execution_unit_to_Write_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,Execution_unit_to_Write_unit,FUNCTION,"Method - transition");
    … …  
    8490        sensitive << (*(in_CLOCK)).pos();
    8591        for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
    86           {
    87             if (_param->_have_port_context_id)
    88             sensitive << (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [i]));
    89             if (_param->_have_port_front_end_id)
    90             sensitive << (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [i]));
    91             if (_param->_have_port_ooo_engine_id)
    92             sensitive << (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [i]));
    93             if (_param->_have_port_packet_id)
    94             sensitive << (*(in_EXECUTE_UNIT_OUT_PACKET_ID     [i]));
    95 
    96             sensitive << (*(in_EXECUTE_UNIT_OUT_VAL           [i]))
    97                     //<< (*(in_EXECUTE_UNIT_OUT_OPERATION     [i]))
    98                     //<< (*(in_EXECUTE_UNIT_OUT_TYPE          [i]))
    99                       << (*(in_EXECUTE_UNIT_OUT_WRITE_RD      [i]))
    100                       << (*(in_EXECUTE_UNIT_OUT_NUM_REG_RD    [i]))
    101                       << (*(in_EXECUTE_UNIT_OUT_DATA_RD       [i]))
    102                       << (*(in_EXECUTE_UNIT_OUT_WRITE_RE      [i]))
    103                       << (*(in_EXECUTE_UNIT_OUT_NUM_REG_RE    [i]))
    104                       << (*(in_EXECUTE_UNIT_OUT_DATA_RE       [i]))
    105                       << (*(in_EXECUTE_UNIT_OUT_EXCEPTION     [i]))
    106                       << (*(in_EXECUTE_UNIT_OUT_NO_SEQUENCE   [i]))
    107                       << (*(in_EXECUTE_UNIT_OUT_ADDRESS       [i]));
    108           }
     92          for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
     93            {
     94              if (_param->_have_port_context_id)
     95              sensitive << (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [i][j]));
     96              if (_param->_have_port_front_end_id)
     97              sensitive << (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [i][j]));
     98              if (_param->_have_port_ooo_engine_id)
     99              sensitive << (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [i][j]));
     100              if (_param->_have_port_rob_ptr  )
     101              sensitive << (*(in_EXECUTE_UNIT_OUT_PACKET_ID     [i][j]));
     102             
     103              sensitive << (*(in_EXECUTE_UNIT_OUT_VAL           [i][j]))
     104                      //<< (*(in_EXECUTE_UNIT_OUT_OPERATION     [i][j]))
     105                      //<< (*(in_EXECUTE_UNIT_OUT_TYPE          [i][j]))
     106                        << (*(in_EXECUTE_UNIT_OUT_WRITE_RD      [i][j]))
     107                        << (*(in_EXECUTE_UNIT_OUT_NUM_REG_RD    [i][j]))
     108                        << (*(in_EXECUTE_UNIT_OUT_DATA_RD       [i][j]))
     109                        << (*(in_EXECUTE_UNIT_OUT_WRITE_RE      [i][j]))
     110                        << (*(in_EXECUTE_UNIT_OUT_NUM_REG_RE    [i][j]))
     111                        << (*(in_EXECUTE_UNIT_OUT_DATA_RE       [i][j]))
     112                        << (*(in_EXECUTE_UNIT_OUT_EXCEPTION     [i][j]))
     113                        << (*(in_EXECUTE_UNIT_OUT_NO_SEQUENCE   [i][j]))
     114                        << (*(in_EXECUTE_UNIT_OUT_ADDRESS       [i][j]));
     115            }
    109116        for (uint32_t i=0; i<_param->_nb_write_unit; i++)
    110117          sensitive << (*(in_WRITE_UNIT_IN_ACK [i]));
    … …  
    113120        // List dependency information
    114121        for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
    115           {
    116             (*(out_EXECUTE_UNIT_OUT_ACK [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [i]));
    117             if (_param->_have_port_context_id)
    118             (*(out_EXECUTE_UNIT_OUT_ACK [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [i]));
    119             if (_param->_have_port_front_end_id)
    120             (*(out_EXECUTE_UNIT_OUT_ACK [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [i]));
    121             if (_param->_have_port_ooo_engine_id)
    122             (*(out_EXECUTE_UNIT_OUT_ACK [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [i]));
    123 
    124             for (uint32_t j=0; j<_param->_nb_write_unit; j++)
    125               (*(out_EXECUTE_UNIT_OUT_ACK [i])) (*(in_WRITE_UNIT_IN_ACK [j]));
    126           }
     122          for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
     123            {
     124              (*(out_EXECUTE_UNIT_OUT_ACK [i][j])) (*(in_EXECUTE_UNIT_OUT_VAL           [i][j]));
     125              if (_param->_have_port_context_id)
     126              (*(out_EXECUTE_UNIT_OUT_ACK [i][j])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [i][j]));
     127              if (_param->_have_port_front_end_id)
     128              (*(out_EXECUTE_UNIT_OUT_ACK [i][j])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [i][j]));
     129              if (_param->_have_port_ooo_engine_id)
     130              (*(out_EXECUTE_UNIT_OUT_ACK [i][j])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [i][j]));
     131
     132              for (uint32_t x=0; x<_param->_nb_write_unit; x++)
     133                (*(out_EXECUTE_UNIT_OUT_ACK [i][j])) (*(in_WRITE_UNIT_IN_ACK [x]));
     134            }
    127135
    128136        for (uint32_t i=0; i<_param->_nb_write_unit; i++)
    129137          {
    130138            (*(out_WRITE_UNIT_IN_VAL [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
    131             for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
    132               {
    133                 (*(out_WRITE_UNIT_IN_VAL [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
    134                 if (_param->_have_port_context_id)
    135                 (*(out_WRITE_UNIT_IN_VAL [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
    136                 if (_param->_have_port_front_end_id)
    137                 (*(out_WRITE_UNIT_IN_VAL [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
    138                 if (_param->_have_port_ooo_engine_id)
    139                 (*(out_WRITE_UNIT_IN_VAL [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
     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              {
     142                (*(out_WRITE_UNIT_IN_VAL [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
     143                if (_param->_have_port_context_id)
     144                (*(out_WRITE_UNIT_IN_VAL [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
     145                if (_param->_have_port_front_end_id)
     146                (*(out_WRITE_UNIT_IN_VAL [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
     147                if (_param->_have_port_ooo_engine_id)
     148                (*(out_WRITE_UNIT_IN_VAL [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
    140149              }
    141150
    … …  
    143152              {
    144153            (*(out_WRITE_UNIT_IN_CONTEXT_ID [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
    145             for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
    146               {
    147                 (*(out_WRITE_UNIT_IN_CONTEXT_ID [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
    148                 if (_param->_have_port_context_id)
    149                 (*(out_WRITE_UNIT_IN_CONTEXT_ID [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
    150                 if (_param->_have_port_front_end_id)
    151                 (*(out_WRITE_UNIT_IN_CONTEXT_ID [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
    152                 if (_param->_have_port_ooo_engine_id)
    153                 (*(out_WRITE_UNIT_IN_CONTEXT_ID [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
     154            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
     155              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
     156              {
     157                (*(out_WRITE_UNIT_IN_CONTEXT_ID [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
     158                if (_param->_have_port_context_id)
     159                (*(out_WRITE_UNIT_IN_CONTEXT_ID [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
     160                if (_param->_have_port_front_end_id)
     161                (*(out_WRITE_UNIT_IN_CONTEXT_ID [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
     162                if (_param->_have_port_ooo_engine_id)
     163                (*(out_WRITE_UNIT_IN_CONTEXT_ID [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
    154164              }
    155165              }
    … …  
    157167              {
    158168            (*(out_WRITE_UNIT_IN_FRONT_END_ID [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
    159             for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
    160               {
    161                 (*(out_WRITE_UNIT_IN_FRONT_END_ID [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
    162                 if (_param->_have_port_context_id)
    163                 (*(out_WRITE_UNIT_IN_FRONT_END_ID [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
    164                 if (_param->_have_port_front_end_id)
    165                 (*(out_WRITE_UNIT_IN_FRONT_END_ID [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
    166                 if (_param->_have_port_ooo_engine_id)
    167                 (*(out_WRITE_UNIT_IN_FRONT_END_ID [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
     169            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
     170              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
     171              {
     172                (*(out_WRITE_UNIT_IN_FRONT_END_ID [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
     173                if (_param->_have_port_context_id)
     174                (*(out_WRITE_UNIT_IN_FRONT_END_ID [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
     175                if (_param->_have_port_front_end_id)
     176                (*(out_WRITE_UNIT_IN_FRONT_END_ID [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
     177                if (_param->_have_port_ooo_engine_id)
     178                (*(out_WRITE_UNIT_IN_FRONT_END_ID [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
    168179              }
    169180              }
    … …  
    171182              {
    172183            (*(out_WRITE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
    173             for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
    174               {
    175                 (*(out_WRITE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
    176                 if (_param->_have_port_context_id)
    177                 (*(out_WRITE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
    178                 if (_param->_have_port_front_end_id)
    179                 (*(out_WRITE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
    180                 if (_param->_have_port_ooo_engine_id)
    181                 (*(out_WRITE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
    182               }
    183               }
    184 
    185             if (_param->_have_port_packet_id)
     184            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
     185              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
     186              {
     187                (*(out_WRITE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
     188                if (_param->_have_port_context_id)
     189                (*(out_WRITE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
     190                if (_param->_have_port_front_end_id)
     191                (*(out_WRITE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
     192                if (_param->_have_port_ooo_engine_id)
     193                (*(out_WRITE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
     194              }
     195              }
     196
     197            if (_param->_have_port_rob_ptr  )
    186198              {
    187199            (*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
    188             for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
    189               {
    190                 (*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_PACKET_ID [j]));
    191                 (*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
    192                 if (_param->_have_port_context_id)
    193                 (*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
    194                 if (_param->_have_port_front_end_id)
    195                 (*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
    196                 if (_param->_have_port_ooo_engine_id)
    197                 (*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
     200            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
     201              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
     202              {
     203                (*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_PACKET_ID [x][y]));
     204                (*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
     205                if (_param->_have_port_context_id)
     206                (*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
     207                if (_param->_have_port_front_end_id)
     208                (*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
     209                if (_param->_have_port_ooo_engine_id)
     210                (*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
    198211              }
    199212              }
    200213
    201214//          (*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
    202 //          for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
     215//          for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
     216//            for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
    203217//            {
    204 //              (*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_OPERATION [j]));
    205 //              (*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
     218//              (*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_OPERATION [x][y]));
     219//              (*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
    206220//              if (_param->_have_port_context_id)
    207 //              (*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
     221//              (*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
    208222//              if (_param->_have_port_front_end_id)
    209 //              (*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
     223//              (*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
    210224//              if (_param->_have_port_ooo_engine_id)
    211 //              (*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
     225//              (*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
    212226//            }
    213227
    214228//          (*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
    215 //          for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
     229//          for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
     230//            for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
    216231//            {
    217 //              (*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_TYPE [j]));
    218 //              (*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
     232//              (*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_TYPE [x][y]));
     233//              (*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
    219234//              if (_param->_have_port_context_id)
    220 //              (*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
     235//              (*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
    221236//              if (_param->_have_port_front_end_id)
    222 //              (*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
     237//              (*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
    223238//              if (_param->_have_port_ooo_engine_id)
    224 //              (*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
     239//              (*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
    225240//            }
    226241
    227242            (*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
    228             for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
    229               {
    230                 (*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_WRITE_RD [j]));
    231                 (*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
    232                 if (_param->_have_port_context_id)
    233                 (*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
    234                 if (_param->_have_port_front_end_id)
    235                 (*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
    236                 if (_param->_have_port_ooo_engine_id)
    237                 (*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
     243            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
     244              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
     245              {
     246                (*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_WRITE_RD [x][y]));
     247                (*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
     248                if (_param->_have_port_context_id)
     249                (*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
     250                if (_param->_have_port_front_end_id)
     251                (*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
     252                if (_param->_have_port_ooo_engine_id)
     253                (*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
    238254              }
    239255
    240256            (*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
    241             for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
    242               {
    243                 (*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_NUM_REG_RD [j]));
    244                 (*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
    245                 if (_param->_have_port_context_id)
    246                 (*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
    247                 if (_param->_have_port_front_end_id)
    248                 (*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
    249                 if (_param->_have_port_ooo_engine_id)
    250                 (*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
     257            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
     258              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
     259              {
     260                (*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_NUM_REG_RD [x][y]));
     261                (*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
     262                if (_param->_have_port_context_id)
     263                (*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
     264                if (_param->_have_port_front_end_id)
     265                (*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
     266                if (_param->_have_port_ooo_engine_id)
     267                (*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
    251268              }
    252269
    253270            (*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
    254             for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
    255               {
    256                 (*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_DATA_RD [j]));
    257                 (*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
    258                 if (_param->_have_port_context_id)
    259                 (*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
    260                 if (_param->_have_port_front_end_id)
    261                 (*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
    262                 if (_param->_have_port_ooo_engine_id)
    263                 (*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
     271            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
     272              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
     273              {
     274                (*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_DATA_RD [x][y]));
     275                (*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
     276                if (_param->_have_port_context_id)
     277                (*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
     278                if (_param->_have_port_front_end_id)
     279                (*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
     280                if (_param->_have_port_ooo_engine_id)
     281                (*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
    264282              }
    265283
    266284            (*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
    267             for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
    268               {
    269                 (*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_WRITE_RE [j]));
    270                 (*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
    271                 if (_param->_have_port_context_id)
    272                 (*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
    273                 if (_param->_have_port_front_end_id)
    274                 (*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
    275                 if (_param->_have_port_ooo_engine_id)
    276                 (*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
     285            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
     286              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
     287              {
     288                (*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_WRITE_RE [x][y]));
     289                (*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
     290                if (_param->_have_port_context_id)
     291                (*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
     292                if (_param->_have_port_front_end_id)
     293                (*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
     294                if (_param->_have_port_ooo_engine_id)
     295                (*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
    277296              }
    278297
    279298            (*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
    280             for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
    281               {
    282                 (*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_NUM_REG_RE [j]));
    283                 (*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
    284                 if (_param->_have_port_context_id)
    285                 (*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
    286                 if (_param->_have_port_front_end_id)
    287                 (*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
    288                 if (_param->_have_port_ooo_engine_id)
    289                 (*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
     299            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
     300              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
     301              {
     302                (*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_NUM_REG_RE [x][y]));
     303                (*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
     304                if (_param->_have_port_context_id)
     305                (*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
     306                if (_param->_have_port_front_end_id)
     307                (*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
     308                if (_param->_have_port_ooo_engine_id)
     309                (*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
    290310              }
    291311
    292312            (*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
    293             for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
    294               {
    295                 (*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_DATA_RE [j]));
    296                 (*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
    297                 if (_param->_have_port_context_id)
    298                 (*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
    299                 if (_param->_have_port_front_end_id)
    300                 (*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
    301                 if (_param->_have_port_ooo_engine_id)
    302                 (*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
     313            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
     314              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
     315              {
     316                (*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_DATA_RE [x][y]));
     317                (*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
     318                if (_param->_have_port_context_id)
     319                (*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
     320                if (_param->_have_port_front_end_id)
     321                (*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
     322                if (_param->_have_port_ooo_engine_id)
     323                (*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
    303324              }
    304325
    305326            (*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
    306             for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
    307               {
    308                 (*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_EXCEPTION [j]));
    309                 (*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
    310                 if (_param->_have_port_context_id)
    311                 (*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
    312                 if (_param->_have_port_front_end_id)
    313                 (*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
    314                 if (_param->_have_port_ooo_engine_id)
    315                 (*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
     327            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
     328              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
     329              {
     330                (*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_EXCEPTION [x][y]));
     331                (*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
     332                if (_param->_have_port_context_id)
     333                (*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
     334                if (_param->_have_port_front_end_id)
     335                (*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
     336                if (_param->_have_port_ooo_engine_id)
     337                (*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
    316338              }
    317339
    318340            (*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
    319             for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
    320               {
    321                 (*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_NO_SEQUENCE [j]));
    322                 (*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
    323                 if (_param->_have_port_context_id)
    324                 (*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
    325                 if (_param->_have_port_front_end_id)
    326                 (*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
    327                 if (_param->_have_port_ooo_engine_id)
    328                 (*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
     341            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
     342              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
     343              {
     344                (*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_NO_SEQUENCE [x][y]));
     345                (*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
     346                if (_param->_have_port_context_id)
     347                (*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
     348                if (_param->_have_port_front_end_id)
     349                (*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
     350                if (_param->_have_port_ooo_engine_id)
     351                (*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
    329352              }
    330353
    331354            (*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
    332             for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
    333               {
    334                 (*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_ADDRESS [j]));
    335                 (*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
    336                 if (_param->_have_port_context_id)
    337                 (*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
    338                 if (_param->_have_port_front_end_id)
    339                 (*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
    340                 if (_param->_have_port_ooo_engine_id)
    341                 (*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
    342               }
    343 
     355            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
     356              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
     357              {
     358                (*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_ADDRESS [x][y]));
     359                (*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
     360                if (_param->_have_port_context_id)
     361                (*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
     362                if (_param->_have_port_front_end_id)
     363                (*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
     364                if (_param->_have_port_ooo_engine_id)
     365                (*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
     366              }
    344367          }
    345368# endif   
    … …  
    357380
    358381#ifdef STATISTICS
    359     if (_usage & USE_STATISTICS)
     382    if (usage_is_set(_usage,USE_STATISTICS))
    360383      {
    361384        log_printf(INFO,Execution_unit_to_Write_unit,FUNCTION,"Generate Statistics file");

  • 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

    r81 r88  
    5858    // ~~~~~[ Interface "execute_unit_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    5959     {
    60        ALLOC1_INTERFACE("execute_unit_out", IN, EAST, "Output of execution_unit", _param->_nb_execute_unit);
     60       ALLOC2_INTERFACE("execute_unit_out", IN, EAST, "Output of execution_unit", _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
    6161
    62        ALLOC1_VALACK_IN ( in_EXECUTE_UNIT_OUT_VAL,VAL);
    63        ALLOC1_VALACK_OUT(out_EXECUTE_UNIT_OUT_ACK,ACK);
    64        ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_CONTEXT_ID   ,"context_id"   ,Tcontext_t        ,_param->_size_context_id      );
    65        ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_FRONT_END_ID ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id    );
    66        ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id   );
    67        ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_PACKET_ID    ,"packet_id"    ,Tpacket_t         ,_param->_size_packet_id       );
    68      //ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_OPERATION    ,"operation"    ,Toperation_t      ,_param->_size_operation       );
    69        ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_TYPE         ,"type"         ,Ttype_t           ,_param->_size_type            );
    70        ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_WRITE_RD     ,"write_rd"     ,Tcontrol_t        ,1                             );
    71        ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_NUM_REG_RD   ,"num_reg_rd"   ,Tgeneral_address_t,_param->_size_general_register);
    72        ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_DATA_RD      ,"data_rd"      ,Tgeneral_data_t   ,_param->_size_general_data    );
    73        ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_WRITE_RE     ,"write_re"     ,Tcontrol_t        ,1                             );
    74        ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_NUM_REG_RE   ,"num_reg_re"   ,Tspecial_address_t,_param->_size_special_register);
    75        ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_DATA_RE      ,"data_re"      ,Tspecial_data_t   ,_param->_size_special_data    );
    76        ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_EXCEPTION    ,"exception"    ,Texception_t      ,_param->_size_exception       );
    77        ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t        ,1                             );
    78        ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_ADDRESS      ,"address"      ,Tgeneral_data_t   ,_param->_size_general_data    );
     62       _ALLOC2_VALACK_IN ( in_EXECUTE_UNIT_OUT_VAL,VAL, _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
     63       _ALLOC2_VALACK_OUT(out_EXECUTE_UNIT_OUT_ACK,ACK, _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
     64       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_CONTEXT_ID   ,"context_id"   ,Tcontext_t        ,_param->_size_context_id      , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
     65       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_FRONT_END_ID ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id    , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
     66       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id   , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
     67       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_PACKET_ID    ,"packet_id"    ,Tpacket_t         ,_param->_size_rob_ptr         , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
     68     //_ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_OPERATION    ,"operation"    ,Toperation_t      ,_param->_size_operation       , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
     69       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_TYPE         ,"type"         ,Ttype_t           ,_param->_size_type            , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
     70       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_WRITE_RD     ,"write_rd"     ,Tcontrol_t        ,1                             , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
     71       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_NUM_REG_RD   ,"num_reg_rd"   ,Tgeneral_address_t,_param->_size_general_register, _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
     72       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_DATA_RD      ,"data_rd"      ,Tgeneral_data_t   ,_param->_size_general_data    , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
     73       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_WRITE_RE     ,"write_re"     ,Tcontrol_t        ,1                             , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
     74       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_NUM_REG_RE   ,"num_reg_re"   ,Tspecial_address_t,_param->_size_special_register, _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
     75       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_DATA_RE      ,"data_re"      ,Tspecial_data_t   ,_param->_size_special_data    , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
     76       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_EXCEPTION    ,"exception"    ,Texception_t      ,_param->_size_exception       , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
     77       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t        ,1                             , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
     78       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_ADDRESS      ,"address"      ,Tgeneral_data_t   ,_param->_size_general_data    , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
    7979     }
     80
    8081    // ~~~~~[ Interface "write_unit_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    8182     {
    … …  
    8788       ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_FRONT_END_ID ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id    );
    8889       ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id   );
    89        ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_PACKET_ID    ,"packet_id"    ,Tpacket_t         ,_param->_size_packet_id       );
     90       ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_PACKET_ID    ,"packet_id"    ,Tpacket_t         ,_param->_size_rob_ptr         );
    9091     //ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_OPERATION    ,"operation"    ,Toperation_t      ,_param->_size_operation       );
    9192       ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_TYPE         ,"type"         ,Ttype_t           ,_param->_size_type            );
    … …  
    102103    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    103104
    104      _destination = new std::list<uint32_t> * [_param->_nb_execute_unit];
     105    if (usage_is_set(_usage,USE_SYSTEMC))
     106      {
     107     _destination = new std::list<uint32_t> ** [_param->_nb_execute_unit];
    105108     for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
    106109       {
    107          _destination [i] = new std::list<uint32_t> [_param->_nb_thread];
     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           }
    108115       }
     116      }
    109117
    110118#ifdef POSITION
    111     _component->generate_file();
     119    if (usage_is_set(_usage,USE_POSITION))
     120      _component->generate_file();
    112121#endif
    113122

  • 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

    r81 r88  
    77
    88#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/include/Execution_unit_to_Write_unit.h"
     9#include "Behavioural/include/Allocation.h"
    910
    1011namespace morpheo                    {
    … …  
    2324    log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"Begin");
    2425
    25     if (_usage & USE_SYSTEMC)
     26    if (usage_is_set(_usage,USE_SYSTEMC))
    2627      {
    2728        delete     in_CLOCK ;
    2829        delete     in_NRESET;
    2930
    30         delete []  in_EXECUTE_UNIT_OUT_VAL;
    31         delete [] out_EXECUTE_UNIT_OUT_ACK;
    32         if (_param->_have_port_context_id)
    33         delete []  in_EXECUTE_UNIT_OUT_CONTEXT_ID   ;
    34         if (_param->_have_port_front_end_id)
    35         delete []  in_EXECUTE_UNIT_OUT_FRONT_END_ID ;
    36         if (_param->_have_port_ooo_engine_id)
    37         delete []  in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID;
    38         if (_param->_have_port_packet_id)
    39         delete []  in_EXECUTE_UNIT_OUT_PACKET_ID    ;
    40       //delete []  in_EXECUTE_UNIT_OUT_OPERATION    ;
    41         delete []  in_EXECUTE_UNIT_OUT_TYPE         ;
    42         delete []  in_EXECUTE_UNIT_OUT_WRITE_RD     ;
    43         delete []  in_EXECUTE_UNIT_OUT_NUM_REG_RD   ;
    44         delete []  in_EXECUTE_UNIT_OUT_DATA_RD      ;
    45         delete []  in_EXECUTE_UNIT_OUT_WRITE_RE     ;
    46         delete []  in_EXECUTE_UNIT_OUT_NUM_REG_RE   ;
    47         delete []  in_EXECUTE_UNIT_OUT_DATA_RE      ;
    48         delete []  in_EXECUTE_UNIT_OUT_EXCEPTION    ;
    49         delete []  in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ;
    50         delete []  in_EXECUTE_UNIT_OUT_ADDRESS      ;
     31        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_VAL          , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],1);
     32        DELETE2_SIGNAL(out_EXECUTE_UNIT_OUT_ACK          , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],1);
     33        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_CONTEXT_ID   , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_context_id      );
     34        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_FRONT_END_ID , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_front_end_id    );
     35        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID, _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_ooo_engine_id   );
     36        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_PACKET_ID    , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_rob_ptr         );
     37     // DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_OPERATION    , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_operation       );
     38        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_TYPE         , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_type            );
     39        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_WRITE_RD     , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],1                             );
     40        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_NUM_REG_RD   , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_general_register);
     41        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_DATA_RD      , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_general_data    );
     42        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_WRITE_RE     , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],1                             );
     43        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_NUM_REG_RE   , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_special_register);
     44        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_DATA_RE      , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_special_data    );
     45        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_EXCEPTION    , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_exception       );
     46        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_NO_SEQUENCE  , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],1                             );
     47        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_ADDRESS      , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_general_data    );
    5148
    52         delete [] out_WRITE_UNIT_IN_VAL;
    53         delete []  in_WRITE_UNIT_IN_ACK;
    54         if (_param->_have_port_context_id)
    55         delete [] out_WRITE_UNIT_IN_CONTEXT_ID   ;
    56         if (_param->_have_port_front_end_id)
    57         delete [] out_WRITE_UNIT_IN_FRONT_END_ID ;
    58         if (_param->_have_port_ooo_engine_id)
    59         delete [] out_WRITE_UNIT_IN_OOO_ENGINE_ID;
    60         if (_param->_have_port_packet_id)
    61         delete [] out_WRITE_UNIT_IN_PACKET_ID    ;
    62       //delete [] out_WRITE_UNIT_IN_OPERATION    ;
    63         delete [] out_WRITE_UNIT_IN_TYPE         ;
    64         delete [] out_WRITE_UNIT_IN_WRITE_RD     ;
    65         delete [] out_WRITE_UNIT_IN_NUM_REG_RD   ;
    66         delete [] out_WRITE_UNIT_IN_DATA_RD      ;
    67         delete [] out_WRITE_UNIT_IN_WRITE_RE     ;
    68         delete [] out_WRITE_UNIT_IN_NUM_REG_RE   ;
    69         delete [] out_WRITE_UNIT_IN_DATA_RE      ;
    70         delete [] out_WRITE_UNIT_IN_EXCEPTION    ;
    71         delete [] out_WRITE_UNIT_IN_NO_SEQUENCE  ;
    72         delete [] out_WRITE_UNIT_IN_ADDRESS      ;
     49        DELETE1_SIGNAL(out_WRITE_UNIT_IN_VAL          , _param->_nb_write_unit,1);
     50        DELETE1_SIGNAL( in_WRITE_UNIT_IN_ACK          , _param->_nb_write_unit,1);
     51        DELETE1_SIGNAL(out_WRITE_UNIT_IN_CONTEXT_ID   , _param->_nb_write_unit,_param->_size_context_id      );
     52        DELETE1_SIGNAL(out_WRITE_UNIT_IN_FRONT_END_ID , _param->_nb_write_unit,_param->_size_front_end_id    );
     53        DELETE1_SIGNAL(out_WRITE_UNIT_IN_OOO_ENGINE_ID, _param->_nb_write_unit,_param->_size_ooo_engine_id   );
     54        DELETE1_SIGNAL(out_WRITE_UNIT_IN_PACKET_ID    , _param->_nb_write_unit,_param->_size_rob_ptr         );
     55     // DELETE1_SIGNAL(out_WRITE_UNIT_IN_OPERATION    , _param->_nb_write_unit,_param->_size_operation       );
     56        DELETE1_SIGNAL(out_WRITE_UNIT_IN_TYPE         , _param->_nb_write_unit,_param->_size_type            );
     57        DELETE1_SIGNAL(out_WRITE_UNIT_IN_WRITE_RD     , _param->_nb_write_unit,1                             );
     58        DELETE1_SIGNAL(out_WRITE_UNIT_IN_NUM_REG_RD   , _param->_nb_write_unit,_param->_size_general_register);
     59        DELETE1_SIGNAL(out_WRITE_UNIT_IN_DATA_RD      , _param->_nb_write_unit,_param->_size_general_data    );
     60        DELETE1_SIGNAL(out_WRITE_UNIT_IN_WRITE_RE     , _param->_nb_write_unit,1                             );
     61        DELETE1_SIGNAL(out_WRITE_UNIT_IN_NUM_REG_RE   , _param->_nb_write_unit,_param->_size_special_register);
     62        DELETE1_SIGNAL(out_WRITE_UNIT_IN_DATA_RE      , _param->_nb_write_unit,_param->_size_special_data    );
     63        DELETE1_SIGNAL(out_WRITE_UNIT_IN_EXCEPTION    , _param->_nb_write_unit,_param->_size_exception       );
     64        DELETE1_SIGNAL(out_WRITE_UNIT_IN_NO_SEQUENCE  , _param->_nb_write_unit,1                             );
     65        DELETE1_SIGNAL(out_WRITE_UNIT_IN_ADDRESS      , _param->_nb_write_unit,_param->_size_general_data    );
     66     
     67        delete [] _destination;
    7368      }
    7469    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    7570
    76     delete [] _destination;
    7771    delete    _component;
    7872

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

    r81 r88  
    2525
    2626#ifdef STATISTICS
    27     _stat->end_cycle();
     27    if (usage_is_set(_usage,USE_STATISTICS))
     28      _stat->end_cycle();
    2829#endif   
    2930
    … …  
    3132    // Evaluation before read the ouput signal
    3233//  sc_start(0);
    33     _interfaces->testbench();
     34    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
     35      _interfaces->testbench();
    3436#endif
    3537

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

    r81 r88  
    3030
    3131    for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
    32       {
    33         bool       ack = false;
    34 
    35         log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION,"Test execute_unit[%d]",i);
    36 
    37         if (PORT_READ(in_EXECUTE_UNIT_OUT_VAL [i]) == true)
    38           {
    39             log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION," * have a valid entry.");
    40            
    41             Tcontext_t context_id    = (_param->_have_port_context_id   )?PORT_READ(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [i]):0;
    42             Tcontext_t front_end_id  = (_param->_have_port_front_end_id )?PORT_READ(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [i]):0;
    43             Tcontext_t ooo_engine_id = (_param->_have_port_ooo_engine_id)?PORT_READ(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [i]):0;
    44             Tcontext_t num_thread    = get_num_thread(context_id   , _param->_size_context_id   ,
    45                                                       front_end_id , _param->_size_front_end_id ,
    46                                                       ooo_engine_id, _param->_size_ooo_engine_id);
     32      for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
     33        {
     34          bool       ack = false;
     35         
     36          log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION,"Test execute_unit[%d][%d]",i,j);
     37         
     38          if (PORT_READ(in_EXECUTE_UNIT_OUT_VAL [i][j]) == true)
     39            {
     40              log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION," * have a valid entry.");
     41             
     42              Tcontext_t context_id    = (_param->_have_port_context_id   )?PORT_READ(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [i][j]):0;
     43              Tcontext_t front_end_id  = (_param->_have_port_front_end_id )?PORT_READ(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [i][j]):0;
     44              Tcontext_t ooo_engine_id = (_param->_have_port_ooo_engine_id)?PORT_READ(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [i][j]):0;
     45              Tcontext_t num_thread    = get_num_thread(context_id   , _param->_size_context_id   ,
     46                                                        front_end_id , _param->_size_front_end_id ,
     47                                                        ooo_engine_id, _param->_size_ooo_engine_id);
    4748#ifdef DEBUG_TEST
    48             if (_destination[i][num_thread].empty())
    49               throw ERRORMORPHEO(FUNCTION,"Invalid Operation : They have no write_unit to receive a operation from the execute_unit ["+toString(i)+"], thread ["+toString(num_thread)+"].");
     49              if (_destination[i][j][num_thread].empty())
     50                throw ERRORMORPHEO(FUNCTION,"Invalid Operation : They have no write_unit to receive a operation from the execute_unit ["+toString(i)+"]["+toString(j)+"], thread ["+toString(num_thread)+"].");
    5051#endif
    51 
    52             // find a free write_unit
    53             for (std::list<uint32_t>::iterator it=_destination[i][num_thread].begin();
    54                  (it != _destination[i][num_thread].end()) and (ack == false);
    55                  it++)
    56               {
    57                 uint32_t dest = *it;
    58 
    59                 log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION,"   * Test destination [%d].",dest);
    60                            
    61                 if (write_unit_use [dest] == false)
    62                   {
    63                     log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION,"     * Is ok! Link.");
    64                     // have find !!!
    65                     ack                   = true;
    66                     write_unit_use [dest] = true;
    67 
    68                     if (_param->_have_port_context_id)
    69                     PORT_WRITE(out_WRITE_UNIT_IN_CONTEXT_ID            [dest], PORT_READ(in_EXECUTE_UNIT_OUT_CONTEXT_ID            [i]));
    70                     if (_param->_have_port_front_end_id)
    71                     PORT_WRITE(out_WRITE_UNIT_IN_FRONT_END_ID          [dest], PORT_READ(in_EXECUTE_UNIT_OUT_FRONT_END_ID          [i]));
    72                     if (_param->_have_port_ooo_engine_id)
    73                     PORT_WRITE(out_WRITE_UNIT_IN_OOO_ENGINE_ID         [dest], PORT_READ(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID         [i]));
    74                     if (_param->_have_port_packet_id)
    75                     PORT_WRITE(out_WRITE_UNIT_IN_PACKET_ID             [dest], PORT_READ(in_EXECUTE_UNIT_OUT_PACKET_ID             [i]));
    76                   //PORT_WRITE(out_WRITE_UNIT_IN_OPERATION             [dest], PORT_READ(in_EXECUTE_UNIT_OUT_OPERATION             [i]));
    77                     PORT_WRITE(out_WRITE_UNIT_IN_TYPE                  [dest], PORT_READ(in_EXECUTE_UNIT_OUT_TYPE                  [i]));
    78                     PORT_WRITE(out_WRITE_UNIT_IN_WRITE_RD              [dest], PORT_READ(in_EXECUTE_UNIT_OUT_WRITE_RD              [i]));
    79                     PORT_WRITE(out_WRITE_UNIT_IN_NUM_REG_RD            [dest], PORT_READ(in_EXECUTE_UNIT_OUT_NUM_REG_RD            [i]));
    80                     PORT_WRITE(out_WRITE_UNIT_IN_DATA_RD               [dest], PORT_READ(in_EXECUTE_UNIT_OUT_DATA_RD               [i]));
    81                     PORT_WRITE(out_WRITE_UNIT_IN_WRITE_RE              [dest], PORT_READ(in_EXECUTE_UNIT_OUT_WRITE_RE              [i]));
    82                     PORT_WRITE(out_WRITE_UNIT_IN_NUM_REG_RE            [dest], PORT_READ(in_EXECUTE_UNIT_OUT_NUM_REG_RE            [i]));
    83                     PORT_WRITE(out_WRITE_UNIT_IN_DATA_RE               [dest], PORT_READ(in_EXECUTE_UNIT_OUT_DATA_RE               [i]));
    84                     PORT_WRITE(out_WRITE_UNIT_IN_EXCEPTION             [dest], PORT_READ(in_EXECUTE_UNIT_OUT_EXCEPTION             [i]));
    85                     PORT_WRITE(out_WRITE_UNIT_IN_NO_SEQUENCE           [dest], PORT_READ(in_EXECUTE_UNIT_OUT_NO_SEQUENCE           [i]));
    86                     PORT_WRITE(out_WRITE_UNIT_IN_ADDRESS               [dest], PORT_READ(in_EXECUTE_UNIT_OUT_ADDRESS               [i]));
    87                   }
    88               }
    89           }
    90         PORT_WRITE(out_EXECUTE_UNIT_OUT_ACK [i], ack);
     52             
     53              // find a free write_unit
     54              for (std::list<uint32_t>::iterator it=_destination[i][j][num_thread].begin();
     55                   (it != _destination[i][j][num_thread].end()) and (ack == false);
     56                   it++)
     57                {
     58                  uint32_t dest = *it;
     59                 
     60                  log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION,"   * Test destination [%d].",dest);
     61                 
     62                  if (write_unit_use [dest] == false)
     63                    {
     64                      log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION,"     * Is ok! Link.");
     65                      // have find !!!
     66                      ack                   = true;
     67                      write_unit_use [dest] = true;
     68                     
     69                      if (_param->_have_port_context_id)
     70                      PORT_WRITE(out_WRITE_UNIT_IN_CONTEXT_ID            [dest], context_id);
     71                      if (_param->_have_port_front_end_id)
     72                      PORT_WRITE(out_WRITE_UNIT_IN_FRONT_END_ID          [dest], front_end_id);
     73                      if (_param->_have_port_ooo_engine_id)
     74                      PORT_WRITE(out_WRITE_UNIT_IN_OOO_ENGINE_ID         [dest], ooo_engine_id);
     75                      if (_param->_have_port_rob_ptr  )
     76                      PORT_WRITE(out_WRITE_UNIT_IN_PACKET_ID             [dest], PORT_READ(in_EXECUTE_UNIT_OUT_PACKET_ID             [i][j]));
     77                  //  PORT_WRITE(out_WRITE_UNIT_IN_OPERATION             [dest], PORT_READ(in_EXECUTE_UNIT_OUT_OPERATION             [i][j]));
     78                      PORT_WRITE(out_WRITE_UNIT_IN_TYPE                  [dest], PORT_READ(in_EXECUTE_UNIT_OUT_TYPE                  [i][j]));
     79                      PORT_WRITE(out_WRITE_UNIT_IN_WRITE_RD              [dest], PORT_READ(in_EXECUTE_UNIT_OUT_WRITE_RD              [i][j]));
     80                      PORT_WRITE(out_WRITE_UNIT_IN_NUM_REG_RD            [dest], PORT_READ(in_EXECUTE_UNIT_OUT_NUM_REG_RD            [i][j]));
     81                      PORT_WRITE(out_WRITE_UNIT_IN_DATA_RD               [dest], PORT_READ(in_EXECUTE_UNIT_OUT_DATA_RD               [i][j]));
     82                      PORT_WRITE(out_WRITE_UNIT_IN_WRITE_RE              [dest], PORT_READ(in_EXECUTE_UNIT_OUT_WRITE_RE              [i][j]));
     83                      PORT_WRITE(out_WRITE_UNIT_IN_NUM_REG_RE            [dest], PORT_READ(in_EXECUTE_UNIT_OUT_NUM_REG_RE            [i][j]));
     84                      PORT_WRITE(out_WRITE_UNIT_IN_DATA_RE               [dest], PORT_READ(in_EXECUTE_UNIT_OUT_DATA_RE               [i][j]));
     85                      PORT_WRITE(out_WRITE_UNIT_IN_EXCEPTION             [dest], PORT_READ(in_EXECUTE_UNIT_OUT_EXCEPTION             [i][j]));
     86                      PORT_WRITE(out_WRITE_UNIT_IN_NO_SEQUENCE           [dest], PORT_READ(in_EXECUTE_UNIT_OUT_NO_SEQUENCE           [i][j]));
     87                      PORT_WRITE(out_WRITE_UNIT_IN_ADDRESS               [dest], PORT_READ(in_EXECUTE_UNIT_OUT_ADDRESS               [i][j]));
     88                    }
     89                }
     90            }
     91          PORT_WRITE(out_EXECUTE_UNIT_OUT_ACK [i][j], ack);
    9192      }
    9293

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

    r81 r88  
    2727      {
    2828        // Flush routing_table
    29         for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
    30           for (uint32_t j=0; j<_param->_nb_thread; j++)
    31               _destination [i][j].clear();
     29        for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
     30          for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
     31            for (uint32_t j=0; j<_param->_nb_thread; j++)
     32              _destination [x][y][j].clear();
    3233       
    3334        // Fill routing table
    34         for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
    35           for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
    36             // Test if link between src and dest
    37             if (_param->_table_routing [i][j])
    38               // Test the thread accepted by the execute_unit
    39               for (uint32_t k=0; k<_param->_nb_thread; k++)
    40                 if (_param->_table_thread[j][k])
    41                   // push_back == minor have a better priority
    42                   _destination [i][k].push_back(j);
     35        for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
     36          for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
     37            for (uint32_t j=0; j<_param->_nb_write_unit; j++)
     38              // Test if link between src and dest
     39              if (_param->_table_routing [x][y][j])
     40                // Test the thread accepted by the execute_unit
     41                for (uint32_t k=0; k<_param->_nb_thread; k++)
     42                  if (_param->_table_thread[j][k])
     43                    // push_back == minor have a better priority
     44                    _destination [x][y][k].push_back(j);
    4345      }
    4446    else
    4547      {
    4648        if (_param->_priority == PRIORITY_ROUND_ROBIN)
    47           for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
    48             for (uint32_t j=0; j<_param->_nb_thread; j++)
    49               if (_destination [i][j].size() > 1)
    50                 {
    51                   // Head queue became the Tail queue
    52                   _destination [i][j].push_back(_destination [i][j].front());
    53                   _destination [i][j].pop_front();
    54                 }
     49          for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
     50            for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
     51              for (uint32_t j=0; j<_param->_nb_thread; j++)
     52                if (_destination [x][y][j].size() > 1)
     53                  {
     54                    // Head queue became the Tail queue
     55                    _destination [x][y][j].push_back(_destination [x][y][j].front());
     56                    _destination [x][y][j].pop_front();
     57                  }
    5558      }
    56 
    57 
     59   
     60   
    5861#if (DEBUG >= DEBUG_TRACE)
    5962    // Print
    6063    log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION,"Routing Table");
    61     for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
    62       for (uint32_t j=0; j<_param->_nb_thread; j++)
    63         for (std::list<uint32_t>::iterator k=_destination[i][j].begin();
    64              k != _destination[i][j].end();
    65              k++)
    66           log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION,"  * Execute_unit [%d], send at the write_unit [%d], the operation of thread [%d].",i,*k,j);
     64    for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
     65      for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
     66        for (uint32_t j=0; j<_param->_nb_thread; j++)
     67          for (std::list<uint32_t>::iterator k=_destination[x][y][j].begin();
     68               k != _destination[x][y][j].end();
     69               k++)
     70            log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION,"  * Execute_unit [%d][%d], send at the write_unit [%d], the operation of thread [%d].",x,y,*k,j);
    6771#endif
    6872

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

    r81 r88  
    77
    88#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/include/Parameters.h"
    9 
     9#include "Common/include/Max.h"
    1010namespace morpheo {
    1111namespace behavioural {
    … …  
    2020#define FUNCTION "Execution_unit_to_Write_unit::Parameters"
    2121  Parameters::Parameters (uint32_t    nb_execute_unit              ,
     22                          uint32_t  * nb_execute_unit_port         ,//[nb_execute_unit]
    2223                          uint32_t    nb_write_unit                ,
    2324                          uint32_t    nb_context                   ,
    … …  
    3031                          uint32_t    nb_special_register          ,
    3132                          Tpriority_t priority                     ,
    32                           bool     ** table_routing                ,
    33                           bool     ** table_thread                 ):
    34     _nb_execute_unit         (nb_execute_unit    ),
    35     _nb_write_unit           (nb_write_unit      ),
    36     _nb_context              (nb_context         ),
    37     _nb_front_end            (nb_front_end       ),
    38     _nb_ooo_engine           (nb_ooo_engine      ),
    39     _nb_packet               (nb_packet          ),
    40     _size_general_data       (size_general_data  ),
    41     _size_special_data       (size_special_data  ),
    42     _nb_general_register     (nb_general_register),
    43     _nb_special_register     (nb_special_register),
    44     _priority                (priority           ),
    45    
    46     _size_context_id         (log2(nb_context         )),
    47     _size_front_end_id       (log2(nb_front_end       )),
    48     _size_ooo_engine_id      (log2(nb_ooo_engine      )),
    49     _size_packet_id          (log2(nb_packet          )),
    50     _size_general_register   (log2(nb_general_register)),
    51     _size_special_register   (log2(nb_special_register)),
    52    
    53     _have_port_context_id    (_size_context_id    > 0),
    54     _have_port_front_end_id  (_size_front_end_id  > 0),
    55     _have_port_ooo_engine_id (_size_ooo_engine_id > 0),
    56     _have_port_packet_id     (_size_packet_id     > 0),
    57 
    58     _nb_thread               (get_nb_thread (nb_context, nb_front_end, nb_ooo_engine))
     33                          bool    *** table_routing                ,//[nb_execute_unit][nb_execute_unit_port][nb_write_unit]
     34                          bool     ** table_thread                 ,//[nb_write_unit][nb_thread]                           
     35                          bool        is_toplevel                  )
    5936  {
    6037    log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"Begin");
    6138
    62     _table_routing = table_routing ;
    63     _table_thread  = table_thread  ;
     39    _nb_execute_unit         = nb_execute_unit     ;
     40    _nb_execute_unit_port    = nb_execute_unit_port;
     41    _nb_write_unit           = nb_write_unit       ;
     42    _nb_context              = nb_context          ;
     43    _nb_front_end            = nb_front_end        ;
     44    _nb_ooo_engine           = nb_ooo_engine       ;
     45    _nb_packet               = nb_packet           ;
     46    _nb_general_register     = nb_general_register ;
     47    _nb_special_register     = nb_special_register ;
     48    _priority                = priority            ;
     49    _table_routing           = table_routing       ;
     50    _table_thread            = table_thread        ;
     51
     52    _max_nb_execute_unit_port= max<uint32_t>(_nb_execute_unit_port, _nb_execute_unit);
     53
     54    _nb_thread               = get_nb_thread (nb_context, nb_front_end, nb_ooo_engine);
    6455
    6556    test();
     57
     58    if (is_toplevel)
     59      {
     60        _size_context_id         = log2(nb_context         );
     61        _size_front_end_id       = log2(nb_front_end       );
     62        _size_ooo_engine_id      = log2(nb_ooo_engine      );
     63        _size_rob_ptr            = log2(nb_packet          );
     64        _size_general_register   = log2(nb_general_register);
     65        _size_special_register   = log2(nb_special_register);
     66        _size_general_data       = size_general_data  ;
     67        _size_special_data       = size_special_data  ;
     68       
     69        _have_port_context_id    = _size_context_id    > 0;
     70        _have_port_front_end_id  = _size_front_end_id  > 0;
     71        _have_port_ooo_engine_id = _size_ooo_engine_id > 0;
     72        _have_port_rob_ptr       = _size_rob_ptr       > 0;
     73
     74        copy();
     75      }
     76
    6677    log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"End");
    6778  };
    6879 
     80// #undef  FUNCTION
     81// #define FUNCTION "Execution_unit_to_Write_unit::Parameters (copy)"
     82//   Parameters::Parameters (Parameters & param) 
     83//   {
     84//     log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"Begin");
     85
     86//     test();
     87//     log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"End");
     88//   };
     89
    6990#undef  FUNCTION
    70 #define FUNCTION "Execution_unit_to_Write_unit::Parameters (copy)"
    71   Parameters::Parameters (Parameters & param):
    72     _nb_execute_unit         (param._nb_execute_unit        ),
    73     _nb_write_unit           (param._nb_write_unit          ),
    74     _nb_context              (param._nb_context             ),
    75     _nb_front_end            (param._nb_front_end           ),
    76     _nb_ooo_engine           (param._nb_ooo_engine          ),
    77     _nb_packet               (param._nb_packet              ),
    78     _size_general_data       (param._size_general_data      ),
    79     _size_special_data       (param._size_special_data      ),
    80     _nb_general_register     (param._nb_general_register    ),
    81     _nb_special_register     (param._nb_special_register    ),
    82     _priority                (param._priority               ),
    83 
    84     _size_context_id         (param._size_context_id        ),
    85     _size_front_end_id       (param._size_front_end_id      ),
    86     _size_ooo_engine_id      (param._size_ooo_engine_id     ),
    87     _size_packet_id          (param._size_packet_id         ),
    88     _size_general_register   (param._size_general_register  ),
    89     _size_special_register   (param._size_special_register  ),
    90 
    91     _have_port_context_id    (param._have_port_context_id   ),
    92     _have_port_front_end_id  (param._have_port_front_end_id ),
    93     _have_port_ooo_engine_id (param._have_port_ooo_engine_id),
    94     _have_port_packet_id     (param._have_port_packet_id    ),
    95 
    96     _nb_thread               (param._nb_thread              )
     91#define FUNCTION "Execution_unit_to_Write_unit::~Parameters"
     92  Parameters::~Parameters (void)
    9793  {
    9894    log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"Begin");
    99 
    100     _table_routing = param._table_routing ;
    101     _table_thread  = param._table_thread  ;
    102 
    103     test();
    10495    log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"End");
    10596  };
    10697
    10798#undef  FUNCTION
    108 #define FUNCTION "Execution_unit_to_Write_unit::~Parameters"
    109   Parameters::~Parameters ()
     99#define FUNCTION "Execution_unit_to_Write_unit::copy"
     100  void Parameters::copy (void)
    110101  {
    111102    log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"Begin");

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

    r81 r88  
    2424  {
    2525    log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"Begin");
     26   
     27    Parameters_test test("Execution_unit_to_Write_unit");
     28   
     29    bool is_link [_nb_execute_unit][_max_nb_execute_unit_port];
     30    for (uint32_t i=0; i<_nb_execute_unit; i++)
     31      for (uint32_t j=0; j<_nb_execute_unit_port[i]; j++)
     32        is_link[i][j] = false;
     33       
     34    for (uint32_t i=0; i<_nb_execute_unit; i++)
     35      for (uint32_t j=0; j<_nb_execute_unit_port[i]; j++)
     36        for (uint32_t k=0; k<_nb_write_unit; k++)
     37          {
     38            log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION,"[%d][%d][%d]",i,j,k);
     39           
     40            if (_table_routing [i][j][k] == true)
     41              {
     42                log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION," * is link");
    2643
    27     Parameters_test test("Execution_unit_to_Write_unit");
     44                is_link [i][j] = true;
     45                break;
     46              }
     47          }
    2848
    2949    for (uint32_t i=0; i<_nb_execute_unit; i++)
    30       {
    31         uint32_t j;
    32         for (j=0; j<_nb_write_unit; j++)
    33           if (_table_routing [i][j] == true)
    34             break;
    35 
    36         if (j == _nb_write_unit)
    37           test.error("The execute_unit ["+toString(i)+"] is link with none write_unit.");
    38       }   
    39 
     50      for (uint32_t j=0; j<_nb_execute_unit_port[i]; j++)
     51        if (not is_link[i][j])
     52          test.error(toString(_("The execute_unit [%d][%d] is link with none write_unit.\n"),i,j));
     53   
    4054    for (uint32_t i=0; i<_nb_write_unit; i++)
    4155      {
    … …  
    4458          if (_table_thread [i][j] == true)
    4559            break;
    46 
     60       
    4761        if (j == _nb_thread)
    48           test.error("The write_unit ["+toString(i)+"] have none source's thread.");
     62          test.error(toString(_("The write_unit [%d] have none source's thread.\n"),i));
    4963      }   
    5064
    5165    if ( (_priority != PRIORITY_STATIC     ) and
    5266         (_priority != PRIORITY_ROUND_ROBIN))
    53       test.error("Unsupported priority scheme. It must be Static or Round Robin.");
     67      test.error(_("Unsupported priority scheme. It must be Static or Round Robin.\n"));
    5468
    5569    log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"End");

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/Makefile

    r81 r88  
    2424library_clean                   : Read_unit_to_Execution_unit_library_clean
    2525
     26local_clean                     :
     27
    2628include                         $(DIR_COMPONENT)/Makefile.deps
    2729include                         $(DIR_MORPHEO)/Behavioural/Makefile.flags

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

    r81 r88  
    11Read_unit_to_Execution_unit
    221       1       *2      # nb_read_unit           
    3 2       2       *2      # nb_execute_unit       
     31       1       +1      # nb_read_unit_port    [0] [nb_read_unit]
     42       2       *2      # nb_execute_unit
     51       1       +1      # nb_execute_unit_port [0] [nb_execute_unit]
     61       1       +1      # nb_execute_unit_port [1] [nb_execute_unit]
    471       1       *2      # nb_context             
    581       1       *2      # nb_front_end           
    … …  
    13164       4       *2      # size_load_queue       
    14170       1       +1      # priority
    15 1       1       +1      # table_routing        [0][0]
    16 1       1       +1      # table_routing        [0][1]
     181       1       +1      # table_routing        [0][0][0]
     191       1       +1      # table_routing        [0][1][0]
    17200       0       +1      # table_execute_type   [0][TYPE_ALU    ]
    18210       0       +1      # table_execute_type   [0][TYPE_SHIFT  ]
    19220       0       +1      # table_execute_type   [0][TYPE_MOVE   ]
    20230       0       +1      # table_execute_type   [0][TYPE_TEST   ]
    21 0       0       +1      # table_execute_type   [0][TYPE_MUL_DIV]
     240       0       +1      # table_execute_type   [0][TYPE_MUL    ]
     250       0       +1      # table_execute_type   [0][TYPE_DIV    ]
    22260       0       +1      # table_execute_type   [0][TYPE_EXTEND ]
    23270       0       +1      # table_execute_type   [0][TYPE_FIND   ]
    … …  
    30341       1       +1      # table_execute_type   [1][TYPE_MOVE   ]
    31351       1       +1      # table_execute_type   [1][TYPE_TEST   ]
    32 1       1       +1      # table_execute_type   [1][TYPE_MUL_DIV]
     361       1       +1      # table_execute_type   [1][TYPE_MUL    ]
     371       1       +1      # table_execute_type   [1][TYPE_DIV    ]
    33381       1       +1      # table_execute_type   [1][TYPE_EXTEND ]
    34391       1       +1      # table_execute_type   [1][TYPE_FIND   ]

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

    r81 r88  
    11Read_unit_to_Execution_unit
    223       3       *2      # nb_read_unit           
     31       1       +1      # nb_read_unit_port    [0] [nb_read_unit]
     42       2       +1      # nb_read_unit_port    [1] [nb_read_unit]
     54       4       +1      # nb_read_unit_port    [2] [nb_read_unit]
    364       4       *2      # nb_execute_unit       
     71       1       +1      # nb_execute_unit_port [0] [nb_execute_unit]
     81       1       +1      # nb_execute_unit_port [1] [nb_execute_unit]
     91       1       +1      # nb_execute_unit_port [2] [nb_execute_unit]
     101       1       +1      # nb_execute_unit_port [3] [nb_execute_unit]
    4111       1       *2      # nb_context             
    5121       1       *2      # nb_front_end           
    … …  
    13201       4       *4      # size_load_queue       
    14210       1       +1      # priority
    15 1       1       +1      # table_routing        [0][0]
    16 0       0       +1      # table_routing        [0][1]
    17 0       0       +1      # table_routing        [0][2]
    18 0       0       +1      # table_routing        [0][3]
    19 0       0       +1      # table_routing        [1][0]
    20 1       1       +1      # table_routing        [1][1]
    21 1       1       +1      # table_routing        [1][2]
    22 0       0       +1      # table_routing        [1][3]
    23 0       0       +1      # table_routing        [2][0]
    24 0       0       +1      # table_routing        [2][1]
    25 1       1       +1      # table_routing        [2][2]
    26 1       1       +1      # table_routing        [2][3]
     221       1       +1      # table_routing        [0][0][0]
     230       0       +1      # table_routing        [0][1][0]
     240       0       +1      # table_routing        [0][2][0]
     250       0       +1      # table_routing        [0][3][0]
     260       0       +1      # table_routing        [1][0][0]
     271       1       +1      # table_routing        [1][1][0]
     281       1       +1      # table_routing        [1][2][0]
     290       0       +1      # table_routing        [1][3][0]
     300       0       +1      # table_routing        [2][0][0]
     310       0       +1      # table_routing        [2][1][0]
     321       1       +1      # table_routing        [2][2][0]
     331       1       +1      # table_routing        [2][3][0]
    27340       0       +1      # table_execute_type   [0][TYPE_ALU    ]
    28350       0       +1      # table_execute_type   [0][TYPE_SHIFT  ]
    29360       0       +1      # table_execute_type   [0][TYPE_MOVE   ]
    30370       0       +1      # table_execute_type   [0][TYPE_TEST   ]
    31 0       0       +1      # table_execute_type   [0][TYPE_MUL_DIV]
     380       0       +1      # table_execute_type   [0][TYPE_MUL    ]
     390       0       +1      # table_execute_type   [0][TYPE_DIV    ]
    32400       0       +1      # table_execute_type   [0][TYPE_EXTEND ]
    33410       0       +1      # table_execute_type   [0][TYPE_FIND   ]
    … …  
    40481       1       +1      # table_execute_type   [1][TYPE_MOVE   ]
    41491       1       +1      # table_execute_type   [1][TYPE_TEST   ]
    42 1       1       +1      # table_execute_type   [1][TYPE_MUL_DIV]
     501       1       +1      # table_execute_type   [1][TYPE_MUL    ]
     511       1       +1      # table_execute_type   [1][TYPE_DIV    ]
    43521       1       +1      # table_execute_type   [1][TYPE_EXTEND ]
    44531       1       +1      # table_execute_type   [1][TYPE_FIND   ]
    … …  
    51600       0       +1      # table_execute_type   [2][TYPE_MOVE   ]
    52610       0       +1      # table_execute_type   [2][TYPE_TEST   ]
    53 0       0       +1      # table_execute_type   [2][TYPE_MUL_DIV]
     620       0       +1      # table_execute_type   [2][TYPE_MUL    ]
     630       0       +1      # table_execute_type   [2][TYPE_DIV    ]
    54640       0       +1      # table_execute_type   [2][TYPE_EXTEND ]
    55650       0       +1      # table_execute_type   [2][TYPE_FIND   ]
    … …  
    62721       1       +1      # table_execute_type   [3][TYPE_MOVE   ]
    63731       1       +1      # table_execute_type   [3][TYPE_TEST   ]
    64 0       0       +1      # table_execute_type   [3][TYPE_MUL_DIV]
     740       0       +1      # table_execute_type   [3][TYPE_MUL    ]
     750       0       +1      # table_execute_type   [3][TYPE_DIV    ]
    65761       1       +1      # table_execute_type   [3][TYPE_EXTEND ]
    66771       1       +1      # table_execute_type   [3][TYPE_FIND   ]

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

    r81 r88  
    11Read_unit_to_Execution_unit
    223       3       *2      # nb_read_unit           
     31       1       +1      # nb_read_unit_port    [0] [nb_read_unit]
     41       1       +1      # nb_read_unit_port    [1] [nb_read_unit]
     51       1       +1      # nb_read_unit_port    [2] [nb_read_unit]
    364       4       *2      # nb_execute_unit       
     71       1       +1      # nb_execute_unit_port [0] [nb_execute_unit]
     81       1       +1      # nb_execute_unit_port [1] [nb_execute_unit]
     91       1       +1      # nb_execute_unit_port [2] [nb_execute_unit]
     101       1       +1      # nb_execute_unit_port [3] [nb_execute_unit]
    4114       4       *2      # nb_context             
    5121       1       *2      # nb_front_end           
    … …  
    13204       4       *2      # size_load_queue       
    14210       1       +1      # priority
    15 1       1       +1      # table_routing        [0][0]
    16 0       0       +1      # table_routing        [0][1]
    17 0       0       +1      # table_routing        [0][2]
    18 0       0       +1      # table_routing        [0][3]
    19 0       0       +1      # table_routing        [1][0]
    20 1       1       +1      # table_routing        [1][1]
    21 1       1       +1      # table_routing        [1][2]
    22 0       0       +1      # table_routing        [1][3]
    23 0       0       +1      # table_routing        [2][0]
    24 0       0       +1      # table_routing        [2][1]
    25 1       1       +1      # table_routing        [2][2]
    26 1       1       +1      # table_routing        [2][3]
     221       1       +1      # table_routing        [0][0][0]
     230       0       +1      # table_routing        [0][1][0]
     240       0       +1      # table_routing        [0][2][0]
     250       0       +1      # table_routing        [0][3][0]
     260       0       +1      # table_routing        [1][0][0]
     271       1       +1      # table_routing        [1][1][0]
     281       1       +1      # table_routing        [1][2][0]
     290       0       +1      # table_routing        [1][3][0]
     300       0       +1      # table_routing        [2][0][0]
     310       0       +1      # table_routing        [2][1][0]
     321       1       +1      # table_routing        [2][2][0]
     331       1       +1      # table_routing        [2][3][0]
    27340       0       +1      # table_execute_type   [0][TYPE_ALU    ]
    28350       0       +1      # table_execute_type   [0][TYPE_SHIFT  ]
    29360       0       +1      # table_execute_type   [0][TYPE_MOVE   ]
    30370       0       +1      # table_execute_type   [0][TYPE_TEST   ]
    31 0       0       +1      # table_execute_type   [0][TYPE_MUL_DIV]
     380       0       +1      # table_execute_type   [0][TYPE_MUL    ]
     390       0       +1      # table_execute_type   [0][TYPE_DIV    ]
    32400       0       +1      # table_execute_type   [0][TYPE_EXTEND ]
    33410       0       +1      # table_execute_type   [0][TYPE_FIND   ]
    … …  
    40481       1       +1      # table_execute_type   [1][TYPE_MOVE   ]
    41491       1       +1      # table_execute_type   [1][TYPE_TEST   ]
    42 1       1       +1      # table_execute_type   [1][TYPE_MUL_DIV]
     501       1       +1      # table_execute_type   [1][TYPE_MUL    ]
     511       1       +1      # table_execute_type   [1][TYPE_DIV    ]
    43521       1       +1      # table_execute_type   [1][TYPE_EXTEND ]
    44531       1       +1      # table_execute_type   [1][TYPE_FIND   ]
    … …  
    51600       0       +1      # table_execute_type   [2][TYPE_MOVE   ]
    52610       0       +1      # table_execute_type   [2][TYPE_TEST   ]
    53 0       0       +1      # table_execute_type   [2][TYPE_MUL_DIV]
     620       0       +1      # table_execute_type   [2][TYPE_MUL    ]
     630       0       +1      # table_execute_type   [2][TYPE_DIV    ]
    54640       0       +1      # table_execute_type   [2][TYPE_EXTEND ]
    55650       0       +1      # table_execute_type   [2][TYPE_FIND   ]
    … …  
    62721       1       +1      # table_execute_type   [3][TYPE_MOVE   ]
    63731       1       +1      # table_execute_type   [3][TYPE_TEST   ]
    64 1       1       +1      # table_execute_type   [3][TYPE_MUL_DIV]
     741       1       +1      # table_execute_type   [3][TYPE_MUL    ]
     751       1       +1      # table_execute_type   [3][TYPE_DIV    ]
    65760       0       +1      # table_execute_type   [3][TYPE_EXTEND ]
    66770       0       +1      # table_execute_type   [3][TYPE_FIND   ]
    … …  
    84950       0       +1      # table_execute_thread [3][1]
    85960       0       +1      # table_execute_thread [3][2]
    86 1       1       +1      # table_execute_thread [3][3]
     971       1       +1      # table_execute_thread [3][3]   

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

    r81 r88  
    1515  err (_("list_params is :\n"));
    1616  err (_("  * nb_read_unit                                         (uint32_t)\n"));
     17  err (_("  * nb_read_unit_port    [nb_read_unit]                  (uint32_t)\n"));
    1718  err (_("  * nb_execute_unit                                      (uint32_t)\n"));
     19  err (_("  * nb_execute_unit_port [nb_execute_unit]               (uint32_t)\n"));
    1820  err (_("  * nb_context                                           (uint32_t)\n"));
    1921  err (_("  * nb_front_end                                         (uint32_t)\n"));
    … …  
    3335  err (_("    * [TYPE_MOVE   ]\n"));
    3436  err (_("    * [TYPE_TEST   ]\n"));
    35   err (_("    * [TYPE_MUL_DIV]\n"));
     37  err (_("    * [TYPE_MUL    ]\n"));
     38  err (_("    * [TYPE_DIV    ]\n"));
    3639  err (_("    * [TYPE_EXTEND ]\n"));
    3740  err (_("    * [TYPE_FIND   ]\n"));
    … …  
    5861  string      name                  =      argv[x++];
    5962  uint32_t    _nb_read_unit         = atoi(argv[x++]);
     63
     64  if (static_cast<uint32_t>(argc) < 2+NB_PARAMS+_nb_read_unit)
     65    usage (argc, argv);
     66
     67  uint32_t *  _nb_read_unit_port = new uint32_t [_nb_read_unit];
     68  for (uint32_t i=0; i<_nb_read_unit; i++)
     69    _nb_read_unit_port [i] = atoi(argv[x++]);
     70 
    6071  uint32_t    _nb_execute_unit      = atoi(argv[x++]);
     72
     73  if (static_cast<uint32_t>(argc) < 2+NB_PARAMS+_nb_read_unit+_nb_execute_unit)
     74    usage (argc, argv);
     75
     76  uint32_t    _sum_execute_unit_port = 0;
     77  uint32_t *  _nb_execute_unit_port = new uint32_t [_nb_execute_unit];
     78  for (uint32_t i=0; i<_nb_execute_unit; i++)
     79    {
     80      _nb_execute_unit_port [i] = atoi(argv[x++]);
     81      _sum_execute_unit_port += _nb_execute_unit_port [i];
     82    }
     83
    6184  uint32_t    _nb_context           = atoi(argv[x++]);
    6285  uint32_t    _nb_front_end         = atoi(argv[x++]);
    … …  
    7093  uint32_t    _size_load_queue      = atoi(argv[x++]);
    7194  Tpriority_t _priority             = fromString<Tpriority_t>(argv[x++]);
    72 
     95 
    7396  uint32_t    _nb_thread            = get_nb_thread(_nb_context, _nb_front_end, _nb_ooo_engine);
    7497
    75   if (static_cast<uint32_t>(argc) != 2+NB_PARAMS+(_nb_read_unit*_nb_execute_unit)+(_nb_execute_unit*11)+(_nb_execute_unit*_nb_thread))
    76     usage (argc, argv);
    77  
    78   bool ** _table_routing        ;
    79   bool ** _table_execute_type   ;
    80   bool ** _table_execute_thread ;
    81  
    82   _table_routing = new bool * [_nb_read_unit];
     98  msg("%d\n",argc);
     99  msg("%d\n",2+NB_PARAMS+(_nb_read_unit+_nb_execute_unit+(_nb_read_unit*_sum_execute_unit_port)+(_nb_execute_unit*12)+(_nb_execute_unit*_nb_thread)));
     100 
     101  if (static_cast<uint32_t>(argc) != 2+NB_PARAMS+(_nb_read_unit+_nb_execute_unit+(_nb_read_unit*_sum_execute_unit_port)+(_nb_execute_unit*12)+(_nb_execute_unit*_nb_thread)))
     102      usage (argc, argv);
     103 
     104  bool *** _table_routing        ;
     105  bool  ** _table_execute_type   ;
     106  bool  ** _table_execute_thread ;
     107 
     108  _table_routing = new bool ** [_nb_read_unit];
    83109  for (uint32_t i=0; i<_nb_read_unit; i++)
    84110    {
    85       _table_routing [i] = new bool [_nb_execute_unit];
     111      _table_routing [i] = new bool * [_nb_execute_unit];
    86112      for (uint32_t j=0; j<_nb_execute_unit; j++)
    87         _table_routing [i][j] = atoi(argv[x++]);
    88     }
    89 
     113        {
     114          _table_routing [i][j] = new bool [_nb_execute_unit_port [j]];
     115     
     116          for (uint32_t k=0; k<_nb_execute_unit_port [j]; k++)
     117            _table_routing [i][j][k] = atoi(argv[x++]);
     118        }
     119    }
     120     
    90121  _table_execute_type = new bool * [_nb_execute_unit];
    91122  for (uint32_t i=0; i<_nb_execute_unit; i++)
    … …  
    97128      _table_execute_type [i][TYPE_MOVE   ] = atoi(argv[x++]);
    98129      _table_execute_type [i][TYPE_TEST   ] = atoi(argv[x++]);
    99       _table_execute_type [i][TYPE_MUL_DIV] = atoi(argv[x++]);
     130      _table_execute_type [i][TYPE_MUL    ] = atoi(argv[x++]);
     131      _table_execute_type [i][TYPE_DIV    ] = atoi(argv[x++]);
    100132      _table_execute_type [i][TYPE_EXTEND ] = atoi(argv[x++]);
    101133      _table_execute_type [i][TYPE_FIND   ] = atoi(argv[x++]);
    … …  
    119151      morpheo::behavioural::core::multi_execute_loop::execute_loop::network::read_unit_to_execution_unit::Parameters * param = new morpheo::behavioural::core::multi_execute_loop::execute_loop::network::read_unit_to_execution_unit::Parameters
    120152        (_nb_read_unit         ,
     153         _nb_read_unit_port    ,
    121154         _nb_execute_unit      ,
     155         _nb_execute_unit_port ,
    122156         _nb_context           ,
    123157         _nb_front_end         ,
    … …  
    133167         _table_routing        ,
    134168         _table_execute_type   ,
    135          _table_execute_thread
     169         _table_execute_thread ,
     170         true // is_toplevel
    136171         );
    137172     
    … …  
    151186    }
    152187
    153   delete [] _table_routing        ;
     188  delete [] _nb_read_unit_port;
     189  delete [] _nb_execute_unit_port ;
     190
     191  for (uint32_t i=0; i<_nb_read_unit; i++)
     192    {
     193      for (uint32_t j=0; j<_nb_execute_unit; j++)
     194        delete [] _table_routing [i][j];
     195      delete [] _table_routing [i];
     196    }
     197  delete [] _table_routing;
     198
     199
     200  for (uint32_t i=0; i<_nb_execute_unit; i++)
     201    delete [] _table_execute_type [i];
    154202  delete [] _table_execute_type   ;
     203
     204  for (uint32_t i=0; i<_nb_execute_unit; i++)
     205    delete [] _table_execute_thread [i];
    155206  delete [] _table_execute_thread ;
     207
    156208
    157209  return (EXIT_SUCCESS);

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

    r82 r88  
    8484#endif
    8585
     86  Tusage_t _usage = USE_ALL;
     87
     88//   _usage = usage_unset(_usage,USE_SYSTEMC              );
     89//   _usage = usage_unset(_usage,USE_VHDL                 );
     90//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
     91//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
     92//   _usage = usage_unset(_usage,USE_POSITION             );
     93   _usage = usage_unset(_usage,USE_STATISTICS           );
     94//   _usage = usage_unset(_usage,USE_INFORMATION          );
     95
    8696  Read_unit_to_Execution_unit * _Read_unit_to_Execution_unit = new Read_unit_to_Execution_unit
    8797    (name.c_str(),
    … …  
    90100#endif
    91101     _param,
    92      USE_ALL);
     102     _usage);
    93103 
    94104#ifdef SYSTEMC
    … …  
    101111  sc_signal<Tcontrol_t> *  in_NRESET = new sc_signal<Tcontrol_t> ("NRESET");
    102112
    103   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_VAL                  ," in_READ_UNIT_OUT_VAL"                  ,Tcontrol_t        ,_param->_nb_read_unit);
    104   ALLOC1_SC_SIGNAL(out_READ_UNIT_OUT_ACK                  ,"out_READ_UNIT_OUT_ACK"                  ,Tcontrol_t        ,_param->_nb_read_unit);
    105   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_CONTEXT_ID           ," in_READ_UNIT_OUT_CONTEXT_ID"           ,Tcontext_t        ,_param->_nb_read_unit);
    106   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_FRONT_END_ID         ," in_READ_UNIT_OUT_FRONT_END_ID"         ,Tcontext_t        ,_param->_nb_read_unit);
    107   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_OOO_ENGINE_ID        ," in_READ_UNIT_OUT_OOO_ENGINE_ID"        ,Tcontext_t        ,_param->_nb_read_unit);
    108   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_PACKET_ID            ," in_READ_UNIT_OUT_PACKET_ID"            ,Tpacket_t         ,_param->_nb_read_unit);
    109   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_OPERATION            ," in_READ_UNIT_OUT_OPERATION"            ,Toperation_t      ,_param->_nb_read_unit);
    110   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_TYPE                 ," in_READ_UNIT_OUT_TYPE"                 ,Ttype_t           ,_param->_nb_read_unit);
    111   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE," in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,_param->_nb_read_unit);
    112   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ," in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE" ,Tlsq_ptr_t        ,_param->_nb_read_unit);
    113   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_HAS_IMMEDIAT         ," in_READ_UNIT_OUT_HAS_IMMEDIAT"         ,Tcontrol_t        ,_param->_nb_read_unit);
    114   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_IMMEDIAT             ," in_READ_UNIT_OUT_IMMEDIAT"             ,Tgeneral_data_t   ,_param->_nb_read_unit);
    115   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_DATA_RA              ," in_READ_UNIT_OUT_DATA_RA"              ,Tgeneral_data_t   ,_param->_nb_read_unit);
    116   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_DATA_RB              ," in_READ_UNIT_OUT_DATA_RB"              ,Tgeneral_data_t   ,_param->_nb_read_unit);
    117   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_DATA_RC              ," in_READ_UNIT_OUT_DATA_RC"              ,Tspecial_data_t   ,_param->_nb_read_unit);
    118   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_WRITE_RD             ," in_READ_UNIT_OUT_WRITE_RD"             ,Tcontrol_t        ,_param->_nb_read_unit);
    119   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_NUM_REG_RD           ," in_READ_UNIT_OUT_NUM_REG_RD"           ,Tgeneral_address_t,_param->_nb_read_unit);
    120   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_WRITE_RE             ," in_READ_UNIT_OUT_WRITE_RE"             ,Tcontrol_t        ,_param->_nb_read_unit);
    121   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_NUM_REG_RE           ," in_READ_UNIT_OUT_NUM_REG_RE"           ,Tspecial_address_t,_param->_nb_read_unit);
    122   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_VAL                  ,"out_EXECUTE_UNIT_IN_VAL"                  ,Tcontrol_t        ,_param->_nb_execute_unit);
    123   ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_IN_ACK                  ," in_EXECUTE_UNIT_IN_ACK"                  ,Tcontrol_t        ,_param->_nb_execute_unit);
    124   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_CONTEXT_ID           ,"out_EXECUTE_UNIT_IN_CONTEXT_ID"           ,Tcontext_t        ,_param->_nb_execute_unit);
    125   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_FRONT_END_ID         ,"out_EXECUTE_UNIT_IN_FRONT_END_ID"         ,Tcontext_t        ,_param->_nb_execute_unit);
    126   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ,"out_EXECUTE_UNIT_IN_OOO_ENGINE_ID"        ,Tcontext_t        ,_param->_nb_execute_unit);
    127   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_PACKET_ID            ,"out_EXECUTE_UNIT_IN_PACKET_ID"            ,Tpacket_t         ,_param->_nb_execute_unit);
    128   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_OPERATION            ,"out_EXECUTE_UNIT_IN_OPERATION"            ,Toperation_t      ,_param->_nb_execute_unit);
    129   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_TYPE                 ,"out_EXECUTE_UNIT_IN_TYPE"                 ,Ttype_t           ,_param->_nb_execute_unit);
    130   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE,"out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,_param->_nb_execute_unit);
    131   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,"out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE" ,Tlsq_ptr_t        ,_param->_nb_execute_unit);
    132   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ,"out_EXECUTE_UNIT_IN_HAS_IMMEDIAT"         ,Tcontrol_t        ,_param->_nb_execute_unit);
    133   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_IMMEDIAT             ,"out_EXECUTE_UNIT_IN_IMMEDIAT"             ,Tgeneral_data_t   ,_param->_nb_execute_unit);
    134   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RA              ,"out_EXECUTE_UNIT_IN_DATA_RA"              ,Tgeneral_data_t   ,_param->_nb_execute_unit);
    135   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RB              ,"out_EXECUTE_UNIT_IN_DATA_RB"              ,Tgeneral_data_t   ,_param->_nb_execute_unit);
    136   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RC              ,"out_EXECUTE_UNIT_IN_DATA_RC"              ,Tspecial_data_t   ,_param->_nb_execute_unit);
    137   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_WRITE_RD             ,"out_EXECUTE_UNIT_IN_WRITE_RD"             ,Tcontrol_t        ,_param->_nb_execute_unit);
    138   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_NUM_REG_RD           ,"out_EXECUTE_UNIT_IN_NUM_REG_RD"           ,Tgeneral_address_t,_param->_nb_execute_unit);
    139   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_WRITE_RE             ,"out_EXECUTE_UNIT_IN_WRITE_RE"             ,Tcontrol_t        ,_param->_nb_execute_unit);
    140   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_NUM_REG_RE           ,"out_EXECUTE_UNIT_IN_NUM_REG_RE"           ,Tspecial_address_t,_param->_nb_execute_unit);
     113  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_VAL                  ," in_READ_UNIT_OUT_VAL"                  ,Tcontrol_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     114  ALLOC2_SC_SIGNAL(out_READ_UNIT_OUT_ACK                  ,"out_READ_UNIT_OUT_ACK"                  ,Tcontrol_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     115  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_CONTEXT_ID           ," in_READ_UNIT_OUT_CONTEXT_ID"           ,Tcontext_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     116  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_FRONT_END_ID         ," in_READ_UNIT_OUT_FRONT_END_ID"         ,Tcontext_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     117  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_OOO_ENGINE_ID        ," in_READ_UNIT_OUT_OOO_ENGINE_ID"        ,Tcontext_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     118  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_PACKET_ID            ," in_READ_UNIT_OUT_PACKET_ID"            ,Tpacket_t         ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     119  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_OPERATION            ," in_READ_UNIT_OUT_OPERATION"            ,Toperation_t      ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     120  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_TYPE                 ," in_READ_UNIT_OUT_TYPE"                 ,Ttype_t           ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     121  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE," in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     122  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ," in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE" ,Tlsq_ptr_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     123  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_HAS_IMMEDIAT         ," in_READ_UNIT_OUT_HAS_IMMEDIAT"         ,Tcontrol_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     124  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_IMMEDIAT             ," in_READ_UNIT_OUT_IMMEDIAT"             ,Tgeneral_data_t   ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     125  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_DATA_RA              ," in_READ_UNIT_OUT_DATA_RA"              ,Tgeneral_data_t   ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     126  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_DATA_RB              ," in_READ_UNIT_OUT_DATA_RB"              ,Tgeneral_data_t   ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     127  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_DATA_RC              ," in_READ_UNIT_OUT_DATA_RC"              ,Tspecial_data_t   ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     128  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_WRITE_RD             ," in_READ_UNIT_OUT_WRITE_RD"             ,Tcontrol_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     129  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_NUM_REG_RD           ," in_READ_UNIT_OUT_NUM_REG_RD"           ,Tgeneral_address_t,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     130  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_WRITE_RE             ," in_READ_UNIT_OUT_WRITE_RE"             ,Tcontrol_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     131  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_NUM_REG_RE           ," in_READ_UNIT_OUT_NUM_REG_RE"           ,Tspecial_address_t,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     132  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_VAL                  ,"out_EXECUTE_UNIT_IN_VAL"                  ,Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     133  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_IN_ACK                  ," in_EXECUTE_UNIT_IN_ACK"                  ,Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     134  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_CONTEXT_ID           ,"out_EXECUTE_UNIT_IN_CONTEXT_ID"           ,Tcontext_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     135  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_FRONT_END_ID         ,"out_EXECUTE_UNIT_IN_FRONT_END_ID"         ,Tcontext_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     136  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ,"out_EXECUTE_UNIT_IN_OOO_ENGINE_ID"        ,Tcontext_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     137  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_PACKET_ID            ,"out_EXECUTE_UNIT_IN_PACKET_ID"            ,Tpacket_t         ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     138  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_OPERATION            ,"out_EXECUTE_UNIT_IN_OPERATION"            ,Toperation_t      ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     139  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_TYPE                 ,"out_EXECUTE_UNIT_IN_TYPE"                 ,Ttype_t           ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     140  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE,"out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     141  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,"out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE" ,Tlsq_ptr_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     142  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ,"out_EXECUTE_UNIT_IN_HAS_IMMEDIAT"         ,Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     143  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_IMMEDIAT             ,"out_EXECUTE_UNIT_IN_IMMEDIAT"             ,Tgeneral_data_t   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     144  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RA              ,"out_EXECUTE_UNIT_IN_DATA_RA"              ,Tgeneral_data_t   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     145  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RB              ,"out_EXECUTE_UNIT_IN_DATA_RB"              ,Tgeneral_data_t   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     146  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RC              ,"out_EXECUTE_UNIT_IN_DATA_RC"              ,Tspecial_data_t   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     147  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_WRITE_RD             ,"out_EXECUTE_UNIT_IN_WRITE_RD"             ,Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     148  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_NUM_REG_RD           ,"out_EXECUTE_UNIT_IN_NUM_REG_RD"           ,Tgeneral_address_t,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     149  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_WRITE_RE             ,"out_EXECUTE_UNIT_IN_WRITE_RE"             ,Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     150  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_NUM_REG_RE           ,"out_EXECUTE_UNIT_IN_NUM_REG_RE"           ,Tspecial_address_t,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
    141151 
    142152 
    … …  
    150160  (*(_Read_unit_to_Execution_unit->in_NRESET))       (*(in_NRESET));
    151161
    152   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_VAL                  ,_param->_nb_read_unit);
    153   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_READ_UNIT_OUT_ACK                  ,_param->_nb_read_unit);
     162  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_VAL                  ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     163  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_READ_UNIT_OUT_ACK                  ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
    154164  if (_param->_have_port_context_id)
    155   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_CONTEXT_ID           ,_param->_nb_read_unit);
     165  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_CONTEXT_ID           ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
    156166  if (_param->_have_port_front_end_id)
    157   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_FRONT_END_ID         ,_param->_nb_read_unit);
     167  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_FRONT_END_ID         ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
    158168  if (_param->_have_port_ooo_engine_id)
    159   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_OOO_ENGINE_ID        ,_param->_nb_read_unit);
    160   if (_param->_have_port_packet_id)
    161   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_PACKET_ID            ,_param->_nb_read_unit);
    162   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_OPERATION            ,_param->_nb_read_unit);
    163   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_TYPE                 ,_param->_nb_read_unit);
    164   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE,_param->_nb_read_unit);
     169  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_OOO_ENGINE_ID        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     170  if (_param->_have_port_rob_ptr  )
     171  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_PACKET_ID            ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     172  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_OPERATION            ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     173  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_TYPE                 ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     174  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
    165175  if (_param->_have_port_load_queue_ptr)
    166   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ,_param->_nb_read_unit);
    167   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_HAS_IMMEDIAT         ,_param->_nb_read_unit);
    168   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_IMMEDIAT             ,_param->_nb_read_unit);
    169   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_DATA_RA              ,_param->_nb_read_unit);
    170   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_DATA_RB              ,_param->_nb_read_unit);
    171   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_DATA_RC              ,_param->_nb_read_unit);
    172   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_WRITE_RD             ,_param->_nb_read_unit);
    173   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_NUM_REG_RD           ,_param->_nb_read_unit);
    174   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_WRITE_RE             ,_param->_nb_read_unit);
    175   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_NUM_REG_RE           ,_param->_nb_read_unit);
    176 
    177   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_VAL                  ,_param->_nb_execute_unit);
    178   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_EXECUTE_UNIT_IN_ACK                  ,_param->_nb_execute_unit);
     176  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     177  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_HAS_IMMEDIAT         ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     178  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_IMMEDIAT             ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     179  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_DATA_RA              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     180  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_DATA_RB              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     181  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_DATA_RC              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     182  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_WRITE_RD             ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     183  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_NUM_REG_RD           ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     184  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_WRITE_RE             ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     185  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_NUM_REG_RE           ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     186
     187  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_VAL                  ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     188  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_EXECUTE_UNIT_IN_ACK                  ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
    179189  if (_param->_have_port_context_id)
    180   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_CONTEXT_ID           ,_param->_nb_execute_unit);
     190  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_CONTEXT_ID           ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
    181191  if (_param->_have_port_front_end_id)
    182   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_FRONT_END_ID         ,_param->_nb_execute_unit);
     192  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_FRONT_END_ID         ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
    183193  if (_param->_have_port_ooo_engine_id)
    184   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ,_param->_nb_execute_unit);
    185   if (_param->_have_port_packet_id)
    186   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_PACKET_ID            ,_param->_nb_execute_unit);
    187   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_OPERATION            ,_param->_nb_execute_unit);
    188   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_TYPE                 ,_param->_nb_execute_unit);
    189   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE,_param->_nb_execute_unit);
     194  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     195  if (_param->_have_port_rob_ptr  )
     196  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_PACKET_ID            ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     197  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_OPERATION            ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     198  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_TYPE                 ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     199  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
    190200  if (_param->_have_port_load_queue_ptr)
    191   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,_param->_nb_execute_unit);
    192   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ,_param->_nb_execute_unit);
    193   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_IMMEDIAT             ,_param->_nb_execute_unit);
    194   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_DATA_RA              ,_param->_nb_execute_unit);
    195   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_DATA_RB              ,_param->_nb_execute_unit);
    196   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_DATA_RC              ,_param->_nb_execute_unit);
    197   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_WRITE_RD             ,_param->_nb_execute_unit);
    198   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_NUM_REG_RD           ,_param->_nb_execute_unit);
    199   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_WRITE_RE             ,_param->_nb_execute_unit);
    200   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_NUM_REG_RE           ,_param->_nb_execute_unit);
     201  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     202  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     203  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_IMMEDIAT             ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     204  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_DATA_RA              ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     205  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_DATA_RB              ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     206  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_DATA_RC              ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     207  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_WRITE_RD             ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     208  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_NUM_REG_RD           ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     209  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_WRITE_RE             ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     210  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_NUM_REG_RE           ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
    201211
    202212  msg(_("<%s> : Start Simulation ............\n"),name.c_str());
    … …  
    222232 
    223233  for (uint32_t i=0; i<_param->_nb_read_unit; i++)
    224     for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
    225       if (_param->_table_routing[i][j])
    226         for (uint32_t k=0; k<_param->_nb_thread; k++)
    227           if (_param->_table_execute_thread[j][k])
    228             {
    229               read_unit_thread [i].insert(k);
    230              
    231               for (uint32_t l=0; l<_param->_nb_type; l++)
    232                 if (_param->_table_execute_type[j][l])
    233                   read_unit_type [i][k].insert(l);
    234             }
     234    for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
     235      for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
     236        if (_param->_table_routing[i][x][y])
     237          for (uint32_t k=0; k<_param->_nb_thread; k++)
     238            if (_param->_table_execute_thread[x][k])
     239              {
     240                read_unit_thread [i].insert(k);
     241               
     242                for (uint32_t l=0; l<_param->_nb_type; l++)
     243                  if (_param->_table_execute_type[x][l])
     244                    read_unit_type [i][k].insert(l);
     245              }
    235246  //bool ** _table_routing       ; //array [nb_read_unit][nb_execute_unit]
    236247  //bool ** _table_execute_type  ; //array [nb_execute_unit][nb_type]
    … …  
    251262      LABEL("Iteration %d",iteration);
    252263
    253       list<entry_t> request [_param->_nb_read_unit];
     264      list<entry_t> request [_param->_nb_read_unit][_param->_max_nb_read_unit_port];
    254265
    255266      uint32_t nb_request_in;
    256267      for (nb_request_in=0; nb_request_in < _param->_nb_packet; )
    257268        for (uint32_t i=0; i<_param->_nb_read_unit; i++)
    258           {
    259             if (nb_request_in >= _param->_nb_packet)
    260               break;
    261 
    262             Tcontext_t context_id   ;
    263             Tcontext_t front_end_id ;
    264             Tcontext_t ooo_engine_id;
    265             Tcontext_t num_thread   ;
    266 
    267             // Find compatible thread
    268             do
    269               {
    270                 context_id    = range<Tcontext_t> (rand(), _param->_size_context_id   );
    271                 front_end_id  = range<Tcontext_t> (rand(), _param->_size_front_end_id );
    272                 ooo_engine_id = range<Tcontext_t> (rand(), _param->_size_ooo_engine_id);
    273                 num_thread    = get_num_thread (context_id   , _param->_size_context_id   ,
    274                                                 front_end_id , _param->_size_front_end_id ,
    275                                                 ooo_engine_id, _param->_size_ooo_engine_id);
    276               }
    277             while (read_unit_thread[i].find(num_thread) == read_unit_thread[i].end());
    278 
    279             Ttype_t    type;
    280            
    281             // Find a compatible type
    282             do
    283               {
    284                 type = range<Ttype_t> (rand(), _param->_size_type);
    285               }
    286             while (read_unit_type[i][num_thread].find(type) == read_unit_type[i][num_thread].end());
    287 
    288             request[i].push_back(entry_t (context_id   ,
    289                                           front_end_id ,
    290                                           ooo_engine_id,
    291                                           nb_request_in,
    292                                           range<Toperation_t      > (rand(), _param->_size_operation       ),
    293                                           type,
    294                                           range<Tlsq_ptr_t        > (rand(), _param->_size_store_queue     ),
    295                                           range<Tlsq_ptr_t        > (rand(), _param->_size_load_queue      ),
    296                                           range<Tcontrol_t        > (rand(), 2                             ),
    297                                           range<Tgeneral_data_t   > (rand(), _param->_size_general_data    ),
    298                                           range<Tgeneral_data_t   > (rand(), _param->_size_general_data    ),
    299                                           range<Tgeneral_data_t   > (rand(), _param->_size_general_data    ),
    300                                           range<Tspecial_data_t   > (rand(), _param->_size_special_data    ),
    301                                           range<Tcontrol_t        > (rand(), 2                             ),
    302                                           range<Tgeneral_address_t> (rand(), _param->_size_general_register),
    303                                           range<Tcontrol_t        > (rand(), 2                             ),
    304                                           range<Tspecial_address_t> (rand(), _param->_size_special_register)
    305                                           ));
    306 
    307             nb_request_in++;
    308           }
     269          for (uint32_t j=0; j<_param->_nb_read_unit_port [i]; j++)
     270            {
     271              if (nb_request_in >= _param->_nb_packet)
     272                break;
     273             
     274              Tcontext_t context_id   ;
     275              Tcontext_t front_end_id ;
     276              Tcontext_t ooo_engine_id;
     277              Tcontext_t num_thread   ;
     278             
     279              // Find compatible thread
     280              do
     281                {
     282                  context_id    = range<Tcontext_t> (rand(), _param->_size_context_id   );
     283                  front_end_id  = range<Tcontext_t> (rand(), _param->_size_front_end_id );
     284                  ooo_engine_id = range<Tcontext_t> (rand(), _param->_size_ooo_engine_id);
     285                  num_thread    = get_num_thread (context_id   , _param->_size_context_id   ,
     286                                                  front_end_id , _param->_size_front_end_id ,
     287                                                  ooo_engine_id, _param->_size_ooo_engine_id);
     288                }
     289              while (read_unit_thread[i].find(num_thread) == read_unit_thread[i].end());
     290             
     291              Ttype_t    type;
     292             
     293              // Find a compatible type
     294              do
     295                {
     296                  type = range<Ttype_t> (rand(), _param->_size_type);
     297                }
     298              while (read_unit_type[i][num_thread].find(type) == read_unit_type[i][num_thread].end());
     299             
     300              request[i][j].push_back(entry_t (context_id   ,
     301                                               front_end_id ,
     302                                               ooo_engine_id,
     303                                               nb_request_in,
     304                                               range<Toperation_t      > (rand(), _param->_size_operation       ),
     305                                               type,
     306                                               range<Tlsq_ptr_t        > (rand(), (1<<_param->_size_store_queue_ptr)),
     307                                               range<Tlsq_ptr_t        > (rand(), (1<<_param->_size_load_queue_ptr )),
     308                                               range<Tcontrol_t        > (rand(), 2                             ),
     309                                               range<Tgeneral_data_t   > (rand(), _param->_size_general_data    ),
     310                                               range<Tgeneral_data_t   > (rand(), _param->_size_general_data    ),
     311                                               range<Tgeneral_data_t   > (rand(), _param->_size_general_data    ),
     312                                               range<Tspecial_data_t   > (rand(), _param->_size_special_data    ),
     313                                               range<Tcontrol_t        > (rand(), 2                             ),
     314                                               range<Tgeneral_address_t> (rand(), _param->_size_general_register),
     315                                               range<Tcontrol_t        > (rand(), 2                             ),
     316                                               range<Tspecial_address_t> (rand(), _param->_size_special_register)
     317                                               ));
     318             
     319              nb_request_in++;
     320            }
    309321
    310322      uint32_t   nb_request_out = 0;
    … …  
    313325        {
    314326          for (uint32_t i=0; i<_param->_nb_read_unit; i++)
    315             {
    316               bool val = not request[i].empty() and ((rand()%100) < percent_transaction_in);
     327            for (uint32_t j=0; j<_param->_nb_read_unit_port [i]; j++)
     328              {
     329                bool val = not request[i][j].empty() and ((rand()%100) < percent_transaction_in);
    317330               
    318               in_READ_UNIT_OUT_VAL [i]->write(val);
    319 
    320               if (val)
     331                in_READ_UNIT_OUT_VAL [i][j]->write(val);
     332               
     333                if (val)
    321334                {
    322                   in_READ_UNIT_OUT_CONTEXT_ID           [i] ->write(request[i].front()._context_id           );
    323                   in_READ_UNIT_OUT_FRONT_END_ID         [i] ->write(request[i].front()._front_end_id         );
    324                   in_READ_UNIT_OUT_OOO_ENGINE_ID        [i] ->write(request[i].front()._ooo_engine_id        );
    325                   in_READ_UNIT_OUT_PACKET_ID            [i] ->write(request[i].front()._packet_id            );
    326                   in_READ_UNIT_OUT_OPERATION            [i] ->write(request[i].front()._operation            );
    327                   in_READ_UNIT_OUT_TYPE                 [i] ->write(request[i].front()._type                 );
    328                   in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE[i] ->write(request[i].front()._store_queue_ptr_write);
     335                  in_READ_UNIT_OUT_CONTEXT_ID           [i][j] ->write(request[i][j].front()._context_id           );
     336                  in_READ_UNIT_OUT_FRONT_END_ID         [i][j] ->write(request[i][j].front()._front_end_id         );
     337                  in_READ_UNIT_OUT_OOO_ENGINE_ID        [i][j] ->write(request[i][j].front()._ooo_engine_id        );
     338                  in_READ_UNIT_OUT_PACKET_ID            [i][j] ->write(request[i][j].front()._packet_id            );
     339                  in_READ_UNIT_OUT_OPERATION            [i][j] ->write(request[i][j].front()._operation            );
     340                  in_READ_UNIT_OUT_TYPE                 [i][j] ->write(request[i][j].front()._type                 );
     341                  in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE[i][j] ->write(request[i][j].front()._store_queue_ptr_write);
    329342                  if (_param->_have_port_load_queue_ptr)
    330                   in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE [i] ->write(request[i].front()._load_queue_ptr_write );
    331                   in_READ_UNIT_OUT_HAS_IMMEDIAT         [i] ->write(request[i].front()._has_immediat         );
    332                   in_READ_UNIT_OUT_IMMEDIAT             [i] ->write(request[i].front()._immediat             );
    333                   in_READ_UNIT_OUT_DATA_RA              [i] ->write(request[i].front()._data_ra              );
    334                   in_READ_UNIT_OUT_DATA_RB              [i] ->write(request[i].front()._data_rb              );
    335                   in_READ_UNIT_OUT_DATA_RC              [i] ->write(request[i].front()._data_rc              );
    336                   in_READ_UNIT_OUT_WRITE_RD             [i] ->write(request[i].front()._write_rd             );
    337                   in_READ_UNIT_OUT_NUM_REG_RD           [i] ->write(request[i].front()._num_reg_rd           );
    338                   in_READ_UNIT_OUT_WRITE_RE             [i] ->write(request[i].front()._write_re             );
    339                   in_READ_UNIT_OUT_NUM_REG_RE           [i] ->write(request[i].front()._num_reg_re           );
     343                  in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE [i][j] ->write(request[i][j].front()._load_queue_ptr_write );
     344                  in_READ_UNIT_OUT_HAS_IMMEDIAT         [i][j] ->write(request[i][j].front()._has_immediat         );
     345                  in_READ_UNIT_OUT_IMMEDIAT             [i][j] ->write(request[i][j].front()._immediat             );
     346                  in_READ_UNIT_OUT_DATA_RA              [i][j] ->write(request[i][j].front()._data_ra              );
     347                  in_READ_UNIT_OUT_DATA_RB              [i][j] ->write(request[i][j].front()._data_rb              );
     348                  in_READ_UNIT_OUT_DATA_RC              [i][j] ->write(request[i][j].front()._data_rc              );
     349                  in_READ_UNIT_OUT_WRITE_RD             [i][j] ->write(request[i][j].front()._write_rd             );
     350                  in_READ_UNIT_OUT_NUM_REG_RD           [i][j] ->write(request[i][j].front()._num_reg_rd           );
     351                  in_READ_UNIT_OUT_WRITE_RE             [i][j] ->write(request[i][j].front()._write_re             );
     352                  in_READ_UNIT_OUT_NUM_REG_RE           [i][j] ->write(request[i][j].front()._num_reg_re           );
    340353                }
    341             }
     354              }
    342355
    343356          for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
    344             in_EXECUTE_UNIT_IN_ACK [i]->write((rand()%100) < percent_transaction_out);
     357            for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
     358              in_EXECUTE_UNIT_IN_ACK [i][j]->write((rand()%100) < percent_transaction_out);
    345359
    346360          SC_START(0);
    347361
    348362          for (uint32_t i=0; i<_param->_nb_read_unit; i++)
    349             if (in_READ_UNIT_OUT_VAL [i]->read() and out_READ_UNIT_OUT_ACK [i]->read())
    350               {
    351                 LABEL("READ_UNIT_OUT   [%d] - Transaction accepted",i);
    352               }
     363            for (uint32_t j=0; j<_param->_nb_read_unit_port [i]; j++)
     364              if (in_READ_UNIT_OUT_VAL [i][j]->read() and out_READ_UNIT_OUT_ACK [i][j]->read())
     365                {
     366                  LABEL("READ_UNIT_OUT   [%d][%d] - Transaction accepted",i,j);
     367                }
    353368
    354369          for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
    355             if (out_EXECUTE_UNIT_IN_VAL [i]->read() and in_EXECUTE_UNIT_IN_ACK [i]->read())
    356               {
    357                 LABEL("EXECUTE_UNIT_IN [%d] - Transaction accepted (%d)",i,nb_request_out);
    358                 nb_request_out ++;
    359                
    360                 Tpacket_t packet = (_param->_have_port_packet_id)?out_EXECUTE_UNIT_IN_PACKET_ID[i]->read():0;
    361                 LABEL("  * packet           : %d",packet);             
    362                 uint32_t read_unit;
    363 
    364                 // find read_unit
    365                 for (read_unit=0; read_unit<_param->_nb_read_unit; read_unit++)
    366                   if (packet == ((_param->_have_port_packet_id)?request[read_unit].front()._packet_id:0))
    367                     break;
    368 
    369                 LABEL("  * read_unit source : %d",read_unit);
    370 
    371                 if (_param->_have_port_packet_id)
    372                 TEST(Tcontext_t        ,out_EXECUTE_UNIT_IN_PACKET_ID            [i]->read(), request[read_unit].front()._packet_id            );
    373 
    374                 // Authorised link ? read_unit -> execute_unit
    375                 TEST(bool, _param->_table_routing[read_unit][i], true);
    376 
    377                 if (_param->_have_port_context_id)
    378                 TEST(Tcontext_t        ,out_EXECUTE_UNIT_IN_CONTEXT_ID           [i]->read(), request[read_unit].front()._context_id           );
    379                 if (_param->_have_port_front_end_id)
    380                 TEST(Tcontext_t        ,out_EXECUTE_UNIT_IN_FRONT_END_ID         [i]->read(), request[read_unit].front()._front_end_id         );
    381                 if (_param->_have_port_ooo_engine_id)
    382                 TEST(Tcontext_t        ,out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        [i]->read(), request[read_unit].front()._ooo_engine_id        );
    383                 TEST(Toperation_t      ,out_EXECUTE_UNIT_IN_OPERATION            [i]->read(), request[read_unit].front()._operation            );
    384                 TEST(Ttype_t           ,out_EXECUTE_UNIT_IN_TYPE                 [i]->read(), request[read_unit].front()._type                 );
    385                 TEST(Tlsq_ptr_t        ,out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE[i]->read(), request[read_unit].front()._store_queue_ptr_write);
    386                 if (_param->_have_port_load_queue_ptr)
    387                 TEST(Tlsq_ptr_t        ,out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i]->read(), request[read_unit].front()._load_queue_ptr_write );
    388                 TEST(Tcontrol_t        ,out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         [i]->read(), request[read_unit].front()._has_immediat         );
    389                 TEST(Tgeneral_data_t   ,out_EXECUTE_UNIT_IN_IMMEDIAT             [i]->read(), request[read_unit].front()._immediat             );
    390                 TEST(Tgeneral_data_t   ,out_EXECUTE_UNIT_IN_DATA_RA              [i]->read(), request[read_unit].front()._data_ra              );
    391                 TEST(Tgeneral_data_t   ,out_EXECUTE_UNIT_IN_DATA_RB              [i]->read(), request[read_unit].front()._data_rb              );
    392                 TEST(Tspecial_data_t   ,out_EXECUTE_UNIT_IN_DATA_RC              [i]->read(), request[read_unit].front()._data_rc              );
    393                 TEST(Tcontrol_t        ,out_EXECUTE_UNIT_IN_WRITE_RD             [i]->read(), request[read_unit].front()._write_rd             );
    394                 TEST(Tgeneral_address_t,out_EXECUTE_UNIT_IN_NUM_REG_RD           [i]->read(), request[read_unit].front()._num_reg_rd           );
    395                 TEST(Tcontrol_t        ,out_EXECUTE_UNIT_IN_WRITE_RE             [i]->read(), request[read_unit].front()._write_re             );
    396                 TEST(Tspecial_address_t,out_EXECUTE_UNIT_IN_NUM_REG_RE           [i]->read(), request[read_unit].front()._num_reg_re           );
    397                
    398                 request[read_unit].pop_front();
    399               }
     370            for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
     371              if (out_EXECUTE_UNIT_IN_VAL [i][j]->read() and in_EXECUTE_UNIT_IN_ACK [i][j]->read())
     372                {
     373                  LABEL("EXECUTE_UNIT_IN [%d][%d] - Transaction accepted (%d)",i,j,nb_request_out);
     374                  nb_request_out ++;
     375                 
     376                  Tpacket_t packet = (_param->_have_port_rob_ptr  )?out_EXECUTE_UNIT_IN_PACKET_ID[i][j]->read():0;
     377                  LABEL("  * packet           : %d",packet);           
     378                  uint32_t x;
     379                  uint32_t y;
     380
     381                  // find read_unit
     382                  bool find = false;
     383                  for (x=0; x<_param->_nb_read_unit; x++)
     384                    {
     385                      for (y=0; y<_param->_nb_read_unit_port[x]; y++)
     386                        if (packet == ((_param->_have_port_rob_ptr  )?request[x][y].front()._packet_id:0))
     387                          {
     388                            find = true;
     389                            break;
     390                          }
     391                      if (find)
     392                        break;
     393                    }
     394                 
     395                  LABEL("  * read_unit source : [%d][%d]",x,y);
     396                 
     397                  if (_param->_have_port_rob_ptr  )
     398                  TEST(Tcontext_t        ,out_EXECUTE_UNIT_IN_PACKET_ID            [i][j]->read(), request[x][y].front()._packet_id            );
     399
     400                  // Authorised link ? read_unit -> execute_unit
     401                  TEST(bool, _param->_table_routing[x][i][j], true);
     402                 
     403                  if (_param->_have_port_context_id)
     404                  TEST(Tcontext_t        ,out_EXECUTE_UNIT_IN_CONTEXT_ID           [i][j]->read(), request[x][y].front()._context_id           );
     405                  if (_param->_have_port_front_end_id)
     406                  TEST(Tcontext_t        ,out_EXECUTE_UNIT_IN_FRONT_END_ID         [i][j]->read(), request[x][y].front()._front_end_id         );
     407                  if (_param->_have_port_ooo_engine_id)
     408                  TEST(Tcontext_t        ,out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        [i][j]->read(), request[x][y].front()._ooo_engine_id        );
     409                  TEST(Toperation_t      ,out_EXECUTE_UNIT_IN_OPERATION            [i][j]->read(), request[x][y].front()._operation            );
     410                  TEST(Ttype_t           ,out_EXECUTE_UNIT_IN_TYPE                 [i][j]->read(), request[x][y].front()._type                 );
     411                  TEST(Tlsq_ptr_t        ,out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE[i][j]->read(), request[x][y].front()._store_queue_ptr_write);
     412                  if (_param->_have_port_load_queue_ptr)
     413                  TEST(Tlsq_ptr_t        ,out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i][j]->read(), request[x][y].front()._load_queue_ptr_write );
     414                  TEST(Tcontrol_t        ,out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         [i][j]->read(), request[x][y].front()._has_immediat         );
     415                  TEST(Tgeneral_data_t   ,out_EXECUTE_UNIT_IN_IMMEDIAT             [i][j]->read(), request[x][y].front()._immediat             );
     416                  TEST(Tgeneral_data_t   ,out_EXECUTE_UNIT_IN_DATA_RA              [i][j]->read(), request[x][y].front()._data_ra              );
     417                  TEST(Tgeneral_data_t   ,out_EXECUTE_UNIT_IN_DATA_RB              [i][j]->read(), request[x][y].front()._data_rb              );
     418                  TEST(Tspecial_data_t   ,out_EXECUTE_UNIT_IN_DATA_RC              [i][j]->read(), request[x][y].front()._data_rc              );
     419                  TEST(Tcontrol_t        ,out_EXECUTE_UNIT_IN_WRITE_RD             [i][j]->read(), request[x][y].front()._write_rd             );
     420                  TEST(Tgeneral_address_t,out_EXECUTE_UNIT_IN_NUM_REG_RD           [i][j]->read(), request[x][y].front()._num_reg_rd           );
     421                  TEST(Tcontrol_t        ,out_EXECUTE_UNIT_IN_WRITE_RE             [i][j]->read(), request[x][y].front()._write_re             );
     422                  TEST(Tspecial_address_t,out_EXECUTE_UNIT_IN_NUM_REG_RE           [i][j]->read(), request[x][y].front()._num_reg_re           );
     423                 
     424                  request[x][y].pop_front();
     425                }
    400426          SC_START(1);
    401427        }
    402 
    403428    }
    404429
    … …  
    414439  delete in_CLOCK;
    415440  delete in_NRESET;
    416  
    417   delete []  in_READ_UNIT_OUT_VAL                  ;
    418   delete [] out_READ_UNIT_OUT_ACK                  ;
    419   delete []  in_READ_UNIT_OUT_CONTEXT_ID           ;
    420   delete []  in_READ_UNIT_OUT_FRONT_END_ID         ;
    421   delete []  in_READ_UNIT_OUT_OOO_ENGINE_ID        ;
    422   delete []  in_READ_UNIT_OUT_PACKET_ID            ;
    423   delete []  in_READ_UNIT_OUT_OPERATION            ;
    424   delete []  in_READ_UNIT_OUT_TYPE                 ;
    425   delete []  in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE;
    426   delete []  in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ;
    427   delete []  in_READ_UNIT_OUT_HAS_IMMEDIAT         ;
    428   delete []  in_READ_UNIT_OUT_IMMEDIAT             ;
    429   delete []  in_READ_UNIT_OUT_DATA_RA              ;
    430   delete []  in_READ_UNIT_OUT_DATA_RB              ;
    431   delete []  in_READ_UNIT_OUT_DATA_RC              ;
    432   delete []  in_READ_UNIT_OUT_WRITE_RD             ;
    433   delete []  in_READ_UNIT_OUT_NUM_REG_RD           ;
    434   delete []  in_READ_UNIT_OUT_WRITE_RE             ;
    435   delete []  in_READ_UNIT_OUT_NUM_REG_RE           ;
    436 
    437   delete [] out_EXECUTE_UNIT_IN_VAL                  ;
    438   delete []  in_EXECUTE_UNIT_IN_ACK                  ;
    439   delete [] out_EXECUTE_UNIT_IN_CONTEXT_ID           ;
    440   delete [] out_EXECUTE_UNIT_IN_FRONT_END_ID         ;
    441   delete [] out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ;
    442   delete [] out_EXECUTE_UNIT_IN_PACKET_ID            ;
    443   delete [] out_EXECUTE_UNIT_IN_OPERATION            ;
    444   delete [] out_EXECUTE_UNIT_IN_TYPE                 ;
    445   delete [] out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE;
    446   delete [] out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ;
    447   delete [] out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ;
    448   delete [] out_EXECUTE_UNIT_IN_IMMEDIAT             ;
    449   delete [] out_EXECUTE_UNIT_IN_DATA_RA              ;
    450   delete [] out_EXECUTE_UNIT_IN_DATA_RB              ;
    451   delete [] out_EXECUTE_UNIT_IN_DATA_RC              ;
    452   delete [] out_EXECUTE_UNIT_IN_WRITE_RD             ;
    453   delete [] out_EXECUTE_UNIT_IN_NUM_REG_RD           ;
    454   delete [] out_EXECUTE_UNIT_IN_WRITE_RE             ;
    455   delete [] out_EXECUTE_UNIT_IN_NUM_REG_RE           ;
     441
     442  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_VAL                  ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     443  DELETE2_SC_SIGNAL(out_READ_UNIT_OUT_ACK                  ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     444  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_CONTEXT_ID           ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     445  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_FRONT_END_ID         ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     446  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_OOO_ENGINE_ID        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     447  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_PACKET_ID            ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     448  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_OPERATION            ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     449  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_TYPE                 ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     450  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     451  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     452  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_HAS_IMMEDIAT         ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     453  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_IMMEDIAT             ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     454  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_DATA_RA              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     455  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_DATA_RB              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     456  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_DATA_RC              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     457  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_WRITE_RD             ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     458  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_NUM_REG_RD           ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     459  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_WRITE_RE             ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     460  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_NUM_REG_RE           ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     461  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_VAL                  ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     462  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_IN_ACK                  ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     463  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_CONTEXT_ID           ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     464  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_FRONT_END_ID         ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     465  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     466  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_PACKET_ID            ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     467  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_OPERATION            ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     468  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_TYPE                 ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     469  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     470  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     471  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     472  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_IMMEDIAT             ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     473  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RA              ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     474  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RB              ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     475  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RC              ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     476  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_WRITE_RD             ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     477  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_NUM_REG_RD           ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     478  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_WRITE_RE             ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
     479  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_NUM_REG_RE           ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
    456480
    457481#endif

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

    r81 r88  
    2626  {
    2727    //-----[ fields ]------------------------------------------------------------
    28   public : const uint32_t    _nb_read_unit           ;
    29   public : const uint32_t    _nb_execute_unit        ;
    30   public : const uint32_t    _nb_context             ;
    31   public : const uint32_t    _nb_front_end           ;
    32   public : const uint32_t    _nb_ooo_engine          ;
    33   public : const uint32_t    _nb_packet              ;
    34   public : const uint32_t    _size_general_data      ;
    35   public : const uint32_t    _size_special_data      ;
    36   public : const uint32_t    _nb_general_register    ;
    37   public : const uint32_t    _nb_special_register    ;
    38   public : const uint32_t    _size_store_queue       ;
    39   public : const uint32_t    _size_load_queue        ;
    40   public : const Tpriority_t _priority               ;
    41   public :       bool     ** _table_routing          ; //[nb_read_unit][nb_execute_unit]
    42   public :       bool     ** _table_execute_type     ; //[nb_execute_unit][nb_type]
    43   public :       bool     ** _table_execute_thread   ; //[nb_execute_unit][nb_thread]
     28  public : uint32_t    _nb_read_unit           ;
     29  public : uint32_t  * _nb_read_unit_port      ;//[nb_read_unit]
     30  public : uint32_t    _nb_execute_unit        ;
     31  public : uint32_t  * _nb_execute_unit_port   ;//[nb_execute_unit]
     32  public : uint32_t    _nb_context             ;
     33  public : uint32_t    _nb_front_end           ;
     34  public : uint32_t    _nb_ooo_engine          ;
     35  public : uint32_t    _nb_packet              ;
     36//public : uint32_t    _size_general_data      ;
     37//public : uint32_t    _size_special_data      ;
     38  public : uint32_t    _nb_general_register    ;
     39  public : uint32_t    _nb_special_register    ;
     40//public : uint32_t    _size_store_queue       ;
     41//public : uint32_t    _size_load_queue        ;
     42  public : Tpriority_t _priority               ;
     43  public : bool    *** _table_routing          ; //[nb_read_unit][nb_execute_unit][nb_execute_unit_port]
     44  public : bool     ** _table_execute_type     ; //[nb_execute_unit][nb_type]
     45  public : bool     ** _table_execute_thread   ; //[nb_execute_unit][nb_thread]
    4446
    45   public : const uint32_t    _size_context_id        ;
    46   public : const uint32_t    _size_front_end_id      ;
    47   public : const uint32_t    _size_ooo_engine_id     ;
    48   public : const uint32_t    _size_packet_id         ;
    49   public : const uint32_t    _size_general_register  ;
    50   public : const uint32_t    _size_special_register  ;
     47  public : uint32_t    _max_nb_read_unit_port  ;
     48  public : uint32_t    _max_nb_execute_unit_port;
     49//public : uint32_t    _size_context_id        ;
     50//public : uint32_t    _size_front_end_id      ;
     51//public : uint32_t    _size_ooo_engine_id     ;
     52//public : uint32_t    _size_packet_id         ;
     53//public : uint32_t    _size_general_register  ;
     54//public : uint32_t    _size_special_register  ;
    5155
    52   public : const bool        _have_port_context_id   ;
    53   public : const bool        _have_port_front_end_id ;
    54   public : const bool        _have_port_ooo_engine_id;
    55   public : const bool        _have_port_packet_id    ;
    56   public : const bool        _have_port_load_queue_ptr;
     56//public : bool        _have_port_context_id   ;
     57//public : bool        _have_port_front_end_id ;
     58//public : bool        _have_port_ooo_engine_id;
     59//public : bool        _have_port_packet_id    ;
     60//public : bool        _have_port_load_queue_ptr;
    5761
    58   public : const uint32_t    _nb_thread              ;
    59   public :       uint32_t    _nb_load_store_unit     ;
    60   public :       uint32_t    _nb_functionnal_unit    ;
     62  public : uint32_t    _nb_thread              ;
     63  public : uint32_t    _nb_load_store_unit     ;
     64  public : uint32_t    _nb_functionnal_unit    ;
    6165
    6266    //-----[ methods ]-----------------------------------------------------------
    6367  public : Parameters  (uint32_t    nb_read_unit           ,
     68                        uint32_t  * nb_read_unit_port      ,
    6469                        uint32_t    nb_execute_unit        ,
     70                        uint32_t  * nb_execute_unit_port   ,
    6571                        uint32_t    nb_context             ,
    6672                        uint32_t    nb_front_end           ,
    … …  
    7480                        uint32_t    size_load_queue        ,
    7581                        Tpriority_t priority               ,
    76                         bool     ** table_routing          ,
     82                        bool    *** table_routing          ,
    7783                        bool     ** table_execute_type     ,
    78                         bool     ** table_execute_thread   );
    79   public : Parameters  (Parameters & param) ;
     84                        bool     ** table_execute_thread   ,
     85                        bool        is_toplevel=false      );
     86//   public : Parameters  (Parameters & param) ;
    8087  public : ~Parameters () ;
     88
     89  public :        void            copy       (void);
    8190
    8291  public :        Parameters_test msg_error  (void);

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

    r82 r88  
    3939namespace read_unit_to_execution_unit {
    4040
     41  class destination_t
     42  {
     43  public : uint32_t grp;
     44  public : uint32_t elt;
     45   
     46  public : destination_t (uint32_t grp, uint32_t elt)
     47    {
     48      this->grp = grp;
     49      this->elt = elt;
     50    }
     51  };
    4152
    4253  class Read_unit_to_Execution_unit
    … …  
    6576
    6677    // ~~~~~[ Interface "read_unit_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    67   public    : SC_IN (Tcontrol_t        )   **  in_READ_UNIT_OUT_VAL                  ;
    68   public    : SC_OUT(Tcontrol_t        )   ** out_READ_UNIT_OUT_ACK                  ;
    69   public    : SC_IN (Tcontext_t        )   **  in_READ_UNIT_OUT_CONTEXT_ID           ;
    70   public    : SC_IN (Tcontext_t        )   **  in_READ_UNIT_OUT_FRONT_END_ID         ;
    71   public    : SC_IN (Tcontext_t        )   **  in_READ_UNIT_OUT_OOO_ENGINE_ID        ;
    72   public    : SC_IN (Tpacket_t         )   **  in_READ_UNIT_OUT_PACKET_ID            ;
    73   public    : SC_IN (Toperation_t      )   **  in_READ_UNIT_OUT_OPERATION            ;
    74   public    : SC_IN (Ttype_t           )   **  in_READ_UNIT_OUT_TYPE                 ;
    75   public    : SC_IN (Tlsq_ptr_t        )   **  in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE;
    76   public    : SC_IN (Tlsq_ptr_t        )   **  in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ;
    77   public    : SC_IN (Tcontrol_t        )   **  in_READ_UNIT_OUT_HAS_IMMEDIAT         ;
    78   public    : SC_IN (Tgeneral_data_t   )   **  in_READ_UNIT_OUT_IMMEDIAT             ;
    79   public    : SC_IN (Tgeneral_data_t   )   **  in_READ_UNIT_OUT_DATA_RA              ;
    80   public    : SC_IN (Tgeneral_data_t   )   **  in_READ_UNIT_OUT_DATA_RB              ;
    81   public    : SC_IN (Tspecial_data_t   )   **  in_READ_UNIT_OUT_DATA_RC              ;
    82   public    : SC_IN (Tcontrol_t        )   **  in_READ_UNIT_OUT_WRITE_RD             ;
    83   public    : SC_IN (Tgeneral_address_t)   **  in_READ_UNIT_OUT_NUM_REG_RD           ;
    84   public    : SC_IN (Tcontrol_t        )   **  in_READ_UNIT_OUT_WRITE_RE             ;
    85   public    : SC_IN (Tspecial_address_t)   **  in_READ_UNIT_OUT_NUM_REG_RE           ;
     78  public    : SC_IN (Tcontrol_t        )  ***  in_READ_UNIT_OUT_VAL                    ;//[nb_read_unit][nb_read_unit_port]
     79  public    : SC_OUT(Tcontrol_t        )  *** out_READ_UNIT_OUT_ACK                    ;//[nb_read_unit][nb_read_unit_port]
     80  public    : SC_IN (Tcontext_t        )  ***  in_READ_UNIT_OUT_CONTEXT_ID             ;//[nb_read_unit][nb_read_unit_port]
     81  public    : SC_IN (Tcontext_t        )  ***  in_READ_UNIT_OUT_FRONT_END_ID           ;//[nb_read_unit][nb_read_unit_port]
     82  public    : SC_IN (Tcontext_t        )  ***  in_READ_UNIT_OUT_OOO_ENGINE_ID          ;//[nb_read_unit][nb_read_unit_port]
     83  public    : SC_IN (Tpacket_t         )  ***  in_READ_UNIT_OUT_PACKET_ID              ;//[nb_read_unit][nb_read_unit_port]
     84  public    : SC_IN (Toperation_t      )  ***  in_READ_UNIT_OUT_OPERATION              ;//[nb_read_unit][nb_read_unit_port]
     85  public    : SC_IN (Ttype_t           )  ***  in_READ_UNIT_OUT_TYPE                   ;//[nb_read_unit][nb_read_unit_port]
     86  public    : SC_IN (Tlsq_ptr_t        )  ***  in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE  ;//[nb_read_unit][nb_read_unit_port]
     87  public    : SC_IN (Tlsq_ptr_t        )  ***  in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE   ;//[nb_read_unit][nb_read_unit_port]
     88  public    : SC_IN (Tcontrol_t        )  ***  in_READ_UNIT_OUT_HAS_IMMEDIAT           ;//[nb_read_unit][nb_read_unit_port]
     89  public    : SC_IN (Tgeneral_data_t   )  ***  in_READ_UNIT_OUT_IMMEDIAT               ;//[nb_read_unit][nb_read_unit_port]
     90  public    : SC_IN (Tgeneral_data_t   )  ***  in_READ_UNIT_OUT_DATA_RA                ;//[nb_read_unit][nb_read_unit_port]
     91  public    : SC_IN (Tgeneral_data_t   )  ***  in_READ_UNIT_OUT_DATA_RB                ;//[nb_read_unit][nb_read_unit_port]
     92  public    : SC_IN (Tspecial_data_t   )  ***  in_READ_UNIT_OUT_DATA_RC                ;//[nb_read_unit][nb_read_unit_port]
     93  public    : SC_IN (Tcontrol_t        )  ***  in_READ_UNIT_OUT_WRITE_RD               ;//[nb_read_unit][nb_read_unit_port]
     94  public    : SC_IN (Tgeneral_address_t)  ***  in_READ_UNIT_OUT_NUM_REG_RD             ;//[nb_read_unit][nb_read_unit_port]
     95  public    : SC_IN (Tcontrol_t        )  ***  in_READ_UNIT_OUT_WRITE_RE               ;//[nb_read_unit][nb_read_unit_port]
     96  public    : SC_IN (Tspecial_address_t)  ***  in_READ_UNIT_OUT_NUM_REG_RE             ;//[nb_read_unit][nb_read_unit_port]
    8697
    8798    // ~~~~~[ Interface "execute_unit_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    88   public    : SC_OUT(Tcontrol_t        )   ** out_EXECUTE_UNIT_IN_VAL                  ;
    89   public    : SC_IN (Tcontrol_t        )   **  in_EXECUTE_UNIT_IN_ACK                  ;
    90   public    : SC_OUT(Tcontext_t        )   ** out_EXECUTE_UNIT_IN_CONTEXT_ID           ;
    91   public    : SC_OUT(Tcontext_t        )   ** out_EXECUTE_UNIT_IN_FRONT_END_ID         ;
    92   public    : SC_OUT(Tcontext_t        )   ** out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ;
    93   public    : SC_OUT(Tpacket_t         )   ** out_EXECUTE_UNIT_IN_PACKET_ID            ;
    94   public    : SC_OUT(Toperation_t      )   ** out_EXECUTE_UNIT_IN_OPERATION            ;
    95   public    : SC_OUT(Ttype_t           )   ** out_EXECUTE_UNIT_IN_TYPE                 ;
    96   public    : SC_OUT(Tlsq_ptr_t        )   ** out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE;
    97   public    : SC_OUT(Tlsq_ptr_t        )   ** out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ;
    98   public    : SC_OUT(Tcontrol_t        )   ** out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ;
    99   public    : SC_OUT(Tgeneral_data_t   )   ** out_EXECUTE_UNIT_IN_IMMEDIAT             ;
    100   public    : SC_OUT(Tgeneral_data_t   )   ** out_EXECUTE_UNIT_IN_DATA_RA              ;
    101   public    : SC_OUT(Tgeneral_data_t   )   ** out_EXECUTE_UNIT_IN_DATA_RB              ;
    102   public    : SC_OUT(Tspecial_data_t   )   ** out_EXECUTE_UNIT_IN_DATA_RC              ;
    103   public    : SC_OUT(Tcontrol_t        )   ** out_EXECUTE_UNIT_IN_WRITE_RD             ;
    104   public    : SC_OUT(Tgeneral_address_t)   ** out_EXECUTE_UNIT_IN_NUM_REG_RD           ;
    105   public    : SC_OUT(Tcontrol_t        )   ** out_EXECUTE_UNIT_IN_WRITE_RE             ;
    106   public    : SC_OUT(Tspecial_address_t)   ** out_EXECUTE_UNIT_IN_NUM_REG_RE           ;
     99  public    : SC_OUT(Tcontrol_t        )  *** out_EXECUTE_UNIT_IN_VAL                  ;//[nb_execute_unit][nb_execute_unit_port]
     100  public    : SC_IN (Tcontrol_t        )  ***  in_EXECUTE_UNIT_IN_ACK                  ;//[nb_execute_unit][nb_execute_unit_port]
     101  public    : SC_OUT(Tcontext_t        )  *** out_EXECUTE_UNIT_IN_CONTEXT_ID           ;//[nb_execute_unit][nb_execute_unit_port]
     102  public    : SC_OUT(Tcontext_t        )  *** out_EXECUTE_UNIT_IN_FRONT_END_ID         ;//[nb_execute_unit][nb_execute_unit_port]
     103  public    : SC_OUT(Tcontext_t        )  *** out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ;//[nb_execute_unit][nb_execute_unit_port]
     104  public    : SC_OUT(Tpacket_t         )  *** out_EXECUTE_UNIT_IN_PACKET_ID            ;//[nb_execute_unit][nb_execute_unit_port]
     105  public    : SC_OUT(Toperation_t      )  *** out_EXECUTE_UNIT_IN_OPERATION            ;//[nb_execute_unit][nb_execute_unit_port]
     106  public    : SC_OUT(Ttype_t           )  *** out_EXECUTE_UNIT_IN_TYPE                 ;//[nb_execute_unit][nb_execute_unit_port]
     107  public    : SC_OUT(Tlsq_ptr_t        )  *** out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE;//[nb_execute_unit][nb_execute_unit_port]
     108  public    : SC_OUT(Tlsq_ptr_t        )  *** out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ;//[nb_execute_unit][nb_execute_unit_port]
     109  public    : SC_OUT(Tcontrol_t        )  *** out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ;//[nb_execute_unit][nb_execute_unit_port]
     110  public    : SC_OUT(Tgeneral_data_t   )  *** out_EXECUTE_UNIT_IN_IMMEDIAT             ;//[nb_execute_unit][nb_execute_unit_port]
     111  public    : SC_OUT(Tgeneral_data_t   )  *** out_EXECUTE_UNIT_IN_DATA_RA              ;//[nb_execute_unit][nb_execute_unit_port]
     112  public    : SC_OUT(Tgeneral_data_t   )  *** out_EXECUTE_UNIT_IN_DATA_RB              ;//[nb_execute_unit][nb_execute_unit_port]
     113  public    : SC_OUT(Tspecial_data_t   )  *** out_EXECUTE_UNIT_IN_DATA_RC              ;//[nb_execute_unit][nb_execute_unit_port]
     114  public    : SC_OUT(Tcontrol_t        )  *** out_EXECUTE_UNIT_IN_WRITE_RD             ;//[nb_execute_unit][nb_execute_unit_port]
     115  public    : SC_OUT(Tgeneral_address_t)  *** out_EXECUTE_UNIT_IN_NUM_REG_RD           ;//[nb_execute_unit][nb_execute_unit_port]
     116  public    : SC_OUT(Tcontrol_t        )  *** out_EXECUTE_UNIT_IN_WRITE_RE             ;//[nb_execute_unit][nb_execute_unit_port]
     117  public    : SC_OUT(Tspecial_address_t)  *** out_EXECUTE_UNIT_IN_NUM_REG_RE           ;//[nb_execute_unit][nb_execute_unit_port]
    107118
    108119    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    … …  
    111122
    112123    // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    113   private   : std::list<uint32_t> *** _destination; // [nb_read_unit][nb_thread][nb_type];
     124  private   : std::list<destination_t> *** _destination; // [nb_read_unit][nb_thread][nb_type];
    114125#endif
    115126

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

    r81 r88  
    77
    88#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/include/Parameters.h"
     9#include "Common/include/Max.h"
    910
    1011namespace morpheo {
    … …  
    2021#define FUNCTION "Read_unit_to_Execution_unit::Parameters"
    2122  Parameters::Parameters (uint32_t    nb_read_unit           ,
     23                          uint32_t  * nb_read_unit_port      ,
    2224                          uint32_t    nb_execute_unit        ,
     25                          uint32_t  * nb_execute_unit_port   ,
    2326                          uint32_t    nb_context             ,
    2427                          uint32_t    nb_front_end           ,
    … …  
    3235                          uint32_t    size_load_queue        ,
    3336                          Tpriority_t priority               ,
    34                           bool     ** table_routing          ,
     37                          bool    *** table_routing          ,
    3538                          bool     ** table_execute_type     ,
    36                           bool     ** table_execute_thread   ):
    37     _nb_read_unit            (nb_read_unit       ),
    38     _nb_execute_unit         (nb_execute_unit    ),
    39     _nb_context              (nb_context         ),
    40     _nb_front_end            (nb_front_end       ),
    41     _nb_ooo_engine           (nb_ooo_engine      ),
    42     _nb_packet               (nb_packet          ),
    43     _size_general_data       (size_general_data  ),
    44     _size_special_data       (size_special_data  ),
    45     _nb_general_register     (nb_general_register),
    46     _nb_special_register     (nb_special_register),
    47     _size_store_queue        (size_store_queue   ),
    48     _size_load_queue         (size_load_queue    ),
    49     _priority                (priority           ),
    50 
    51     _size_context_id         (log2(nb_context         )),
    52     _size_front_end_id       (log2(nb_front_end       )),
    53     _size_ooo_engine_id      (log2(nb_ooo_engine      )),
    54     _size_packet_id          (log2(nb_packet          )),
    55     _size_general_register   (log2(nb_general_register)),
    56     _size_special_register   (log2(nb_special_register)),
    57    
    58     _have_port_context_id    (_size_context_id    > 0),
    59     _have_port_front_end_id  (_size_front_end_id  > 0),
    60     _have_port_ooo_engine_id (_size_ooo_engine_id > 0),
    61     _have_port_packet_id     (_size_packet_id     > 0),
    62     _have_port_load_queue_ptr(_size_load_queue    > 1),
    63 
    64     _nb_thread               (get_nb_thread (nb_context, nb_front_end, nb_ooo_engine))
     39                          bool     ** table_execute_thread   ,
     40                          bool        is_toplevel            )
    6541  {
    6642    log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"Begin");
    6743
    68     _table_routing        = table_routing       ;
    69     _table_execute_type   = table_execute_type  ;
    70     _table_execute_thread = table_execute_thread;
     44    _nb_read_unit            = nb_read_unit        ;
     45    _nb_read_unit_port       = nb_read_unit_port   ;   
     46    _nb_execute_unit         = nb_execute_unit     ;
     47    _nb_execute_unit_port    = nb_execute_unit_port;
     48    _nb_context              = nb_context          ;
     49    _nb_front_end            = nb_front_end        ;
     50    _nb_ooo_engine           = nb_ooo_engine       ;
     51    _nb_packet               = nb_packet           ;
     52    _nb_general_register     = nb_general_register ;
     53    _nb_special_register     = nb_special_register ;
     54    _priority                = priority            ;
     55    _table_routing           = table_routing       ;
     56    _table_execute_type      = table_execute_type  ;
     57    _table_execute_thread    = table_execute_thread;
    7158
    72     _nb_load_store_unit   = 0;
     59    _max_nb_read_unit_port   = max<uint32_t>(_nb_read_unit_port, _nb_read_unit);
     60    _max_nb_execute_unit_port= max<uint32_t>(_nb_execute_unit_port, _nb_execute_unit);
     61
     62    _nb_thread               = get_nb_thread (nb_context, nb_front_end, nb_ooo_engine);
     63    _nb_load_store_unit      = 0;
    7364
    7465    for (uint32_t i=0; i<nb_execute_unit; i++)
    … …  
    8273    test();
    8374
     75    if (is_toplevel)
     76      {
     77        _size_context_id         = log2(nb_context         );
     78        _size_front_end_id       = log2(nb_front_end       );
     79        _size_ooo_engine_id      = log2(nb_ooo_engine      );
     80        _size_rob_ptr            = log2(nb_packet          );
     81        _size_general_register   = log2(nb_general_register);
     82        _size_special_register   = log2(nb_special_register);
     83        _size_general_data       = size_general_data   ;
     84        _size_special_data       = size_special_data   ;
     85        _size_store_queue_ptr    = log2(size_store_queue   );
     86        _size_load_queue_ptr     = log2(size_load_queue    );
     87       
     88        _have_port_context_id    = _size_context_id    > 0;
     89        _have_port_front_end_id  = _size_front_end_id  > 0;
     90        _have_port_ooo_engine_id = _size_ooo_engine_id > 0;
     91        _have_port_rob_ptr       = _size_rob_ptr       > 0;
     92        _have_port_load_queue_ptr= _size_load_queue_ptr> 0;
     93       
     94        copy();
     95      }
     96
    8497    log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"End");
    8598  };
    8699 
     100// #undef  FUNCTION
     101// #define FUNCTION "Read_unit_to_Execution_unit::Parameters (copy)"
     102//   Parameters::Parameters (Parameters & param)
     103//   {
     104//     log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"Begin");
     105
     106//     test();
     107//     log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"End");
     108//   };
     109
    87110#undef  FUNCTION
    88 #define FUNCTION "Read_unit_to_Execution_unit::Parameters (copy)"
    89   Parameters::Parameters (Parameters & param):
    90     _nb_read_unit            (param._nb_read_unit           ),
    91     _nb_execute_unit         (param._nb_execute_unit        ),
    92     _nb_context              (param._nb_context             ),
    93     _nb_front_end            (param._nb_front_end           ),
    94     _nb_ooo_engine           (param._nb_ooo_engine          ),
    95     _nb_packet               (param._nb_packet              ),
    96     _size_general_data       (param._size_general_data      ),
    97     _size_special_data       (param._size_special_data      ),
    98     _nb_general_register     (param._nb_general_register    ),
    99     _nb_special_register     (param._nb_special_register    ),
    100     _size_store_queue        (param._size_store_queue       ),
    101     _size_load_queue         (param._size_load_queue        ),
    102     _priority                (param._priority               ),
    103 
    104     _size_context_id         (param._size_context_id        ),
    105     _size_front_end_id       (param._size_front_end_id      ),
    106     _size_ooo_engine_id      (param._size_ooo_engine_id     ),
    107     _size_packet_id          (param._size_packet_id         ),
    108     _size_general_register   (param._size_general_register  ),
    109     _size_special_register   (param._size_special_register  ),
    110 
    111     _have_port_context_id    (param._have_port_context_id   ),
    112     _have_port_front_end_id  (param._have_port_front_end_id ),
    113     _have_port_ooo_engine_id (param._have_port_ooo_engine_id),
    114     _have_port_packet_id     (param._have_port_packet_id    ),
    115     _have_port_load_queue_ptr(param._have_port_load_queue_ptr),
    116 
    117     _nb_thread               (param._nb_thread              )
     111#define FUNCTION "Read_unit_to_Execution_unit::~Parameters"
     112  Parameters::~Parameters ()
    118113  {
    119114    log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"Begin");
    120 
    121     _table_routing        = param._table_routing       ;
    122     _table_execute_type   = param._table_execute_type  ;
    123     _table_execute_thread = param._table_execute_thread;
    124     _nb_load_store_unit   = param._nb_load_store_unit  ;
    125     _nb_functionnal_unit  = param._nb_functionnal_unit ;
    126 
    127     test();
    128115    log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"End");
    129116  };
    130117
    131118#undef  FUNCTION
    132 #define FUNCTION "Read_unit_to_Execution_unit::~Parameters"
    133   Parameters::~Parameters ()
     119#define FUNCTION "Read_unit_to_Execution_unit::copy"
     120  void Parameters::copy (void)
    134121  {
    135122    log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"Begin");

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

    r81 r88  
    3333    // TYPE_MOVE    |     X     |            |            | cmov is optionnal
    3434    // TYPE_TEST    |     X     |            |            |
    35     // TYPE_MUL_DIV |     X     |            |            | div is optionnal
     35    // TYPE_MUL     |     X     |            |            |
     36    // TYPE_DIV     |     X     |     X      |            |
    3637    // TYPE_EXTEND  |     X     |     X      |            |
    3738    // TYPE_FIND    |     X     |     X      |            |
    … …  
    5859    type_valid     [TYPE_MOVE   ] = true;
    5960    type_valid     [TYPE_TEST   ] = true;
    60     type_valid     [TYPE_MUL_DIV] = true;
     61    type_valid     [TYPE_MUL    ] = true;
     62    type_valid     [TYPE_DIV    ] = true;
    6163    type_valid     [TYPE_EXTEND ] = true;
    6264    type_valid     [TYPE_FIND   ] = true;
    … …  
    7072    type_uniq      [TYPE_MEMORY ] = true;
    7173
     74    type_optionnal [TYPE_DIV    ] = true;
    7275    type_optionnal [TYPE_EXTEND ] = true;
    7376    type_optionnal [TYPE_FIND   ] = true;
    … …  
    8588        if (_table_execute_thread [i][j] == true)
    8689          // this execute_unit execute this thread !
    87           for (Ttype_t k=0; k<=_nb_type; k++)
    88             if (_table_execute_type[i][k] == true)
    89               {
    90                 // Test uniq type
    91                 if (type_present [j][k] and type_uniq[k])
    92                   test.error("The execute_unit '"+toString(i)+"' can execute operation of type '"+toString_type(k)+"' at the thread '"+toString(j)+"'. But an another execute_unit can be execute the same type for the same thread. And the type must be uniq !.");
    93                
    94                 type_present [j][k] = true;
    95               }
     90          for (Ttype_t k=0; k<_nb_type; k++)
     91            if (_table_execute_type[i][k] == true)
     92              {
     93//                 test.information(toString(_("Execute_unit [%d], Thread [%d], Type [%d], type_valid %d, type_present %d, type_uniq %d\n"),i,j,k,type_valid[k],type_present[j][k],type_uniq[k]));
     94               
     95                // Test uniq type
     96                if (type_present [j][k] and type_uniq[k])
     97                  test.error(toString(_("The execute_unit '%d' can execute operation of type '%s' at the thread '%d'. But an another execute_unit can be execute the same type for the same thread. And the type must be single !.\n"),i,toString_type(k).c_str(),j));
     98               
     99                type_present [j][k] = true;
     100              }
     101
     102    for (Ttype_t j=0; j<_nb_type; j++)
     103      if (not type_valid [j])
     104        for (uint32_t i=0; i<_nb_thread; i++)
     105          if (type_present [i][j])
     106            test.error(toString(_("The thread '%d' can execute the type's operation '%s' but this type is invalid.\n"),i,toString_type(j).c_str()));
    96107
    97108    for (Ttype_t j=0; j<_nb_type; j++)
    … …  
    99110        for (uint32_t i=0; i<_nb_thread; i++)
    100111          if (not type_present [i][j])
    101             test.error("The thread '"+toString(i)+"' can't access at the execute_unit to execute the type's operation '"+toString_type(j)+"' (and this type is not optionnal !).");
     112            test.error(toString(_("The thread '%d' can't access at the execute_unit to execute the type's operation '%s' (and this type is not optional !).\n"),i,toString_type(j).c_str()));
    102113           
    103114    // Test all excluve type
    104115    for (uint32_t i=0; i<_nb_execute_unit; i++)
    105       for (Ttype_t j=0; j<=_nb_type; j++)
     116      for (Ttype_t j=0; j<_nb_type; j++)
    106117        if (type_exclusive [j] and _table_execute_type[i][j])
    107           for (Ttype_t k=0; k<=_nb_type; k++)
     118          for (Ttype_t k=0; k<_nb_type; k++)
    108119            if ((j != k) and (_table_execute_type[i][k] == true))
    109120              {
    110                 test.error("The execute_unit ["+toString(i)+"] implement the type '"+toString_type(j)+"', and this type is exclusive with all others type.");
     121                test.error(toString(_("The execute_unit [%d] implement the type '%s', and this type is exclusive with all others type.\n"),i,toString_type(j).c_str()));
    111122                break;
    112123              }
    … …  
    120131
    121132        if (j == _nb_thread)
    122           test.error("The execute_unit ["+toString(i)+"] have none source's thread.");
     133          test.error(toString(_("The execute_unit [%d] have none source's thread.\n"),i));
    123134      }   
    124135
    125136    if ( (_priority != PRIORITY_STATIC     ) and
    126137         (_priority != PRIORITY_ROUND_ROBIN))
    127       test.error("Unsupported priority scheme. It must be Static or Round Robin.");
     138      test.error(_("Unsupported priority scheme. It must be Static or Round Robin.\n"));
    128139       
    129140    log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"End");

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

    r81 r88  
    3737    xml.singleton_begin("nb_general_register"); xml.attribut("value",toString(_nb_general_register)); xml.singleton_end();
    3838    xml.singleton_begin("nb_special_register"); xml.attribut("value",toString(_nb_special_register)); xml.singleton_end();
    39     xml.singleton_begin("size_store_queue   "); xml.attribut("value",toString(_size_store_queue   )); xml.singleton_end();
    40     xml.singleton_begin("size_load_queue    "); xml.attribut("value",toString(_size_load_queue    )); xml.singleton_end();
     39//  xml.singleton_begin("size_store_queue   "); xml.attribut("value",toString(_size_store_queue   )); xml.singleton_end();
     40//  xml.singleton_begin("size_load_queue    "); xml.attribut("value",toString(_size_load_queue    )); xml.singleton_end();
    4141    xml.singleton_begin("priority           "); xml.attribut("value",toString(_priority           )); xml.singleton_end();
    4242    xml.balise_close();

  • 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");

  • 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

    r81 r88  
    5757    // ~~~~~[ Interface "read_unit_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    5858     {
    59        ALLOC1_INTERFACE("read_unit_out", IN, EAST, "Output of read_unit", _param->_nb_read_unit);
     59       ALLOC2_INTERFACE("read_unit_out", IN, EAST, "Output of read_unit",_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
    6060
    61        ALLOC1_VALACK_IN ( in_READ_UNIT_OUT_VAL,VAL);
    62        ALLOC1_VALACK_OUT(out_READ_UNIT_OUT_ACK,ACK);
    63 
    64        ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_CONTEXT_ID           ,"CONTEXT_ID"           ,Tcontext_t        ,_param->_size_context_id);
    65        ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_FRONT_END_ID         ,"FRONT_END_ID"         ,Tcontext_t        ,_param->_size_front_end_id);
    66        ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_OOO_ENGINE_ID        ,"OOO_ENGINE_ID"        ,Tcontext_t        ,_param->_size_ooo_engine_id);
    67        ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_PACKET_ID            ,"PACKET_ID"            ,Tpacket_t         ,_param->_size_packet_id);
    68        ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_OPERATION            ,"OPERATION"            ,Toperation_t      ,_param->_size_operation);
    69        ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_TYPE                 ,"TYPE"                 ,Ttype_t           ,_param->_size_type);
    70        ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE,"STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,log2(_param->_size_store_queue));
    71        ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ,"LOAD_QUEUE_PTR_WRITE" ,Tlsq_ptr_t        ,log2(_param->_size_load_queue));
    72        ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_HAS_IMMEDIAT         ,"HAS_IMMEDIAT"         ,Tcontrol_t        ,1);
    73        ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_IMMEDIAT             ,"IMMEDIAT"             ,Tgeneral_data_t   ,_param->_size_general_data);
    74        ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_DATA_RA              ,"DATA_RA"              ,Tgeneral_data_t   ,_param->_size_general_data);
    75        ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_DATA_RB              ,"DATA_RB"              ,Tgeneral_data_t   ,_param->_size_general_data);
    76        ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_DATA_RC              ,"DATA_RC"              ,Tspecial_data_t   ,_param->_size_special_data);
    77        ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_WRITE_RD             ,"WRITE_RD"             ,Tcontrol_t        ,1);
    78        ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_NUM_REG_RD           ,"NUM_REG_RD"           ,Tgeneral_address_t,_param->_size_general_register);
    79        ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_WRITE_RE             ,"WRITE_RE"             ,Tcontrol_t        ,1);
    80        ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_NUM_REG_RE           ,"NUM_REG_RE"           ,Tspecial_address_t,_param->_size_special_register);
     61       _ALLOC2_VALACK_IN ( in_READ_UNIT_OUT_VAL,VAL,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     62       _ALLOC2_VALACK_OUT(out_READ_UNIT_OUT_ACK,ACK,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     63       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_CONTEXT_ID           ,"CONTEXT_ID"           ,Tcontext_t        ,_param->_size_context_id       ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     64       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_FRONT_END_ID         ,"FRONT_END_ID"         ,Tcontext_t        ,_param->_size_front_end_id     ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     65       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_OOO_ENGINE_ID        ,"OOO_ENGINE_ID"        ,Tcontext_t        ,_param->_size_ooo_engine_id    ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     66       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_PACKET_ID            ,"PACKET_ID"            ,Tpacket_t         ,_param->_size_rob_ptr          ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     67       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_OPERATION            ,"OPERATION"            ,Toperation_t      ,_param->_size_operation        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     68       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_TYPE                 ,"TYPE"                 ,Ttype_t           ,_param->_size_type             ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     69       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE,"STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,_param->_size_store_queue_ptr  ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     70       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ,"LOAD_QUEUE_PTR_WRITE" ,Tlsq_ptr_t        ,_param->_size_load_queue_ptr   ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     71       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_HAS_IMMEDIAT         ,"HAS_IMMEDIAT"         ,Tcontrol_t        ,1                              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     72       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_IMMEDIAT             ,"IMMEDIAT"             ,Tgeneral_data_t   ,_param->_size_general_data     ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     73       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_DATA_RA              ,"DATA_RA"              ,Tgeneral_data_t   ,_param->_size_general_data     ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     74       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_DATA_RB              ,"DATA_RB"              ,Tgeneral_data_t   ,_param->_size_general_data     ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     75       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_DATA_RC              ,"DATA_RC"              ,Tspecial_data_t   ,_param->_size_special_data     ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     76       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_WRITE_RD             ,"WRITE_RD"             ,Tcontrol_t        ,1                              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     77       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_NUM_REG_RD           ,"NUM_REG_RD"           ,Tgeneral_address_t,_param->_size_general_register ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     78       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_WRITE_RE             ,"WRITE_RE"             ,Tcontrol_t        ,1                              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
     79       _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]);
    8180     }
    8281    // ~~~~~[ Interface "execute_unit_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    8382     {
    84        ALLOC1_INTERFACE("execute_unit_in", OUT, WEST, "Input of execute_unit", _param->_nb_execute_unit);
     83       ALLOC2_INTERFACE("execute_unit_in", OUT, WEST, "Input of execute_unit", _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
    8584       
    86        ALLOC1_VALACK_OUT(out_EXECUTE_UNIT_IN_VAL,VAL);
    87        ALLOC1_VALACK_IN ( in_EXECUTE_UNIT_IN_ACK,ACK);
     85       _ALLOC2_VALACK_OUT(out_EXECUTE_UNIT_IN_VAL,VAL, _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
     86       _ALLOC2_VALACK_IN ( in_EXECUTE_UNIT_IN_ACK,ACK, _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
     87       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_CONTEXT_ID           ,"CONTEXT_ID"           ,Tcontext_t        ,_param->_size_context_id       , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
     88       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_FRONT_END_ID         ,"FRONT_END_ID"         ,Tcontext_t        ,_param->_size_front_end_id     , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
     89       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ,"OOO_ENGINE_ID"        ,Tcontext_t        ,_param->_size_ooo_engine_id    , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
     90       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_PACKET_ID            ,"PACKET_ID"            ,Tpacket_t         ,_param->_size_rob_ptr          , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
     91       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_OPERATION            ,"OPERATION"            ,Toperation_t      ,_param->_size_operation        , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
     92       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_TYPE                 ,"TYPE"                 ,Ttype_t           ,_param->_size_type             , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
     93       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ,"HAS_IMMEDIAT"         ,Tcontrol_t        ,1                              , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
     94       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_DATA_RC              ,"DATA_RC"              ,Tspecial_data_t   ,_param->_size_special_data     , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
     95       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_WRITE_RD             ,"WRITE_RD"             ,Tcontrol_t        ,1                              , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
     96       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_WRITE_RE             ,"WRITE_RE"             ,Tcontrol_t        ,1                              , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
     97       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_NUM_REG_RE           ,"NUM_REG_RE"           ,Tspecial_address_t,_param->_size_special_register , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
     98       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE,"STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,_param->_size_store_queue_ptr  , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
     99       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,"LOAD_QUEUE_PTR_WRITE" ,Tlsq_ptr_t        ,_param->_size_load_queue_ptr   , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
     100       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_IMMEDIAT             ,"IMMEDIAT"             ,Tgeneral_data_t   ,_param->_size_general_data     , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
     101       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_DATA_RA              ,"DATA_RA"              ,Tgeneral_data_t   ,_param->_size_general_data     , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
     102       _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]);
     103       _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]);
     104     }
    88105
    89        ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_CONTEXT_ID           ,"CONTEXT_ID"           ,Tcontext_t        ,_param->_size_context_id);
    90        ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_FRONT_END_ID         ,"FRONT_END_ID"         ,Tcontext_t        ,_param->_size_front_end_id);
    91        ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ,"OOO_ENGINE_ID"        ,Tcontext_t        ,_param->_size_ooo_engine_id);
    92        ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_PACKET_ID            ,"PACKET_ID"            ,Tpacket_t         ,_param->_size_packet_id);
    93        ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_OPERATION            ,"OPERATION"            ,Toperation_t      ,_param->_size_operation);
    94        ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_TYPE                 ,"TYPE"                 ,Ttype_t           ,_param->_size_type);
    95        ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ,"HAS_IMMEDIAT"         ,Tcontrol_t        ,1);
    96        ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_DATA_RC              ,"DATA_RC"              ,Tspecial_data_t   ,_param->_size_special_data);
    97        ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_WRITE_RD             ,"WRITE_RD"             ,Tcontrol_t        ,1);
    98        ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_WRITE_RE             ,"WRITE_RE"             ,Tcontrol_t        ,1);
    99        ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_NUM_REG_RE           ,"NUM_REG_RE"           ,Tspecial_address_t,_param->_size_special_register);
    100        ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE,"STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,log2(_param->_size_store_queue));
    101        ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,"LOAD_QUEUE_PTR_WRITE" ,Tlsq_ptr_t        ,log2(_param->_size_load_queue));
    102        ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_IMMEDIAT             ,"IMMEDIAT"             ,Tgeneral_data_t   ,_param->_size_general_data);
    103        ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_DATA_RA              ,"DATA_RA"              ,Tgeneral_data_t   ,_param->_size_general_data);
    104        ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_DATA_RB              ,"DATA_RB"              ,Tgeneral_data_t   ,_param->_size_general_data);
    105        ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_NUM_REG_RD           ,"NUM_REG_RD"           ,Tgeneral_address_t,_param->_size_general_register);
    106      }
    107106    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    108      _destination = new std::list<uint32_t> ** [_param->_nb_read_unit];
     107     if (usage_is_set(_usage,USE_SYSTEMC))
     108       {
     109     _destination = new std::list<destination_t> ** [_param->_nb_read_unit];
    109110     for (uint32_t i=0; i<_param->_nb_read_unit; i++)
    110111       {
    111          _destination [i] = new std::list<uint32_t> * [_param->_nb_thread];
     112         _destination [i] = new std::list<destination_t> * [_param->_nb_thread];
    112113         for (uint32_t j=0; j<_param->_nb_thread; j++)
    113114           {
    114              _destination [i][j] = new std::list<uint32_t> [_param->_nb_type];
     115             _destination [i][j] = new std::list<destination_t> [_param->_nb_type];
    115116           }
     117       }
    116118       }
    117119
    118120#ifdef POSITION
    119     _component->generate_file();
     121     if (usage_is_set(_usage,USE_POSITION))
     122       _component->generate_file();
    120123#endif
    121124

  • 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

    r81 r88  
    77
    88#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/include/Read_unit_to_Execution_unit.h"
     9#include "Behavioural/include/Allocation.h"
    910
    1011namespace morpheo                    {
    … …  
    2324    log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"Begin");
    2425
    25     if (_usage & USE_SYSTEMC)
     26    if (usage_is_set(_usage,USE_SYSTEMC))
    2627      {
    2728        delete    in_CLOCK ;
    2829        delete    in_NRESET;
    2930
    30         // ~~~~~[ Interface "read_unit_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    31         delete [] in_READ_UNIT_OUT_VAL                  ;
    32         delete []out_READ_UNIT_OUT_ACK                  ;
    33         if (_param->_have_port_context_id)
    34         delete [] in_READ_UNIT_OUT_CONTEXT_ID           ;
    35         if (_param->_have_port_front_end_id)
    36         delete [] in_READ_UNIT_OUT_FRONT_END_ID         ;
    37         if (_param->_have_port_ooo_engine_id)
    38         delete [] in_READ_UNIT_OUT_OOO_ENGINE_ID        ;
    39         if (_param->_have_port_packet_id)
    40         delete [] in_READ_UNIT_OUT_PACKET_ID            ;
    41         delete [] in_READ_UNIT_OUT_OPERATION            ;
    42         delete [] in_READ_UNIT_OUT_TYPE                 ;
    43         delete [] in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE;
    44         if (_param->_have_port_load_queue_ptr)
    45         delete [] in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ;
    46         delete [] in_READ_UNIT_OUT_HAS_IMMEDIAT         ;
    47         delete [] in_READ_UNIT_OUT_IMMEDIAT             ;
    48         delete [] in_READ_UNIT_OUT_DATA_RA              ;
    49         delete [] in_READ_UNIT_OUT_DATA_RB              ;
    50         delete [] in_READ_UNIT_OUT_DATA_RC              ;
    51         delete [] in_READ_UNIT_OUT_WRITE_RD             ;
    52         delete [] in_READ_UNIT_OUT_NUM_REG_RD           ;
    53         delete [] in_READ_UNIT_OUT_WRITE_RE             ;
    54         delete [] in_READ_UNIT_OUT_NUM_REG_RE           ;
     31         DELETE2_SIGNAL( in_READ_UNIT_OUT_VAL                    , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],1                              );
     32         DELETE2_SIGNAL(out_READ_UNIT_OUT_ACK                    , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],1                              );
     33         DELETE2_SIGNAL( in_READ_UNIT_OUT_CONTEXT_ID             , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_context_id       );
     34         DELETE2_SIGNAL( in_READ_UNIT_OUT_FRONT_END_ID           , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_front_end_id     );
     35         DELETE2_SIGNAL( in_READ_UNIT_OUT_OOO_ENGINE_ID          , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_ooo_engine_id    );
     36         DELETE2_SIGNAL( in_READ_UNIT_OUT_PACKET_ID              , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_rob_ptr          );
     37         DELETE2_SIGNAL( in_READ_UNIT_OUT_OPERATION              , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_operation        );
     38         DELETE2_SIGNAL( in_READ_UNIT_OUT_TYPE                   , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_type             );
     39         DELETE2_SIGNAL( in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE  , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_store_queue_ptr  );
     40         DELETE2_SIGNAL( in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE   , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_load_queue_ptr   );
     41         DELETE2_SIGNAL( in_READ_UNIT_OUT_HAS_IMMEDIAT           , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],1                              );
     42         DELETE2_SIGNAL( in_READ_UNIT_OUT_IMMEDIAT               , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_general_data     );
     43         DELETE2_SIGNAL( in_READ_UNIT_OUT_DATA_RA                , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_general_data     );
     44         DELETE2_SIGNAL( in_READ_UNIT_OUT_DATA_RB                , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_general_data     );
     45         DELETE2_SIGNAL( in_READ_UNIT_OUT_DATA_RC                , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_special_data     );
     46         DELETE2_SIGNAL( in_READ_UNIT_OUT_WRITE_RD               , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],1                              );
     47         DELETE2_SIGNAL( in_READ_UNIT_OUT_NUM_REG_RD             , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_general_register );
     48         DELETE2_SIGNAL( in_READ_UNIT_OUT_WRITE_RE               , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],1                              );
     49         DELETE2_SIGNAL( in_READ_UNIT_OUT_NUM_REG_RE             , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_special_register );
     50       
     51         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_VAL                  , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],1                              );
     52         DELETE2_SIGNAL( in_EXECUTE_UNIT_IN_ACK                  , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],1                              );
     53         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_CONTEXT_ID           , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_context_id       );
     54         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_FRONT_END_ID         , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_front_end_id     );
     55         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_ooo_engine_id    );
     56         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_PACKET_ID            , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_rob_ptr          );
     57         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_OPERATION            , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_operation        );
     58         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_TYPE                 , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_type             );
     59         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],1                              );
     60         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RC              , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_special_data     );
     61         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_WRITE_RD             , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],1                              );
     62         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_WRITE_RE             , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],1                              );
     63         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_NUM_REG_RE           , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_special_register );
     64         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE, _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_store_queue_ptr  );
     65         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_load_queue_ptr   );
     66         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_IMMEDIAT             , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_general_data     );
     67         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RA              , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_general_data     );
     68         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RB              , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_general_data     );
     69         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_NUM_REG_RD           , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_general_register );
    5570
    56         // ~~~~~[ Interface "execute_unit_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    57         delete [] out_EXECUTE_UNIT_IN_VAL                  ;
    58         delete []  in_EXECUTE_UNIT_IN_ACK                  ;
    59         if (_param->_have_port_context_id)
    60         delete [] out_EXECUTE_UNIT_IN_CONTEXT_ID           ;
    61         if (_param->_have_port_front_end_id)
    62         delete [] out_EXECUTE_UNIT_IN_FRONT_END_ID         ;
    63         if (_param->_have_port_ooo_engine_id)
    64         delete [] out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ;
    65         if (_param->_have_port_packet_id)
    66         delete [] out_EXECUTE_UNIT_IN_PACKET_ID            ;
    67         delete [] out_EXECUTE_UNIT_IN_OPERATION            ;
    68         delete [] out_EXECUTE_UNIT_IN_TYPE                 ;
    69         delete [] out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ;
    70         delete [] out_EXECUTE_UNIT_IN_DATA_RC              ;
    71         delete [] out_EXECUTE_UNIT_IN_WRITE_RD             ;
    72         delete [] out_EXECUTE_UNIT_IN_WRITE_RE             ;
    73         delete [] out_EXECUTE_UNIT_IN_NUM_REG_RE           ;
    74         delete [] out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE;
    75         if (_param->_have_port_load_queue_ptr)
    76         delete [] out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ;
    77         delete [] out_EXECUTE_UNIT_IN_IMMEDIAT             ;
    78         delete [] out_EXECUTE_UNIT_IN_DATA_RA              ;
    79         delete [] out_EXECUTE_UNIT_IN_DATA_RB              ;
    80         delete [] out_EXECUTE_UNIT_IN_NUM_REG_RD           ;
     71         delete [] _destination;
    8172      }
    8273    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    8374
    84     delete [] _destination;
    8575    delete    _component;
    8676

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

    r81 r88  
    2525
    2626#ifdef STATISTICS
    27     _stat->end_cycle();
     27    if (usage_is_set(_usage,USE_STATISTICS))
     28      _stat->end_cycle();
    2829#endif   
    2930
    … …  
    3132    // Evaluation before read the ouput signal
    3233//  sc_start(0);
    33     _interfaces->testbench();
     34    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
     35      _interfaces->testbench();
    3436#endif
    3537

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

    r81 r88  
    2424    log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"Begin");
    2525
    26     bool execute_unit_use [_param->_nb_execute_unit];
     26    bool execute_unit_use [_param->_nb_execute_unit][_param->_max_nb_execute_unit_port];
    2727
    2828    for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
    29       execute_unit_use[i] = (PORT_READ(in_EXECUTE_UNIT_IN_ACK [i]) == 0);
     29      for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
     30        execute_unit_use[i][j] = false;
    3031
    3132    for (uint32_t i=0; i<_param->_nb_read_unit; i++)
    32       {
    33         bool       ack = false;
     33      for (uint32_t j=0; j<_param->_nb_read_unit_port[i]; j++)
     34        {
     35          bool       ack = false;
     36         
     37          log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION,"Test Read_unit[%d][%d]",i,j);
     38         
     39          if (PORT_READ(in_READ_UNIT_OUT_VAL [i][j]) == true)
     40            {
     41              log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION," * have a valid entry.");
     42             
     43              Tcontext_t context_id    = (_param->_have_port_context_id   )?PORT_READ(in_READ_UNIT_OUT_CONTEXT_ID    [i][j]):0;
     44              Tcontext_t front_end_id  = (_param->_have_port_front_end_id )?PORT_READ(in_READ_UNIT_OUT_FRONT_END_ID  [i][j]):0;
     45              Tcontext_t ooo_engine_id = (_param->_have_port_ooo_engine_id)?PORT_READ(in_READ_UNIT_OUT_OOO_ENGINE_ID [i][j]):0;
     46              Tcontext_t num_thread    = get_num_thread(context_id   , _param->_size_context_id   ,
     47                                                        front_end_id , _param->_size_front_end_id ,
     48                                                        ooo_engine_id, _param->_size_ooo_engine_id);
     49              Ttype_t    type          = PORT_READ(in_READ_UNIT_OUT_TYPE [i][j]);
     50             
     51#ifdef DEBUG_TEST
     52              if (_destination[i][num_thread][type].empty())
     53                throw ERRORMORPHEO(FUNCTION,"Invalid Operation : They have no execute_unit to receive a operation from the read_unit ["+toString(i)+"], thread ["+toString(num_thread)+"] and a operation's type ["+toString_type(type)+"].");
     54#endif
     55             
     56              // find a free execute_unit
     57              for (std::list<destination_t>::iterator it=_destination[i][num_thread][type].begin();
     58                   (it != _destination[i][num_thread][type].end()) and (ack == false);
     59                   it++)
     60                {
     61                  uint32_t dest = (*it).grp;
     62                  uint32_t port = (*it).elt;
     63                 
     64                  log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION,"   * Test destination [%d][%d].",dest,port);
     65                 
     66                  if (execute_unit_use [dest][port] == false)
     67                    {
     68                      log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION,"     * Is ok! Link.");
     69                     
     70                      // have find !!!
     71                      ack                           = PORT_READ(in_EXECUTE_UNIT_IN_ACK [dest][port]);
     72                      execute_unit_use [dest][port] = true;
    3473
    35         log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION,"Test Read_unit[%d]",i);
    36 
    37         if (PORT_READ(in_READ_UNIT_OUT_VAL [i]) == true)
    38           {
    39             log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION," * have a valid entry.");
    40            
    41             Tcontext_t context_id    = (_param->_have_port_context_id   )?PORT_READ(in_READ_UNIT_OUT_CONTEXT_ID    [i]):0;
    42             Tcontext_t front_end_id  = (_param->_have_port_front_end_id )?PORT_READ(in_READ_UNIT_OUT_FRONT_END_ID  [i]):0;
    43             Tcontext_t ooo_engine_id = (_param->_have_port_ooo_engine_id)?PORT_READ(in_READ_UNIT_OUT_OOO_ENGINE_ID [i]):0;
    44             Tcontext_t num_thread    = get_num_thread(context_id   , _param->_size_context_id   ,
    45                                                       front_end_id , _param->_size_front_end_id ,
    46                                                       ooo_engine_id, _param->_size_ooo_engine_id);
    47             Ttype_t    type          = PORT_READ(in_READ_UNIT_OUT_TYPE [i]);
    48            
    49 #ifdef DEBUG_TEST
    50             if (_destination[i][num_thread][type].empty())
    51               throw ERRORMORPHEO(FUNCTION,"Invalid Operation : They have no execute_unit to receive a operation from the read_unit ["+toString(i)+"], thread ["+toString(num_thread)+"] and a operation's type ["+toString_type(type)+"].");
    52 #endif
    53 
    54             // find a free execute_unit
    55             for (std::list<uint32_t>::iterator it=_destination[i][num_thread][type].begin();
    56                  (it != _destination[i][num_thread][type].end()) and (ack == false);
    57                  it++)
    58               {
    59                 uint32_t dest = *it;
    60 
    61                 log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION,"   * Test destination [%d].",dest);
    62                            
    63                 if (execute_unit_use [dest] == false)
    64                   {
    65                     log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION,"     * Is ok! Link.");
    66                     // have find !!!
    67                     ack                     = true;
    68                     execute_unit_use [dest] = true;
    69 
    70                     if (_param->_have_port_context_id)
    71                     PORT_WRITE(out_EXECUTE_UNIT_IN_CONTEXT_ID            [dest], PORT_READ(in_READ_UNIT_OUT_CONTEXT_ID            [i]));
    72                     if (_param->_have_port_front_end_id)
    73                     PORT_WRITE(out_EXECUTE_UNIT_IN_FRONT_END_ID          [dest], PORT_READ(in_READ_UNIT_OUT_FRONT_END_ID          [i]));
    74                     if (_param->_have_port_ooo_engine_id)
    75                     PORT_WRITE(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID         [dest], PORT_READ(in_READ_UNIT_OUT_OOO_ENGINE_ID         [i]));
    76                     if (_param->_have_port_packet_id)
    77                     PORT_WRITE(out_EXECUTE_UNIT_IN_PACKET_ID             [dest], PORT_READ(in_READ_UNIT_OUT_PACKET_ID             [i]));
    78                     PORT_WRITE(out_EXECUTE_UNIT_IN_OPERATION             [dest], PORT_READ(in_READ_UNIT_OUT_OPERATION             [i]));
    79                     PORT_WRITE(out_EXECUTE_UNIT_IN_TYPE                  [dest], PORT_READ(in_READ_UNIT_OUT_TYPE                  [i]));
    80                     PORT_WRITE(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT          [dest], PORT_READ(in_READ_UNIT_OUT_HAS_IMMEDIAT          [i]));
    81                     PORT_WRITE(out_EXECUTE_UNIT_IN_DATA_RC               [dest], PORT_READ(in_READ_UNIT_OUT_DATA_RC               [i]));
    82                     PORT_WRITE(out_EXECUTE_UNIT_IN_WRITE_RD              [dest], PORT_READ(in_READ_UNIT_OUT_WRITE_RD              [i]));
    83                     PORT_WRITE(out_EXECUTE_UNIT_IN_WRITE_RE              [dest], PORT_READ(in_READ_UNIT_OUT_WRITE_RE              [i]));
    84                     PORT_WRITE(out_EXECUTE_UNIT_IN_NUM_REG_RE            [dest], PORT_READ(in_READ_UNIT_OUT_NUM_REG_RE            [i]));
    85                     PORT_WRITE(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [dest], PORT_READ(in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE [i]));
    86                     if (_param->_have_port_load_queue_ptr)
    87                     PORT_WRITE(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE  [dest], PORT_READ(in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE  [i]));
    88                     PORT_WRITE(out_EXECUTE_UNIT_IN_IMMEDIAT              [dest], PORT_READ(in_READ_UNIT_OUT_IMMEDIAT              [i]));
    89                     PORT_WRITE(out_EXECUTE_UNIT_IN_DATA_RA               [dest], PORT_READ(in_READ_UNIT_OUT_DATA_RA               [i]));
    90                     PORT_WRITE(out_EXECUTE_UNIT_IN_DATA_RB               [dest], PORT_READ(in_READ_UNIT_OUT_DATA_RB               [i]));
    91                     PORT_WRITE(out_EXECUTE_UNIT_IN_NUM_REG_RD            [dest], PORT_READ(in_READ_UNIT_OUT_NUM_REG_RD            [i]));
    92                   }
    93               }
    94           }
    95         PORT_WRITE(out_READ_UNIT_OUT_ACK [i], ack);
    96       }
     74                      if (_param->_have_port_context_id)
     75                      PORT_WRITE(out_EXECUTE_UNIT_IN_CONTEXT_ID            [dest][port], PORT_READ(in_READ_UNIT_OUT_CONTEXT_ID            [i][j]));
     76                      if (_param->_have_port_front_end_id)
     77                      PORT_WRITE(out_EXECUTE_UNIT_IN_FRONT_END_ID          [dest][port], PORT_READ(in_READ_UNIT_OUT_FRONT_END_ID          [i][j]));
     78                      if (_param->_have_port_ooo_engine_id)
     79                      PORT_WRITE(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID         [dest][port], PORT_READ(in_READ_UNIT_OUT_OOO_ENGINE_ID         [i][j]));
     80                      if (_param->_have_port_rob_ptr  )
     81                      PORT_WRITE(out_EXECUTE_UNIT_IN_PACKET_ID             [dest][port], PORT_READ(in_READ_UNIT_OUT_PACKET_ID             [i][j]));
     82                      PORT_WRITE(out_EXECUTE_UNIT_IN_OPERATION             [dest][port], PORT_READ(in_READ_UNIT_OUT_OPERATION             [i][j]));
     83                      PORT_WRITE(out_EXECUTE_UNIT_IN_TYPE                  [dest][port], PORT_READ(in_READ_UNIT_OUT_TYPE                  [i][j]));
     84                      PORT_WRITE(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT          [dest][port], PORT_READ(in_READ_UNIT_OUT_HAS_IMMEDIAT          [i][j]));
     85                      PORT_WRITE(out_EXECUTE_UNIT_IN_DATA_RC               [dest][port], PORT_READ(in_READ_UNIT_OUT_DATA_RC               [i][j]));
     86                      PORT_WRITE(out_EXECUTE_UNIT_IN_WRITE_RD              [dest][port], PORT_READ(in_READ_UNIT_OUT_WRITE_RD              [i][j]));
     87                      PORT_WRITE(out_EXECUTE_UNIT_IN_WRITE_RE              [dest][port], PORT_READ(in_READ_UNIT_OUT_WRITE_RE              [i][j]));
     88                      PORT_WRITE(out_EXECUTE_UNIT_IN_NUM_REG_RE            [dest][port], PORT_READ(in_READ_UNIT_OUT_NUM_REG_RE            [i][j]));
     89                      PORT_WRITE(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [dest][port], PORT_READ(in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE [i][j]));
     90                      if (_param->_have_port_load_queue_ptr)
     91                      PORT_WRITE(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE  [dest][port], PORT_READ(in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE  [i][j]));
     92                      PORT_WRITE(out_EXECUTE_UNIT_IN_IMMEDIAT              [dest][port], PORT_READ(in_READ_UNIT_OUT_IMMEDIAT              [i][j]));
     93                      PORT_WRITE(out_EXECUTE_UNIT_IN_DATA_RA               [dest][port], PORT_READ(in_READ_UNIT_OUT_DATA_RA               [i][j]));
     94                      PORT_WRITE(out_EXECUTE_UNIT_IN_DATA_RB               [dest][port], PORT_READ(in_READ_UNIT_OUT_DATA_RB               [i][j]));
     95                      PORT_WRITE(out_EXECUTE_UNIT_IN_NUM_REG_RD            [dest][port], PORT_READ(in_READ_UNIT_OUT_NUM_REG_RD            [i][j]));
     96                    }
     97                }
     98            }
     99          PORT_WRITE(out_READ_UNIT_OUT_ACK [i][j], ack);
     100        }
    97101
    98102    for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
    99       {
    100         PORT_WRITE(out_EXECUTE_UNIT_IN_VAL[i], execute_unit_use[i]); 
    101       }
     103      for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
     104        PORT_WRITE(out_EXECUTE_UNIT_IN_VAL[i][j], execute_unit_use[i][j]);
    102105
    103106    log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"End");

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

    r81 r88  
    3434        // Fill routing table
    3535        for (uint32_t i=0; i<_param->_nb_read_unit; i++)
    36           for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
    37             // Test if link between src and dest
    38             if (_param->_table_routing [i][j])
    39               // Test the thread accepted by the execute_unit
    40               for (uint32_t k=0; k<_param->_nb_thread; k++)
    41                 if (_param->_table_execute_thread[j][k])
    42                   // Test the type accepted by the execute_unit
    43                   for (uint32_t l=0; l<_param->_nb_type; l++)
    44                     if (_param->_table_execute_type [j][l])
    45                       // push_back == minor have a better priority
    46                       _destination [i][k][l].push_back(j);
     36          for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
     37            for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
     38              // Test if link between src and dest
     39              if (_param->_table_routing [i][x][y])
     40                // Test the thread accepted by the execute_unit
     41                for (uint32_t k=0; k<_param->_nb_thread; k++)
     42                  if (_param->_table_execute_thread[x][k])
     43                    // Test the type accepted by the execute_unit
     44                    for (uint32_t l=0; l<_param->_nb_type; l++)
     45                      if (_param->_table_execute_type [x][l])
     46                        // push_back == minor have a better priority
     47                        _destination [i][k][l].push_back(destination_t(x,y));
    4748      }
    4849    else
Note: See TracChangeset for help on using the changeset viewer.