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/Execution_unit_to_Write_unit
Files:
1 added
17 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");
Note: See TracChangeset for help on using the changeset viewer.