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