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/Register_unit
Files:
38 edited

Legend:

Unmodified
Added
Removed

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/SelfTest/Makefile

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

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

    r81 r88  
    1515#include <sys/time.h>
    1616
     17#include "Common/include/Time.h"
    1718#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/include/Register_unit_Glue.h"
    1819
    … …  
    2930void test    (string name,
    3031              morpheo::behavioural::core::multi_execute_loop::execute_loop::register_unit::register_unit_glue::Parameters * param);
    31 
    32 class Time
    33 {
    34 private : timeval time_begin;
    35 // private : timeval time_end;
    36  
    37 public  : Time ()
    38   {
    39     gettimeofday(&time_begin     ,NULL);
    40   };
    41 
    42 public  : ~Time ()
    43   {
    44     cout << *this;
    45   };
    46 
    47 public  : friend ostream& operator<< (ostream& output_stream,
    48                                       const Time & x)
    49   {
    50     timeval time_end;
    51    
    52     gettimeofday(&time_end       ,NULL);
    53    
    54     uint32_t nb_cycles = static_cast<uint32_t>(sc_simulation_time());
    55 
    56     double average = static_cast<double>(nb_cycles) / static_cast<double>(time_end.tv_sec-x.time_begin.tv_sec);
    57    
    58     output_stream << nb_cycles << "\t(" << average << " cycles / seconds )" << endl;
    59 
    60     return output_stream;
    61   }
    62 };

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

    r81 r88  
    7474         _nb_spr_write     ,
    7575         _nb_inst_insert_rob,
    76          _nb_inst_retire_rob);
     76         _nb_inst_retire_rob,
     77         true //is_toplevel
     78         );
    7779     
    7880      cout << param->print(1);

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

    r82 r88  
    2222#endif
    2323
     24  Tusage_t _usage = USE_ALL;
     25
     26//   _usage = usage_unset(_usage,USE_SYSTEMC              );
     27//   _usage = usage_unset(_usage,USE_VHDL                 );
     28//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
     29//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
     30//   _usage = usage_unset(_usage,USE_POSITION             );
     31   _usage = usage_unset(_usage,USE_STATISTICS           );
     32//   _usage = usage_unset(_usage,USE_INFORMATION          );
     33
    2434  Register_unit_Glue * _Register_unit_Glue = new Register_unit_Glue
    2535    (name.c_str(),
    … …  
    2838#endif
    2939     _param,
    30      USE_ALL);
     40     _usage);
    3141 
    3242#ifdef SYSTEMC
    … …  
    8898  sc_signal<Tcontrol_t        >  ***  in_INSERT_ROB_SPR_STATUS_ACK            ;
    8999
    90   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_VAL                       ;
    91   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_ACK                       ;
    92   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RD_OLD_USE                ;
    93   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RD_NEW_USE                ;
    94   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RE_OLD_USE                ;
    95   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RE_NEW_USE                ;
    96   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_GPR_STATUS_NEW_VAL        ;
    97   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_GPR_STATUS_NEW_ACK        ;
    98   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_GPR_STATUS_OLD_VAL        ;
    99   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_GPR_STATUS_OLD_ACK        ;
    100   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_SPR_STATUS_NEW_VAL        ;
    101   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_SPR_STATUS_NEW_ACK        ;
    102   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_SPR_STATUS_OLD_VAL        ;
    103   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_SPR_STATUS_OLD_ACK        ;
     100//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_VAL                       ;
     101//   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_ACK                       ;
     102//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RD_OLD_USE                ;
     103//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RD_NEW_USE                ;
     104//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RE_OLD_USE                ;
     105//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RE_NEW_USE                ;
     106//   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_GPR_STATUS_NEW_VAL        ;
     107//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_GPR_STATUS_NEW_ACK        ;
     108//   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_GPR_STATUS_OLD_VAL        ;
     109//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_GPR_STATUS_OLD_ACK        ;
     110//   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_SPR_STATUS_NEW_VAL        ;
     111//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_SPR_STATUS_NEW_ACK        ;
     112//   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_SPR_STATUS_OLD_VAL        ;
     113//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_SPR_STATUS_OLD_ACK        ;
    104114
    105115  string rename;
    … …  
    294304      }
    295305
    296     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    297     in_RETIRE_ROB_VAL                      = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
    298    out_RETIRE_ROB_ACK                      = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
    299     in_RETIRE_ROB_RD_OLD_USE               = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
    300     in_RETIRE_ROB_RD_NEW_USE               = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
    301     in_RETIRE_ROB_RE_OLD_USE               = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
    302     in_RETIRE_ROB_RE_NEW_USE               = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
    303    out_RETIRE_ROB_GPR_STATUS_OLD_VAL       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
    304    out_RETIRE_ROB_GPR_STATUS_NEW_VAL       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
    305     in_RETIRE_ROB_GPR_STATUS_OLD_ACK       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
    306     in_RETIRE_ROB_GPR_STATUS_NEW_ACK       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
    307    out_RETIRE_ROB_SPR_STATUS_OLD_VAL       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
    308    out_RETIRE_ROB_SPR_STATUS_NEW_VAL       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
    309     in_RETIRE_ROB_SPR_STATUS_OLD_ACK       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
    310     in_RETIRE_ROB_SPR_STATUS_NEW_ACK       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
    311 
    312     for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    313       {
    314         uint32_t x=_param->_nb_inst_retire_rob [i];
    315 
    316          in_RETIRE_ROB_VAL                      [i] = new sc_signal<Tcontrol_t> * [x];
    317         out_RETIRE_ROB_ACK                      [i] = new sc_signal<Tcontrol_t> * [x];
    318          in_RETIRE_ROB_RD_OLD_USE               [i] = new sc_signal<Tcontrol_t> * [x];
    319          in_RETIRE_ROB_RD_NEW_USE               [i] = new sc_signal<Tcontrol_t> * [x];
    320          in_RETIRE_ROB_RE_OLD_USE               [i] = new sc_signal<Tcontrol_t> * [x];
    321          in_RETIRE_ROB_RE_NEW_USE               [i] = new sc_signal<Tcontrol_t> * [x];
    322         out_RETIRE_ROB_GPR_STATUS_OLD_VAL       [i] = new sc_signal<Tcontrol_t> * [x];
    323         out_RETIRE_ROB_GPR_STATUS_NEW_VAL       [i] = new sc_signal<Tcontrol_t> * [x];
    324          in_RETIRE_ROB_GPR_STATUS_OLD_ACK       [i] = new sc_signal<Tcontrol_t> * [x];
    325          in_RETIRE_ROB_GPR_STATUS_NEW_ACK       [i] = new sc_signal<Tcontrol_t> * [x];
    326         out_RETIRE_ROB_SPR_STATUS_OLD_VAL       [i] = new sc_signal<Tcontrol_t> * [x];
    327         out_RETIRE_ROB_SPR_STATUS_NEW_VAL       [i] = new sc_signal<Tcontrol_t> * [x];
    328          in_RETIRE_ROB_SPR_STATUS_OLD_ACK       [i] = new sc_signal<Tcontrol_t> * [x];
    329          in_RETIRE_ROB_SPR_STATUS_NEW_ACK       [i] = new sc_signal<Tcontrol_t> * [x];
     306//     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     307//     in_RETIRE_ROB_VAL                      = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
     308//    out_RETIRE_ROB_ACK                      = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
     309//     in_RETIRE_ROB_RD_OLD_USE               = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
     310//     in_RETIRE_ROB_RD_NEW_USE               = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
     311//     in_RETIRE_ROB_RE_OLD_USE               = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
     312//     in_RETIRE_ROB_RE_NEW_USE               = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
     313//    out_RETIRE_ROB_GPR_STATUS_OLD_VAL       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
     314//    out_RETIRE_ROB_GPR_STATUS_NEW_VAL       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
     315//     in_RETIRE_ROB_GPR_STATUS_OLD_ACK       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
     316//     in_RETIRE_ROB_GPR_STATUS_NEW_ACK       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
     317//    out_RETIRE_ROB_SPR_STATUS_OLD_VAL       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
     318//    out_RETIRE_ROB_SPR_STATUS_NEW_VAL       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
     319//     in_RETIRE_ROB_SPR_STATUS_OLD_ACK       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
     320//     in_RETIRE_ROB_SPR_STATUS_NEW_ACK       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
     321
     322//     for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     323//       {
     324//      uint32_t x=_param->_nb_inst_retire_rob [i];
     325
     326//       in_RETIRE_ROB_VAL                      [i] = new sc_signal<Tcontrol_t> * [x];
     327//      out_RETIRE_ROB_ACK                      [i] = new sc_signal<Tcontrol_t> * [x];
     328//       in_RETIRE_ROB_RD_OLD_USE               [i] = new sc_signal<Tcontrol_t> * [x];
     329//       in_RETIRE_ROB_RD_NEW_USE               [i] = new sc_signal<Tcontrol_t> * [x];
     330//       in_RETIRE_ROB_RE_OLD_USE               [i] = new sc_signal<Tcontrol_t> * [x];
     331//       in_RETIRE_ROB_RE_NEW_USE               [i] = new sc_signal<Tcontrol_t> * [x];
     332//      out_RETIRE_ROB_GPR_STATUS_OLD_VAL       [i] = new sc_signal<Tcontrol_t> * [x];
     333//      out_RETIRE_ROB_GPR_STATUS_NEW_VAL       [i] = new sc_signal<Tcontrol_t> * [x];
     334//       in_RETIRE_ROB_GPR_STATUS_OLD_ACK       [i] = new sc_signal<Tcontrol_t> * [x];
     335//       in_RETIRE_ROB_GPR_STATUS_NEW_ACK       [i] = new sc_signal<Tcontrol_t> * [x];
     336//      out_RETIRE_ROB_SPR_STATUS_OLD_VAL       [i] = new sc_signal<Tcontrol_t> * [x];
     337//      out_RETIRE_ROB_SPR_STATUS_NEW_VAL       [i] = new sc_signal<Tcontrol_t> * [x];
     338//       in_RETIRE_ROB_SPR_STATUS_OLD_ACK       [i] = new sc_signal<Tcontrol_t> * [x];
     339//       in_RETIRE_ROB_SPR_STATUS_NEW_ACK       [i] = new sc_signal<Tcontrol_t> * [x];
    330340   
    331         for (uint32_t j=0; j<x; j++)
    332           {
    333                in_RETIRE_ROB_VAL                      [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
    334               out_RETIRE_ROB_ACK                      [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
    335                in_RETIRE_ROB_RD_OLD_USE               [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
    336                in_RETIRE_ROB_RD_NEW_USE               [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
    337                in_RETIRE_ROB_RE_OLD_USE               [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
    338                in_RETIRE_ROB_RE_NEW_USE               [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
    339               out_RETIRE_ROB_GPR_STATUS_OLD_VAL       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
    340                in_RETIRE_ROB_GPR_STATUS_OLD_ACK       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
    341               out_RETIRE_ROB_GPR_STATUS_NEW_VAL       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
    342                in_RETIRE_ROB_GPR_STATUS_NEW_ACK       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
    343               out_RETIRE_ROB_SPR_STATUS_OLD_VAL       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
    344                in_RETIRE_ROB_SPR_STATUS_OLD_ACK       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
    345               out_RETIRE_ROB_SPR_STATUS_NEW_VAL       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
    346                in_RETIRE_ROB_SPR_STATUS_NEW_ACK       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
    347             }
    348       }
     341//      for (uint32_t j=0; j<x; j++)
     342//        {
     343//             in_RETIRE_ROB_VAL                      [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
     344//            out_RETIRE_ROB_ACK                      [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
     345//             in_RETIRE_ROB_RD_OLD_USE               [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
     346//             in_RETIRE_ROB_RD_NEW_USE               [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
     347//             in_RETIRE_ROB_RE_OLD_USE               [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
     348//             in_RETIRE_ROB_RE_NEW_USE               [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
     349//            out_RETIRE_ROB_GPR_STATUS_OLD_VAL       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
     350//             in_RETIRE_ROB_GPR_STATUS_OLD_ACK       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
     351//            out_RETIRE_ROB_GPR_STATUS_NEW_VAL       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
     352//             in_RETIRE_ROB_GPR_STATUS_NEW_ACK       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
     353//            out_RETIRE_ROB_SPR_STATUS_OLD_VAL       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
     354//             in_RETIRE_ROB_SPR_STATUS_OLD_ACK       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
     355//            out_RETIRE_ROB_SPR_STATUS_NEW_VAL       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
     356//             in_RETIRE_ROB_SPR_STATUS_NEW_ACK       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
     357//          }
     358//       }
    349359   
    350360
    … …  
    451461      }
    452462
    453     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    454 
    455     for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    456       {
    457         uint32_t x=_param->_nb_inst_retire_rob [i];
    458 
    459         for (uint32_t j=0; j<x; j++)
    460           {
    461             (*(_Register_unit_Glue-> in_RETIRE_ROB_VAL                [i][j]))(*( in_RETIRE_ROB_VAL                [i][j]));
    462             (*(_Register_unit_Glue->out_RETIRE_ROB_ACK                [i][j]))(*(out_RETIRE_ROB_ACK                [i][j]));
    463             (*(_Register_unit_Glue-> in_RETIRE_ROB_RD_OLD_USE         [i][j]))(*( in_RETIRE_ROB_RD_OLD_USE         [i][j]));
    464             (*(_Register_unit_Glue-> in_RETIRE_ROB_RD_NEW_USE         [i][j]))(*( in_RETIRE_ROB_RD_NEW_USE         [i][j]));
    465             (*(_Register_unit_Glue-> in_RETIRE_ROB_RE_OLD_USE         [i][j]))(*( in_RETIRE_ROB_RE_OLD_USE         [i][j]));
    466             (*(_Register_unit_Glue-> in_RETIRE_ROB_RE_NEW_USE         [i][j]))(*( in_RETIRE_ROB_RE_NEW_USE         [i][j]));
    467             (*(_Register_unit_Glue->out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]))(*(out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]));
    468             (*(_Register_unit_Glue-> in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]));
    469             (*(_Register_unit_Glue->out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]))(*(out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]));
    470             (*(_Register_unit_Glue-> in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]));
    471             (*(_Register_unit_Glue->out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]))(*(out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]));
    472             (*(_Register_unit_Glue-> in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]));
    473             (*(_Register_unit_Glue->out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]))(*(out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]));
    474             (*(_Register_unit_Glue-> in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]));
    475             }
    476       }
     463//     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     464
     465//     for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     466//       {
     467//      uint32_t x=_param->_nb_inst_retire_rob [i];
     468
     469//      for (uint32_t j=0; j<x; j++)
     470//        {
     471//          (*(_Register_unit_Glue-> in_RETIRE_ROB_VAL                [i][j]))(*( in_RETIRE_ROB_VAL                [i][j]));
     472//          (*(_Register_unit_Glue->out_RETIRE_ROB_ACK                [i][j]))(*(out_RETIRE_ROB_ACK                [i][j]));
     473//          (*(_Register_unit_Glue-> in_RETIRE_ROB_RD_OLD_USE         [i][j]))(*( in_RETIRE_ROB_RD_OLD_USE         [i][j]));
     474//          (*(_Register_unit_Glue-> in_RETIRE_ROB_RD_NEW_USE         [i][j]))(*( in_RETIRE_ROB_RD_NEW_USE         [i][j]));
     475//          (*(_Register_unit_Glue-> in_RETIRE_ROB_RE_OLD_USE         [i][j]))(*( in_RETIRE_ROB_RE_OLD_USE         [i][j]));
     476//          (*(_Register_unit_Glue-> in_RETIRE_ROB_RE_NEW_USE         [i][j]))(*( in_RETIRE_ROB_RE_NEW_USE         [i][j]));
     477//          (*(_Register_unit_Glue->out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]))(*(out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]));
     478//          (*(_Register_unit_Glue-> in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]));
     479//          (*(_Register_unit_Glue->out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]))(*(out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]));
     480//          (*(_Register_unit_Glue-> in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]));
     481//          (*(_Register_unit_Glue->out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]))(*(out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]));
     482//          (*(_Register_unit_Glue-> in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]));
     483//          (*(_Register_unit_Glue->out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]))(*(out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]));
     484//          (*(_Register_unit_Glue-> in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]));
     485//          }
     486//       }
    477487   
    478488  cout << "<" << name << "> Start Simulation ............" << endl;
    … …  
    487497  const bool     test_write  = true;
    488498  const bool     test_insert = true;
    489   const bool     test_retire = true;
     499//   const bool     test_retire = true;
    490500
    491501  const  int32_t percent_transaction = 75;
    … …  
    517527  Tcontrol_t      spr_write_status_val       [_param->_nb_ooo_engine][_param->_nb_spr_write];
    518528
    519   uint32_t        max_nb_inst_retire_rob = 0;
    520 
    521   for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    522     if (_param->_nb_inst_retire_rob [i] > max_nb_inst_retire_rob)
    523       max_nb_inst_retire_rob = _param->_nb_inst_retire_rob [i];
    524 
    525   Tcontrol_t      retire_rob_ack                [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
    526   Tcontrol_t      retire_rob_gpr_status_new_val [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
    527   Tcontrol_t      retire_rob_gpr_status_old_val [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
    528   Tcontrol_t      retire_rob_spr_status_new_val [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
    529   Tcontrol_t      retire_rob_spr_status_old_val [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
     529//   uint32_t        max_nb_inst_retire_rob = 0;
     530
     531//   for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     532//     if (_param->_nb_inst_retire_rob [i] > max_nb_inst_retire_rob)
     533//       max_nb_inst_retire_rob = _param->_nb_inst_retire_rob [i];
     534
     535//   Tcontrol_t      retire_rob_ack                [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
     536//   Tcontrol_t      retire_rob_gpr_status_new_val [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
     537//   Tcontrol_t      retire_rob_gpr_status_old_val [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
     538//   Tcontrol_t      retire_rob_spr_status_new_val [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
     539//   Tcontrol_t      retire_rob_spr_status_old_val [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
    530540
    531541  uint32_t        max_nb_inst_insert_rob = 0;
    … …  
    706716        }
    707717     
    708       if (test_retire == true)
    709         {
    710           for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    711             {
    712               uint32_t x = _param->_nb_inst_retire_rob [i];
    713 
    714               for (uint32_t j=0; j<x; j++)
    715                 {
    716                 Tcontrol_t val                = (rand()%100)<=percent_transaction;
    717                 Tcontrol_t rd_old_use         = (rand()%100)<=percent_transaction;
    718                 Tcontrol_t rd_new_use         = (rand()%100)<=percent_transaction;
    719                 Tcontrol_t re_old_use         = (rand()%100)<=percent_transaction;
    720                 Tcontrol_t re_new_use         = (rand()%100)<=percent_transaction;
    721                 Tcontrol_t gpr_status_old_ack = (rand()%100)<=percent_transaction;
    722                 Tcontrol_t gpr_status_new_ack = (rand()%100)<=percent_transaction;
    723                 Tcontrol_t spr_status_old_ack = (rand()%100)<=percent_transaction;
    724                 Tcontrol_t spr_status_new_ack = (rand()%100)<=percent_transaction;
    725                  
    726                 in_RETIRE_ROB_VAL                [i][j]->write(val               );
    727                 in_RETIRE_ROB_RD_OLD_USE         [i][j]->write(rd_old_use        );
    728                 in_RETIRE_ROB_RD_NEW_USE         [i][j]->write(rd_new_use        );
    729                 in_RETIRE_ROB_RE_OLD_USE         [i][j]->write(re_old_use        );
    730                 in_RETIRE_ROB_RE_NEW_USE         [i][j]->write(re_new_use        );
    731                 in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]->write(gpr_status_old_ack);
    732                 in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]->write(gpr_status_new_ack);
    733                 in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]->write(spr_status_old_ack);
    734                 in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]->write(spr_status_new_ack);
     718//       if (test_retire == true)
     719//      {
     720//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     721//          {
     722//            uint32_t x = _param->_nb_inst_retire_rob [i];
     723
     724//            for (uint32_t j=0; j<x; j++)
     725//              {
     726//              Tcontrol_t val                = (rand()%100)<=percent_transaction;
     727//              Tcontrol_t rd_old_use         = (rand()%100)<=percent_transaction;
     728//              Tcontrol_t rd_new_use         = (rand()%100)<=percent_transaction;
     729//              Tcontrol_t re_old_use         = (rand()%100)<=percent_transaction;
     730//              Tcontrol_t re_new_use         = (rand()%100)<=percent_transaction;
     731//              Tcontrol_t gpr_status_old_ack = (rand()%100)<=percent_transaction;
     732//              Tcontrol_t gpr_status_new_ack = (rand()%100)<=percent_transaction;
     733//              Tcontrol_t spr_status_old_ack = (rand()%100)<=percent_transaction;
     734//              Tcontrol_t spr_status_new_ack = (rand()%100)<=percent_transaction;
     735                 
     736//              in_RETIRE_ROB_VAL                [i][j]->write(val               );
     737//              in_RETIRE_ROB_RD_OLD_USE         [i][j]->write(rd_old_use        );
     738//              in_RETIRE_ROB_RD_NEW_USE         [i][j]->write(rd_new_use        );
     739//              in_RETIRE_ROB_RE_OLD_USE         [i][j]->write(re_old_use        );
     740//              in_RETIRE_ROB_RE_NEW_USE         [i][j]->write(re_new_use        );
     741//              in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]->write(gpr_status_old_ack);
     742//              in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]->write(gpr_status_new_ack);
     743//              in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]->write(spr_status_old_ack);
     744//              in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]->write(spr_status_new_ack);
    735745               
    736                 retire_rob_ack                [i][j] = (gpr_status_new_ack and
    737                                                         gpr_status_old_ack and
    738                                                         spr_status_new_ack and
    739                                                         spr_status_old_ack);
    740 
    741 
    742                 retire_rob_gpr_status_old_val [i][j] = val and rd_old_use                        and gpr_status_new_ack and spr_status_old_ack and spr_status_new_ack;
    743                 retire_rob_gpr_status_new_val [i][j] = val and rd_new_use and gpr_status_old_ack                        and spr_status_old_ack and spr_status_new_ack;
    744                 retire_rob_spr_status_old_val [i][j] = val and re_old_use and gpr_status_old_ack and gpr_status_new_ack                        and spr_status_new_ack;
    745                 retire_rob_spr_status_new_val [i][j] = val and re_new_use and gpr_status_old_ack and gpr_status_new_ack and spr_status_old_ack                       ;
    746                 }
    747             }
    748         }
     746//              retire_rob_ack                [i][j] = (gpr_status_new_ack and
     747//                                                      gpr_status_old_ack and
     748//                                                      spr_status_new_ack and
     749//                                                      spr_status_old_ack);
     750
     751
     752//              retire_rob_gpr_status_old_val [i][j] = val and rd_old_use                        and gpr_status_new_ack and spr_status_old_ack and spr_status_new_ack;
     753//              retire_rob_gpr_status_new_val [i][j] = val and rd_new_use and gpr_status_old_ack                        and spr_status_old_ack and spr_status_new_ack;
     754//              retire_rob_spr_status_old_val [i][j] = val and re_old_use and gpr_status_old_ack and gpr_status_new_ack                        and spr_status_new_ack;
     755//              retire_rob_spr_status_new_val [i][j] = val and re_new_use and gpr_status_old_ack and gpr_status_new_ack and spr_status_old_ack                       ;
     756//              }
     757//          }
     758//      }
    749759
    750760      if (test_insert == true)
    … …  
    837847
    838848
    839       if (test_retire == true)
    840         {
    841           for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    842             {
    843               uint32_t x = _param->_nb_inst_retire_rob [i];
    844 
    845               for (uint32_t j=0; j<x; j++)
    846                 {
    847                   TEST(Tcontrol_t, out_RETIRE_ROB_ACK                [i][j]->read(), retire_rob_ack                [i][j]);
    848                   TEST(Tcontrol_t, out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]->read(), retire_rob_gpr_status_old_val [i][j]);
    849                   TEST(Tcontrol_t, out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]->read(), retire_rob_gpr_status_new_val [i][j]);
    850                   TEST(Tcontrol_t, out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]->read(), retire_rob_spr_status_old_val [i][j]);
    851                   TEST(Tcontrol_t, out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]->read(), retire_rob_spr_status_new_val [i][j]);
    852                 }
    853             }
    854         }
     849//       if (test_retire == true)
     850//      {
     851//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     852//          {
     853//            uint32_t x = _param->_nb_inst_retire_rob [i];
     854
     855//            for (uint32_t j=0; j<x; j++)
     856//              {
     857//                TEST(Tcontrol_t, out_RETIRE_ROB_ACK                [i][j]->read(), retire_rob_ack                [i][j]);
     858//                TEST(Tcontrol_t, out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]->read(), retire_rob_gpr_status_old_val [i][j]);
     859//                TEST(Tcontrol_t, out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]->read(), retire_rob_gpr_status_new_val [i][j]);
     860//                TEST(Tcontrol_t, out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]->read(), retire_rob_spr_status_old_val [i][j]);
     861//                TEST(Tcontrol_t, out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]->read(), retire_rob_spr_status_new_val [i][j]);
     862//              }
     863//          }
     864//      }
    855865
    856866      if (test_insert == true)
    … …  
    927937  delete [] out_INSERT_ROB_SPR_STATUS_VAL       ;
    928938  delete []  in_INSERT_ROB_SPR_STATUS_ACK       ;
    929   delete []  in_RETIRE_ROB_VAL                      ;
    930   delete [] out_RETIRE_ROB_ACK                      ;
    931   delete []  in_RETIRE_ROB_RD_OLD_USE               ;
    932   delete []  in_RETIRE_ROB_RD_NEW_USE               ;
    933   delete []  in_RETIRE_ROB_RE_OLD_USE               ;
    934   delete []  in_RETIRE_ROB_RE_NEW_USE               ;
    935   delete [] out_RETIRE_ROB_GPR_STATUS_OLD_VAL       ;
    936   delete [] out_RETIRE_ROB_GPR_STATUS_NEW_VAL       ;
    937   delete []  in_RETIRE_ROB_GPR_STATUS_OLD_ACK       ;
    938   delete []  in_RETIRE_ROB_GPR_STATUS_NEW_ACK       ;
    939   delete [] out_RETIRE_ROB_SPR_STATUS_OLD_VAL       ;
    940   delete [] out_RETIRE_ROB_SPR_STATUS_NEW_VAL       ;
    941   delete []  in_RETIRE_ROB_SPR_STATUS_OLD_ACK       ;
    942   delete []  in_RETIRE_ROB_SPR_STATUS_NEW_ACK       ;
     939//   delete []  in_RETIRE_ROB_VAL                      ;
     940//   delete [] out_RETIRE_ROB_ACK                      ;
     941//   delete []  in_RETIRE_ROB_RD_OLD_USE               ;
     942//   delete []  in_RETIRE_ROB_RD_NEW_USE               ;
     943//   delete []  in_RETIRE_ROB_RE_OLD_USE               ;
     944//   delete []  in_RETIRE_ROB_RE_NEW_USE               ;
     945//   delete [] out_RETIRE_ROB_GPR_STATUS_OLD_VAL       ;
     946//   delete [] out_RETIRE_ROB_GPR_STATUS_NEW_VAL       ;
     947//   delete []  in_RETIRE_ROB_GPR_STATUS_OLD_ACK       ;
     948//   delete []  in_RETIRE_ROB_GPR_STATUS_NEW_ACK       ;
     949//   delete [] out_RETIRE_ROB_SPR_STATUS_OLD_VAL       ;
     950//   delete [] out_RETIRE_ROB_SPR_STATUS_NEW_VAL       ;
     951//   delete []  in_RETIRE_ROB_SPR_STATUS_OLD_ACK       ;
     952//   delete []  in_RETIRE_ROB_SPR_STATUS_NEW_ACK       ;
    943953
    944954#endif

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/include/Parameters.h

    r81 r88  
    2222
    2323
     24
     25
    2426  class Parameters : public morpheo::behavioural::Parameters
    2527  {
    2628    //-----[ fields ]------------------------------------------------------------
    27   public : const uint32_t    _nb_ooo_engine        ;
    28   public : const uint32_t    _size_general_data    ;
    29   public : const uint32_t    _size_special_data    ;
    30   public : const uint32_t    _nb_gpr_read          ;
    31   public : const uint32_t    _nb_spr_read          ;   
    32   public : const uint32_t    _nb_gpr_write         ;
    33   public : const uint32_t    _nb_spr_write         ;
    34   public : const uint32_t  * _nb_inst_insert_rob   ;
    35   public : const uint32_t  * _nb_inst_retire_rob   ;
     29  public : uint32_t    _nb_ooo_engine        ;
     30//public : uint32_t    _size_general_data    ;
     31//public : uint32_t    _size_special_data    ;
     32  public : uint32_t    _nb_gpr_read          ;
     33  public : uint32_t    _nb_spr_read          ;   
     34  public : uint32_t    _nb_gpr_write         ;
     35  public : uint32_t    _nb_spr_write         ;
     36  public : uint32_t  * _nb_inst_insert_rob   ;
     37  public : uint32_t  * _nb_inst_retire_rob   ;
    3638
    37   public : const bool        _have_port_ooo_engine_id;
     39//public : bool        _have_port_ooo_engine_id;
    3840   
    3941    //-----[ methods ]-----------------------------------------------------------
    40   public : Parameters  (const uint32_t   nb_ooo_engine        ,
    41                         const uint32_t   size_general_data    ,
    42                         const uint32_t   size_special_data    ,
    43                         const uint32_t   nb_gpr_read          ,
    44                         const uint32_t   nb_spr_read          ,   
    45                         const uint32_t   nb_gpr_write         ,
    46                         const uint32_t   nb_spr_write         ,
    47                         const uint32_t * nb_inst_insert_rob   ,
    48                         const uint32_t * nb_inst_retire_rob   );
    49   public : Parameters  (Parameters & param) ;
     42  public : Parameters  (uint32_t   nb_ooo_engine        ,
     43                        uint32_t   size_general_data    ,
     44                        uint32_t   size_special_data    ,
     45                        uint32_t   nb_gpr_read          ,
     46                        uint32_t   nb_spr_read          ,   
     47                        uint32_t   nb_gpr_write         ,
     48                        uint32_t   nb_spr_write         ,
     49                        uint32_t * nb_inst_insert_rob   ,
     50                        uint32_t * nb_inst_retire_rob   ,
     51                        bool       is_toplevel=false);
     52//public : Parameters  (Parameters & param) ;
    5053  public : ~Parameters () ;
    51 
     54   
     55  public :        void            copy       (void);
     56   
    5257  public :        Parameters_test msg_error  (void);
    5358

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/include/Register_unit_Glue.h

    r82 r88  
    128128  public    : SC_IN (Tcontrol_t        )  ***  in_INSERT_ROB_SPR_STATUS_ACK            ;
    129129
    130     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    131   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_VAL                       ;
    132   public    : SC_OUT(Tcontrol_t        )  *** out_RETIRE_ROB_ACK                       ;
    133   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RD_OLD_USE                ;
    134   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RD_NEW_USE                ;
    135   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RE_OLD_USE                ;
    136   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RE_NEW_USE                ;
    137 
    138   public    : SC_OUT(Tcontrol_t        )  *** out_RETIRE_ROB_GPR_STATUS_NEW_VAL        ;
    139   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_GPR_STATUS_NEW_ACK        ;
    140   public    : SC_OUT(Tcontrol_t        )  *** out_RETIRE_ROB_GPR_STATUS_OLD_VAL        ;
    141   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_GPR_STATUS_OLD_ACK        ;
    142 
    143   public    : SC_OUT(Tcontrol_t        )  *** out_RETIRE_ROB_SPR_STATUS_NEW_VAL        ;
    144   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_SPR_STATUS_NEW_ACK        ;
    145   public    : SC_OUT(Tcontrol_t        )  *** out_RETIRE_ROB_SPR_STATUS_OLD_VAL        ;
    146   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_SPR_STATUS_OLD_ACK        ;
     130//     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     131//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_VAL                       ;
     132//   public    : SC_OUT(Tcontrol_t        )  *** out_RETIRE_ROB_ACK                       ;
     133//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RD_OLD_USE                ;
     134//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RD_NEW_USE                ;
     135//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RE_OLD_USE                ;
     136//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RE_NEW_USE                ;
     137
     138//   public    : SC_OUT(Tcontrol_t        )  *** out_RETIRE_ROB_GPR_STATUS_NEW_VAL        ;
     139//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_GPR_STATUS_NEW_ACK        ;
     140//   public    : SC_OUT(Tcontrol_t        )  *** out_RETIRE_ROB_GPR_STATUS_OLD_VAL        ;
     141//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_GPR_STATUS_OLD_ACK        ;
     142
     143//   public    : SC_OUT(Tcontrol_t        )  *** out_RETIRE_ROB_SPR_STATUS_NEW_VAL        ;
     144//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_SPR_STATUS_NEW_ACK        ;
     145//   public    : SC_OUT(Tcontrol_t        )  *** out_RETIRE_ROB_SPR_STATUS_OLD_VAL        ;
     146//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_SPR_STATUS_OLD_ACK        ;
    147147
    148148    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Parameters.cpp

    r81 r88  
    1919#undef  FUNCTION
    2020#define FUNCTION "Register_unit_Glue::Parameters"
    21   Parameters::Parameters (const uint32_t   nb_ooo_engine        ,
    22                           const uint32_t   size_general_data    ,
    23                           const uint32_t   size_special_data    ,
    24                           const uint32_t   nb_gpr_read          ,
    25                           const uint32_t   nb_spr_read          ,   
    26                           const uint32_t   nb_gpr_write         ,
    27                           const uint32_t   nb_spr_write         ,
    28                           const uint32_t * nb_inst_insert_rob   ,
    29                           const uint32_t * nb_inst_retire_rob   ):
    30     _nb_ooo_engine        (nb_ooo_engine    ),
    31     _size_general_data    (size_general_data),
    32     _size_special_data    (size_special_data),
    33     _nb_gpr_read          (nb_gpr_read      ),
    34     _nb_spr_read          (nb_spr_read      ),   
    35     _nb_gpr_write         (nb_gpr_write     ),
    36     _nb_spr_write         (nb_spr_write     ),
    37     _nb_inst_insert_rob   (nb_inst_insert_rob),
    38     _nb_inst_retire_rob   (nb_inst_retire_rob),
    39     _have_port_ooo_engine_id (nb_ooo_engine>1)
     21  Parameters::Parameters (uint32_t   nb_ooo_engine        ,
     22                          uint32_t   size_general_data    ,
     23                          uint32_t   size_special_data    ,
     24                          uint32_t   nb_gpr_read          ,
     25                          uint32_t   nb_spr_read          ,   
     26                          uint32_t   nb_gpr_write         ,
     27                          uint32_t   nb_spr_write         ,
     28                          uint32_t * nb_inst_insert_rob   ,
     29                          uint32_t * nb_inst_retire_rob   ,
     30                          bool       is_toplevel          )
    4031  {
    4132    log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
     33   
     34    _nb_ooo_engine           = nb_ooo_engine     ;
     35    _nb_gpr_read             = nb_gpr_read       ;
     36    _nb_spr_read             = nb_spr_read       ;   
     37    _nb_gpr_write            = nb_gpr_write      ;
     38    _nb_spr_write            = nb_spr_write      ;
     39    _nb_inst_insert_rob      = nb_inst_insert_rob;
     40    _nb_inst_retire_rob      = nb_inst_retire_rob;
     41
    4242    test();
     43
     44    if (is_toplevel)
     45      {
     46        _size_ooo_engine_id      = log2(nb_ooo_engine);
     47        _size_general_data       = size_general_data ;
     48        _size_special_data       = size_special_data ;
     49       
     50        _have_port_ooo_engine_id = _size_ooo_engine_id > 0;
     51
     52        copy();
     53      }
     54
    4355    log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
    4456  };
    4557 
     58// #undef  FUNCTION
     59// #define FUNCTION "Register_unit_Glue::Parameters (copy)"
     60//   Parameters::Parameters (Parameters & param):
     61//     _nb_ooo_engine        (param._nb_ooo_engine    ),
     62//     _size_general_data    (param._size_general_data),
     63//     _size_special_data    (param._size_special_data),
     64//     _nb_gpr_read          (param._nb_gpr_read      ),
     65//     _nb_spr_read          (param._nb_spr_read      ),   
     66//     _nb_gpr_write         (param._nb_gpr_write     ),
     67//     _nb_spr_write         (param._nb_spr_write     ),
     68//     _nb_inst_insert_rob   (param._nb_inst_insert_rob),
     69//     _nb_inst_retire_rob   (param._nb_inst_retire_rob),
     70//     _have_port_ooo_engine_id (param._have_port_ooo_engine_id)
     71//   {
     72//     log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
     73//     test();
     74//     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
     75//   };
     76
    4677#undef  FUNCTION
    47 #define FUNCTION "Register_unit_Glue::Parameters (copy)"
    48   Parameters::Parameters (Parameters & param):
    49     _nb_ooo_engine        (param._nb_ooo_engine    ),
    50     _size_general_data    (param._size_general_data),
    51     _size_special_data    (param._size_special_data),
    52     _nb_gpr_read          (param._nb_gpr_read      ),
    53     _nb_spr_read          (param._nb_spr_read      ),   
    54     _nb_gpr_write         (param._nb_gpr_write     ),
    55     _nb_spr_write         (param._nb_spr_write     ),
    56     _nb_inst_insert_rob   (param._nb_inst_insert_rob),
    57     _nb_inst_retire_rob   (param._nb_inst_retire_rob),
    58     _have_port_ooo_engine_id (param._have_port_ooo_engine_id)
     78#define FUNCTION "Register_unit_Glue::~Parameters"
     79  Parameters::~Parameters (void)
    5980  {
    6081    log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
    61     test();
    6282    log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
    6383  };
    6484
    6585#undef  FUNCTION
    66 #define FUNCTION "Register_unit_Glue::~Parameters"
    67   Parameters::~Parameters ()
     86#define FUNCTION "Register_unit_Glue::copy"
     87  void Parameters::copy (void)
    6888  {
    6989    log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue.cpp

    r81 r88  
    3838    log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
    3939
     40#if DEBUG_Register_unit_Glue == true
     41    log_printf(INFO,Register_unit_Glue,FUNCTION,_("<%s> Parameters"),_name.c_str());
     42
     43    std::cout << *param << std::endl;
     44#endif   
     45
    4046    log_printf(INFO,Register_unit_Glue,FUNCTION,"Allocation");
    4147    allocation ();
    4248
    4349#ifdef STATISTICS
    44     log_printf(INFO,Register_unit_Glue,FUNCTION,"Allocation of statistics");
    45 
    46     // Allocation of statistics
    47     statistics_declaration(param_statistics);
     50    if (usage_is_set(_usage,USE_STATISTICS))
     51      {
     52        log_printf(INFO,Register_unit_Glue,FUNCTION,"Allocation of statistics");
     53       
     54        // Allocation of statistics
     55        statistics_declaration(param_statistics);
     56      }
    4857#endif
    4958
    5059#ifdef VHDL
    51     // generate the vhdl
    52     log_printf(INFO,Register_unit_Glue,FUNCTION,"Generate the vhdl");
    53 
    54     vhdl();
     60    if (usage_is_set(_usage,USE_VHDL))
     61      {
     62        // generate the vhdl
     63        log_printf(INFO,Register_unit_Glue,FUNCTION,"Generate the vhdl");
     64       
     65        vhdl();
     66      }
    5567#endif
    5668
    5769#ifdef SYSTEMC
     70    if (usage_is_set(_usage,USE_SYSTEMC))
     71      {
    5872    // Constant
    5973
    … …  
    473487#endif   
    474488
    475     log_printf(INFO,Register_unit_Glue,FUNCTION,"Method - genMealy_retire");
    476 
    477     SC_METHOD (genMealy_retire);
    478     dont_initialize ();
    479 //     sensitive_neg << *(in_CLOCK);
    480     for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    481       {
    482         uint32_t x=_param->_nb_inst_retire_rob [i];
    483         for (uint32_t j=0; j<x; j++)
    484           sensitive << *( in_RETIRE_ROB_VAL                [i][j])
    485                     << *( in_RETIRE_ROB_RD_OLD_USE         [i][j])
    486                     << *( in_RETIRE_ROB_RD_NEW_USE         [i][j])
    487                     << *( in_RETIRE_ROB_RE_OLD_USE         [i][j])
    488                     << *( in_RETIRE_ROB_RE_NEW_USE         [i][j])
    489                     << *( in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j])
    490                     << *( in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j])
    491                     << *( in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j])
    492                     << *( in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]);
    493       }
    494 #ifdef SYSTEMCASS_SPECIFIC
    495     // List dependency information
    496     for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    497       {
    498         uint32_t x=_param->_nb_inst_retire_rob [i];
    499         for (uint32_t j=0; j<x; j++)
    500           {
    501             (*(out_RETIRE_ROB_ACK                [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]));
    502             (*(out_RETIRE_ROB_ACK                [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]));
    503             (*(out_RETIRE_ROB_ACK                [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]));
    504             (*(out_RETIRE_ROB_ACK                [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]));
    505 
    506             (*(out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_VAL                [i][j]));
    507             (*(out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_RD_OLD_USE         [i][j]));
    508             (*(out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]));
    509             (*(out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]));
    510             (*(out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]));
    511 
    512             (*(out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_VAL                [i][j]));
    513             (*(out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_RD_NEW_USE         [i][j]));
    514             (*(out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]));
    515             (*(out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]));
    516             (*(out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]));
    517 
    518             (*(out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_VAL                [i][j]));
    519             (*(out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_RE_OLD_USE         [i][j]));
    520             (*(out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]));
    521             (*(out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]));
    522             (*(out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]));
    523 
    524             (*(out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_VAL                [i][j]));
    525             (*(out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_RE_NEW_USE         [i][j]));
    526             (*(out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]));
    527             (*(out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]));
    528             (*(out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]));
    529           }
    530       }
    531 #endif   
    532 
     489//     log_printf(INFO,Register_unit_Glue,FUNCTION,"Method - genMealy_retire");
     490
     491//     SC_METHOD (genMealy_retire);
     492//     dont_initialize ();
     493// //     sensitive_neg << *(in_CLOCK);
     494//     for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     495//       {
     496//      uint32_t x=_param->_nb_inst_retire_rob [i];
     497//      for (uint32_t j=0; j<x; j++)
     498//        sensitive << *( in_RETIRE_ROB_VAL                [i][j])
     499//                  << *( in_RETIRE_ROB_RD_OLD_USE         [i][j])
     500//                  << *( in_RETIRE_ROB_RD_NEW_USE         [i][j])
     501//                  << *( in_RETIRE_ROB_RE_OLD_USE         [i][j])
     502//                  << *( in_RETIRE_ROB_RE_NEW_USE         [i][j])
     503//                  << *( in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j])
     504//                  << *( in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j])
     505//                  << *( in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j])
     506//                  << *( in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]);
     507//       }
     508// #ifdef SYSTEMCASS_SPECIFIC
     509//     // List dependency information
     510//     for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     511//       {
     512//      uint32_t x=_param->_nb_inst_retire_rob [i];
     513//      for (uint32_t j=0; j<x; j++)
     514//        {
     515//          (*(out_RETIRE_ROB_ACK                [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]));
     516//          (*(out_RETIRE_ROB_ACK                [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]));
     517//          (*(out_RETIRE_ROB_ACK                [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]));
     518//          (*(out_RETIRE_ROB_ACK                [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]));
     519
     520//          (*(out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_VAL                [i][j]));
     521//          (*(out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_RD_OLD_USE         [i][j]));
     522//          (*(out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]));
     523//          (*(out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]));
     524//          (*(out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]));
     525
     526//          (*(out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_VAL                [i][j]));
     527//          (*(out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_RD_NEW_USE         [i][j]));
     528//          (*(out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]));
     529//          (*(out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]));
     530//          (*(out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]));
     531
     532//          (*(out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_VAL                [i][j]));
     533//          (*(out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_RE_OLD_USE         [i][j]));
     534//          (*(out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]));
     535//          (*(out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]));
     536//          (*(out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]));
     537
     538//          (*(out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_VAL                [i][j]));
     539//          (*(out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_RE_NEW_USE         [i][j]));
     540//          (*(out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]));
     541//          (*(out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]));
     542//          (*(out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]));
     543//        }
     544//       }
     545// #endif   
     546      }
    533547#endif
    534548    log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
    … …  
    542556
    543557#ifdef STATISTICS
    544     log_printf(INFO,Register_unit_Glue,FUNCTION,"Generate Statistics file");
    545 
    546     delete _stat;
     558    if (usage_is_set(_usage,USE_STATISTICS))
     559      {
     560        log_printf(INFO,Register_unit_Glue,FUNCTION,"Generate Statistics file");
     561       
     562        delete _stat;
     563      }
    547564#endif
    548565

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_allocation.cpp

    r82 r88  
    9090       out_GPR_READ_ACK           [j] = interface->set_signal_valack_out (ACK);
    9191       if (_param->_have_port_ooo_engine_id == true)
    92         in_GPR_READ_OOO_ENGINE_ID [j] = interface->set_signal_in <Tcontext_t     > ("ooo_engine_id", log2(_param->_nb_ooo_engine));
     92        in_GPR_READ_OOO_ENGINE_ID [j] = interface->set_signal_in <Tcontext_t     > ("ooo_engine_id", _param->_size_ooo_engine_id);
    9393       out_GPR_READ_DATA          [j] = interface->set_signal_out<Tgeneral_data_t> ("data"         , _param->_size_general_data);
    9494       out_GPR_READ_DATA_VAL      [j] = interface->set_signal_out<Tcontrol_t     > ("data_val"     , 1);
    … …  
    166166       out_SPR_READ_ACK           [j] = interface->set_signal_valack_out (ACK);
    167167       if (_param->_have_port_ooo_engine_id == true)
    168         in_SPR_READ_OOO_ENGINE_ID [j] = interface->set_signal_in <Tcontext_t     > ("ooo_engine_id", log2(_param->_nb_ooo_engine));
     168        in_SPR_READ_OOO_ENGINE_ID [j] = interface->set_signal_in <Tcontext_t     > ("ooo_engine_id", _param->_size_ooo_engine_id);
    169169       out_SPR_READ_DATA          [j] = interface->set_signal_out<Tspecial_data_t> ("data"         , _param->_size_special_data);
    170170       out_SPR_READ_DATA_VAL      [j] = interface->set_signal_out<Tcontrol_t     > ("data_val"     , 1);
    … …  
    236236       out_GPR_WRITE_ACK           [j] = interface->set_signal_valack_out (ACK);
    237237       if (_param->_have_port_ooo_engine_id == true)
    238         in_GPR_WRITE_OOO_ENGINE_ID [j] = interface->set_signal_in <Tcontext_t     > ("ooo_engine_id", log2(_param->_nb_ooo_engine));
     238        in_GPR_WRITE_OOO_ENGINE_ID [j] = interface->set_signal_in <Tcontext_t     > ("ooo_engine_id", _param->_size_ooo_engine_id);
    239239
    240240       for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    … …  
    302302       out_SPR_WRITE_ACK           [j] = interface->set_signal_valack_out (ACK);
    303303       if (_param->_have_port_ooo_engine_id == true)
    304         in_SPR_WRITE_OOO_ENGINE_ID [j] = interface->set_signal_in <Tcontext_t     > ("ooo_engine_id", log2(_param->_nb_ooo_engine));
     304        in_SPR_WRITE_OOO_ENGINE_ID [j] = interface->set_signal_in <Tcontext_t     > ("ooo_engine_id", _param->_size_ooo_engine_id);
    305305
    306306       for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    … …  
    400400      }
    401401
    402     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    403     in_RETIRE_ROB_VAL                      = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
    404    out_RETIRE_ROB_ACK                      = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
    405     in_RETIRE_ROB_RD_OLD_USE               = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
    406     in_RETIRE_ROB_RD_NEW_USE               = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
    407     in_RETIRE_ROB_RE_OLD_USE               = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
    408     in_RETIRE_ROB_RE_NEW_USE               = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
    409    out_RETIRE_ROB_GPR_STATUS_OLD_VAL       = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
    410    out_RETIRE_ROB_GPR_STATUS_NEW_VAL       = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
    411     in_RETIRE_ROB_GPR_STATUS_OLD_ACK       = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
    412     in_RETIRE_ROB_GPR_STATUS_NEW_ACK       = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
    413    out_RETIRE_ROB_SPR_STATUS_OLD_VAL       = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
    414    out_RETIRE_ROB_SPR_STATUS_NEW_VAL       = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
    415     in_RETIRE_ROB_SPR_STATUS_OLD_ACK       = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
    416     in_RETIRE_ROB_SPR_STATUS_NEW_ACK       = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
    417 
    418     for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    419       {
    420         uint32_t x=_param->_nb_inst_retire_rob [i];
    421 
    422          in_RETIRE_ROB_VAL                      [i] = new SC_IN (Tcontrol_t) * [x];
    423         out_RETIRE_ROB_ACK                      [i] = new SC_OUT(Tcontrol_t) * [x];
    424          in_RETIRE_ROB_RD_OLD_USE               [i] = new SC_IN (Tcontrol_t) * [x];
    425          in_RETIRE_ROB_RD_NEW_USE               [i] = new SC_IN (Tcontrol_t) * [x];
    426          in_RETIRE_ROB_RE_OLD_USE               [i] = new SC_IN (Tcontrol_t) * [x];
    427          in_RETIRE_ROB_RE_NEW_USE               [i] = new SC_IN (Tcontrol_t) * [x];
    428         out_RETIRE_ROB_GPR_STATUS_OLD_VAL       [i] = new SC_OUT(Tcontrol_t) * [x];
    429         out_RETIRE_ROB_GPR_STATUS_NEW_VAL       [i] = new SC_OUT(Tcontrol_t) * [x];
    430          in_RETIRE_ROB_GPR_STATUS_OLD_ACK       [i] = new SC_IN (Tcontrol_t) * [x];
    431          in_RETIRE_ROB_GPR_STATUS_NEW_ACK       [i] = new SC_IN (Tcontrol_t) * [x];
    432         out_RETIRE_ROB_SPR_STATUS_OLD_VAL       [i] = new SC_OUT(Tcontrol_t) * [x];
    433         out_RETIRE_ROB_SPR_STATUS_NEW_VAL       [i] = new SC_OUT(Tcontrol_t) * [x];
    434          in_RETIRE_ROB_SPR_STATUS_OLD_ACK       [i] = new SC_IN (Tcontrol_t) * [x];
    435          in_RETIRE_ROB_SPR_STATUS_NEW_ACK       [i] = new SC_IN (Tcontrol_t) * [x];
     402//     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     403//     in_RETIRE_ROB_VAL                      = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
     404//    out_RETIRE_ROB_ACK                      = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
     405//     in_RETIRE_ROB_RD_OLD_USE               = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
     406//     in_RETIRE_ROB_RD_NEW_USE               = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
     407//     in_RETIRE_ROB_RE_OLD_USE               = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
     408//     in_RETIRE_ROB_RE_NEW_USE               = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
     409//    out_RETIRE_ROB_GPR_STATUS_OLD_VAL       = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
     410//    out_RETIRE_ROB_GPR_STATUS_NEW_VAL       = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
     411//     in_RETIRE_ROB_GPR_STATUS_OLD_ACK       = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
     412//     in_RETIRE_ROB_GPR_STATUS_NEW_ACK       = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
     413//    out_RETIRE_ROB_SPR_STATUS_OLD_VAL       = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
     414//    out_RETIRE_ROB_SPR_STATUS_NEW_VAL       = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
     415//     in_RETIRE_ROB_SPR_STATUS_OLD_ACK       = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
     416//     in_RETIRE_ROB_SPR_STATUS_NEW_ACK       = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
     417
     418//     for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     419//       {
     420//      uint32_t x=_param->_nb_inst_retire_rob [i];
     421
     422//       in_RETIRE_ROB_VAL                      [i] = new SC_IN (Tcontrol_t) * [x];
     423//      out_RETIRE_ROB_ACK                      [i] = new SC_OUT(Tcontrol_t) * [x];
     424//       in_RETIRE_ROB_RD_OLD_USE               [i] = new SC_IN (Tcontrol_t) * [x];
     425//       in_RETIRE_ROB_RD_NEW_USE               [i] = new SC_IN (Tcontrol_t) * [x];
     426//       in_RETIRE_ROB_RE_OLD_USE               [i] = new SC_IN (Tcontrol_t) * [x];
     427//       in_RETIRE_ROB_RE_NEW_USE               [i] = new SC_IN (Tcontrol_t) * [x];
     428//      out_RETIRE_ROB_GPR_STATUS_OLD_VAL       [i] = new SC_OUT(Tcontrol_t) * [x];
     429//      out_RETIRE_ROB_GPR_STATUS_NEW_VAL       [i] = new SC_OUT(Tcontrol_t) * [x];
     430//       in_RETIRE_ROB_GPR_STATUS_OLD_ACK       [i] = new SC_IN (Tcontrol_t) * [x];
     431//       in_RETIRE_ROB_GPR_STATUS_NEW_ACK       [i] = new SC_IN (Tcontrol_t) * [x];
     432//      out_RETIRE_ROB_SPR_STATUS_OLD_VAL       [i] = new SC_OUT(Tcontrol_t) * [x];
     433//      out_RETIRE_ROB_SPR_STATUS_NEW_VAL       [i] = new SC_OUT(Tcontrol_t) * [x];
     434//       in_RETIRE_ROB_SPR_STATUS_OLD_ACK       [i] = new SC_IN (Tcontrol_t) * [x];
     435//       in_RETIRE_ROB_SPR_STATUS_NEW_ACK       [i] = new SC_IN (Tcontrol_t) * [x];
    436436   
    437         for (uint32_t j=0; j<x; j++)
    438           {
    439             {
    440               Interface_fifo * interface = _interfaces->set_interface("retire_rob_"+toString(i)+"_"+toString(j)
    441 #ifdef POSITION
    442                                                                       ,IN
    443                                                                       ,WEST
    444                                                                       ,"Interface to update status (retire)"
    445 #endif
    446                                                                       );
    447 
    448                in_RETIRE_ROB_VAL                      [i][j] = interface->set_signal_valack_in (VAL);
    449               out_RETIRE_ROB_ACK                      [i][j] = interface->set_signal_valack_out(ACK);
    450                in_RETIRE_ROB_RD_OLD_USE               [i][j] = interface->set_signal_in <Tcontrol_t> ("rd_old_use", 1);
    451                in_RETIRE_ROB_RD_NEW_USE               [i][j] = interface->set_signal_in <Tcontrol_t> ("rd_new_use", 1);
    452                in_RETIRE_ROB_RE_OLD_USE               [i][j] = interface->set_signal_in <Tcontrol_t> ("re_old_use", 1);
    453                in_RETIRE_ROB_RE_NEW_USE               [i][j] = interface->set_signal_in <Tcontrol_t> ("re_new_use", 1);
    454             }
    455             {
    456               Interface_fifo * interface = _interfaces->set_interface("retire_rob_gpr_status_old_"+toString(i)+"_"+toString(j)
    457 #ifdef POSITION
    458                                                                       ,IN
    459                                                                       ,EAST
    460                                                                       ,"Interface to update status (retire)"
    461 #endif
    462                                                                       );
    463 
    464               out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j] = interface->set_signal_valack_out(VAL);
    465                in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j] = interface->set_signal_valack_in (ACK);
    466             }
    467             {
    468               Interface_fifo * interface = _interfaces->set_interface("retire_rob_gpr_status_new_"+toString(i)+"_"+toString(j)
    469 #ifdef POSITION
    470                                                                       ,IN
    471                                                                       ,EAST
    472                                                                       ,"Interface to update status (retire)"
    473 #endif
    474                                                                       );
    475 
    476               out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j] = interface->set_signal_valack_out(VAL);
    477                in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j] = interface->set_signal_valack_in (ACK);
    478             }
    479             {
    480               Interface_fifo * interface = _interfaces->set_interface("retire_rob_spr_status_old_"+toString(i)+"_"+toString(j)
    481 #ifdef POSITION
    482                                                                       ,IN
    483                                                                       ,EAST
    484                                                                       ,"Interface to update status (retire)"
    485 #endif
    486                                                                       );
    487 
    488               out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j] = interface->set_signal_valack_out(VAL);
    489                in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j] = interface->set_signal_valack_in (ACK);
    490             }
    491             {
    492               Interface_fifo * interface = _interfaces->set_interface("retire_rob_spr_status_new_"+toString(i)+"_"+toString(j)
    493 #ifdef POSITION
    494                                                                       ,IN
    495                                                                       ,EAST
    496                                                                       ,"Interface to update status (retire)"
    497 #endif
    498                                                                       );
    499 
    500               out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j] = interface->set_signal_valack_out(VAL);
    501                in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j] = interface->set_signal_valack_in (ACK);
    502             }
    503           }
    504       }
     437//      for (uint32_t j=0; j<x; j++)
     438//        {
     439//          {
     440//            Interface_fifo * interface = _interfaces->set_interface("retire_rob_"+toString(i)+"_"+toString(j)
     441// #ifdef POSITION
     442//                                                                    ,IN
     443//                                                                    ,WEST
     444//                                                                    ,"Interface to update status (retire)"
     445// #endif
     446//                                                                    );
     447
     448//             in_RETIRE_ROB_VAL                      [i][j] = interface->set_signal_valack_in (VAL);
     449//            out_RETIRE_ROB_ACK                      [i][j] = interface->set_signal_valack_out(ACK);
     450//             in_RETIRE_ROB_RD_OLD_USE               [i][j] = interface->set_signal_in <Tcontrol_t> ("rd_old_use", 1);
     451//             in_RETIRE_ROB_RD_NEW_USE               [i][j] = interface->set_signal_in <Tcontrol_t> ("rd_new_use", 1);
     452//             in_RETIRE_ROB_RE_OLD_USE               [i][j] = interface->set_signal_in <Tcontrol_t> ("re_old_use", 1);
     453//             in_RETIRE_ROB_RE_NEW_USE               [i][j] = interface->set_signal_in <Tcontrol_t> ("re_new_use", 1);
     454//          }
     455//          {
     456//            Interface_fifo * interface = _interfaces->set_interface("retire_rob_gpr_status_old_"+toString(i)+"_"+toString(j)
     457// #ifdef POSITION
     458//                                                                    ,IN
     459//                                                                    ,EAST
     460//                                                                    ,"Interface to update status (retire)"
     461// #endif
     462//                                                                    );
     463
     464//            out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j] = interface->set_signal_valack_out(VAL);
     465//             in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j] = interface->set_signal_valack_in (ACK);
     466//          }
     467//          {
     468//            Interface_fifo * interface = _interfaces->set_interface("retire_rob_gpr_status_new_"+toString(i)+"_"+toString(j)
     469// #ifdef POSITION
     470//                                                                    ,IN
     471//                                                                    ,EAST
     472//                                                                    ,"Interface to update status (retire)"
     473// #endif
     474//                                                                    );
     475
     476//            out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j] = interface->set_signal_valack_out(VAL);
     477//             in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j] = interface->set_signal_valack_in (ACK);
     478//          }
     479//          {
     480//            Interface_fifo * interface = _interfaces->set_interface("retire_rob_spr_status_old_"+toString(i)+"_"+toString(j)
     481// #ifdef POSITION
     482//                                                                    ,IN
     483//                                                                    ,EAST
     484//                                                                    ,"Interface to update status (retire)"
     485// #endif
     486//                                                                    );
     487
     488//            out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j] = interface->set_signal_valack_out(VAL);
     489//             in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j] = interface->set_signal_valack_in (ACK);
     490//          }
     491//          {
     492//            Interface_fifo * interface = _interfaces->set_interface("retire_rob_spr_status_new_"+toString(i)+"_"+toString(j)
     493// #ifdef POSITION
     494//                                                                    ,IN
     495//                                                                    ,EAST
     496//                                                                    ,"Interface to update status (retire)"
     497// #endif
     498//                                                                    );
     499
     500//            out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j] = interface->set_signal_valack_out(VAL);
     501//             in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j] = interface->set_signal_valack_in (ACK);
     502//          }
     503//        }
     504//       }
    505505
    506506    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    507507
    508508#ifdef POSITION
    509     _component->generate_file();
     509    if (usage_is_set(_usage,USE_POSITION))
     510      _component->generate_file();
    510511#endif
    511512

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_deallocation.cpp

    r81 r88  
    2323    log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
    2424
     25    if (usage_is_set(_usage,USE_VHDL))
     26      {
    2527//#if defined(STATISTICS) or defined(VHDL_TESTBENCH)
    2628    delete    in_CLOCK ;
    … …  
    9597    delete []  in_INSERT_ROB_SPR_STATUS_ACK       ;
    9698
    97     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    98     delete []  in_RETIRE_ROB_VAL                      ;
    99     delete [] out_RETIRE_ROB_ACK                      ;
    100     delete []  in_RETIRE_ROB_RD_OLD_USE               ;
    101     delete []  in_RETIRE_ROB_RD_NEW_USE               ;
    102     delete []  in_RETIRE_ROB_RE_OLD_USE               ;
    103     delete []  in_RETIRE_ROB_RE_NEW_USE               ;
    104     delete [] out_RETIRE_ROB_GPR_STATUS_OLD_VAL       ;
    105     delete [] out_RETIRE_ROB_GPR_STATUS_NEW_VAL       ;
    106     delete []  in_RETIRE_ROB_GPR_STATUS_OLD_ACK       ;
    107     delete []  in_RETIRE_ROB_GPR_STATUS_NEW_ACK       ;
    108     delete [] out_RETIRE_ROB_SPR_STATUS_OLD_VAL       ;
    109     delete [] out_RETIRE_ROB_SPR_STATUS_NEW_VAL       ;
    110     delete []  in_RETIRE_ROB_SPR_STATUS_OLD_ACK       ;
    111     delete []  in_RETIRE_ROB_SPR_STATUS_NEW_ACK       ;
    112 
     99//     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     100//     delete []  in_RETIRE_ROB_VAL                      ;
     101//     delete [] out_RETIRE_ROB_ACK                      ;
     102//     delete []  in_RETIRE_ROB_RD_OLD_USE               ;
     103//     delete []  in_RETIRE_ROB_RD_NEW_USE               ;
     104//     delete []  in_RETIRE_ROB_RE_OLD_USE               ;
     105//     delete []  in_RETIRE_ROB_RE_NEW_USE               ;
     106//     delete [] out_RETIRE_ROB_GPR_STATUS_OLD_VAL       ;
     107//     delete [] out_RETIRE_ROB_GPR_STATUS_NEW_VAL       ;
     108//     delete []  in_RETIRE_ROB_GPR_STATUS_OLD_ACK       ;
     109//     delete []  in_RETIRE_ROB_GPR_STATUS_NEW_ACK       ;
     110//     delete [] out_RETIRE_ROB_SPR_STATUS_OLD_VAL       ;
     111//     delete [] out_RETIRE_ROB_SPR_STATUS_NEW_VAL       ;
     112//     delete []  in_RETIRE_ROB_SPR_STATUS_OLD_ACK       ;
     113//     delete []  in_RETIRE_ROB_SPR_STATUS_NEW_ACK       ;
     114      }
    113115    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    114116

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_end_cycle.cpp

    r81 r88  
    2424
    2525#ifdef STATISTICS
    26     _stat->end_cycle();
     26    if (usage_is_set(_usage,USE_STATISTICS))
     27      _stat->end_cycle();
    2728#endif   
    2829
    … …  
    3031    // Evaluation before read the ouput signal
    3132//  sc_start(0);
    32     _interfaces->testbench();
     33    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
     34      _interfaces->testbench();
    3335#endif
    3436

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_gpr_read.cpp

    r81 r88  
    2323  void Register_unit_Glue::genMealy_gpr_read (void)
    2424  {
    25     log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
     25    log_begin(Register_unit_Glue,FUNCTION);
     26    log_function(Register_unit_Glue,FUNCTION,_name.c_str());
    2627
    27     for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
     28//     if (not PORT_READ(in_NRESET))
     29//       {
     30//      for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
     31//        PORT_WRITE(out_GPR_READ_ACK      [j], 0);
     32//       }
     33//     else
    2834      {
    29         Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_GPR_READ_OOO_ENGINE_ID[j]):0;
    30         Tcontrol_t registerfile_ack = PORT_READ(in_GPR_READ_REGISTERFILE_ACK [ooo_engine_id][j]);
    31         Tcontrol_t status_ack       = PORT_READ(in_GPR_READ_STATUS_ACK       [ooo_engine_id][j]);
    32 
    33         // multiplexor
    34         PORT_WRITE(out_GPR_READ_ACK      [j], registerfile_ack and status_ack);
    35         PORT_WRITE(out_GPR_READ_DATA     [j], PORT_READ(in_GPR_READ_REGISTERFILE_DATA[ooo_engine_id][j]));
    36         PORT_WRITE(out_GPR_READ_DATA_VAL [j], PORT_READ(in_GPR_READ_STATUS_DATA_VAL  [ooo_engine_id][j]));
     35        for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
     36          {
     37            Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_GPR_READ_OOO_ENGINE_ID[j]):0;
     38            Tcontrol_t registerfile_ack = PORT_READ(in_GPR_READ_REGISTERFILE_ACK [ooo_engine_id][j]);
     39            Tcontrol_t status_ack       = PORT_READ(in_GPR_READ_STATUS_ACK       [ooo_engine_id][j]);
     40           
     41            // multiplexor
     42            PORT_WRITE(out_GPR_READ_ACK      [j], registerfile_ack and status_ack);
     43            PORT_WRITE(out_GPR_READ_DATA     [j], PORT_READ(in_GPR_READ_REGISTERFILE_DATA[ooo_engine_id][j]));
     44            PORT_WRITE(out_GPR_READ_DATA_VAL [j], PORT_READ(in_GPR_READ_STATUS_DATA_VAL  [ooo_engine_id][j]));
     45          }
    3746      }
    3847
    39     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
     48    log_end(Register_unit_Glue,FUNCTION);
    4049  };
    4150

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_gpr_read_registerfile.cpp

    r81 r88  
    2323  void Register_unit_Glue::genMealy_gpr_read_registerfile (void)
    2424  {
    25     log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
     25    log_begin(Register_unit_Glue,FUNCTION);
     26    log_function(Register_unit_Glue,FUNCTION,_name.c_str());
    2627
    27     for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
     28//     if (not PORT_READ(in_NRESET))
     29//       {
     30//      for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
     31//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     32//          PORT_WRITE(out_GPR_READ_REGISTERFILE_VAL [i][j],0);
     33//       }
     34//     else
    2835      {
    29         Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_GPR_READ_OOO_ENGINE_ID[j]):0;
    30         Tcontrol_t val              = PORT_READ(in_GPR_READ_VAL [j]);
    31         Tcontrol_t status_ack       = PORT_READ(in_GPR_READ_STATUS_ACK       [ooo_engine_id][j]);
    32    
    33         Tcontrol_t registerfile_val = val and status_ack;
    34 
    35         for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     36        for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
    3637          {
    37             Tcontrol_t id = (i == ooo_engine_id)?1:0;
    38             PORT_WRITE(out_GPR_READ_REGISTERFILE_VAL [i][j], (id and registerfile_val));
     38            Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_GPR_READ_OOO_ENGINE_ID[j]):0;
     39            Tcontrol_t val              = PORT_READ(in_GPR_READ_VAL [j]);
     40            Tcontrol_t status_ack       = PORT_READ(in_GPR_READ_STATUS_ACK       [ooo_engine_id][j]);
     41           
     42            Tcontrol_t registerfile_val = val and status_ack;
     43           
     44            for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     45              {
     46                Tcontrol_t id = (i == ooo_engine_id)?1:0;
     47                PORT_WRITE(out_GPR_READ_REGISTERFILE_VAL [i][j], (id and registerfile_val));
     48              }
    3949          }
    4050      }
    4151
    42     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
     52    log_end(Register_unit_Glue,FUNCTION);
    4353  };
    4454

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_gpr_read_status.cpp

    r81 r88  
    2323  void Register_unit_Glue::genMealy_gpr_read_status (void)
    2424  {
    25     log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
     25    log_begin(Register_unit_Glue,FUNCTION);
     26    log_function(Register_unit_Glue,FUNCTION,_name.c_str());
    2627
    27     for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
     28//     if (not PORT_READ(in_NRESET))
     29//       {
     30//      for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
     31//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     32//          PORT_WRITE(out_GPR_READ_STATUS_VAL       [i][j], 0);
     33//       }
     34//     else
    2835      {
    29         Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_GPR_READ_OOO_ENGINE_ID[j]):0;
    30         Tcontrol_t val              = PORT_READ(in_GPR_READ_VAL [j]);
    31         Tcontrol_t registerfile_ack = PORT_READ(in_GPR_READ_REGISTERFILE_ACK [ooo_engine_id][j]);
    32    
    33         Tcontrol_t status_val       = val and registerfile_ack;
    34 
    35         for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     36        for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
    3637          {
    37             Tcontrol_t id = (i == ooo_engine_id)?1:0;
    38             PORT_WRITE(out_GPR_READ_STATUS_VAL       [i][j], (id and status_val));
     38            Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_GPR_READ_OOO_ENGINE_ID[j]):0;
     39            Tcontrol_t val              = PORT_READ(in_GPR_READ_VAL [j]);
     40            Tcontrol_t registerfile_ack = PORT_READ(in_GPR_READ_REGISTERFILE_ACK [ooo_engine_id][j]);
     41           
     42            Tcontrol_t status_val       = val and registerfile_ack;
     43           
     44            for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     45              {
     46                Tcontrol_t id = (i == ooo_engine_id)?1:0;
     47                PORT_WRITE(out_GPR_READ_STATUS_VAL       [i][j], (id and status_val));
     48              }
    3949          }
    4050      }
    4151
    42     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
     52    log_end(Register_unit_Glue,FUNCTION);
    4353  };
    4454

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_gpr_registerfile.cpp

    r81 r88  
    2323  void Register_unit_Glue::genMealy_gpr_write_registerfile (void)
    2424  {
    25     log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
     25    log_begin(Register_unit_Glue,FUNCTION);
     26    log_function(Register_unit_Glue,FUNCTION,_name.c_str());
    2627
    27     for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
     28//     if (not PORT_READ(in_NRESET))
     29//       {
     30//      for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
     31//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     32//          PORT_WRITE(out_GPR_WRITE_REGISTERFILE_VAL [i][j], 0);
     33//       }
     34//     else
    2835      {
    29         Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_GPR_WRITE_OOO_ENGINE_ID[j]):0;
    30         Tcontrol_t val              = PORT_READ(in_GPR_WRITE_VAL [j]);
    31         Tcontrol_t status_ack       = PORT_READ(in_GPR_WRITE_STATUS_ACK       [ooo_engine_id][j]);
    32         Tcontrol_t registerfile_val = val and status_ack;
    33        
    34         for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     36        for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
    3537          {
    36             Tcontrol_t id = (i == ooo_engine_id)?1:0;
    37             PORT_WRITE(out_GPR_WRITE_REGISTERFILE_VAL [i][j], (id and registerfile_val));
     38            Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_GPR_WRITE_OOO_ENGINE_ID[j]):0;
     39            Tcontrol_t val              = PORT_READ(in_GPR_WRITE_VAL [j]);
     40            Tcontrol_t status_ack       = PORT_READ(in_GPR_WRITE_STATUS_ACK       [ooo_engine_id][j]);
     41            Tcontrol_t registerfile_val = val and status_ack;
     42           
     43            for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     44              {
     45                Tcontrol_t id = (i == ooo_engine_id)?1:0;
     46                PORT_WRITE(out_GPR_WRITE_REGISTERFILE_VAL [i][j], (id and registerfile_val));
     47              }
    3848          }
    3949      }
    4050
    41     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
     51    log_end(Register_unit_Glue,FUNCTION);
    4252  };
    4353

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_gpr_write.cpp

    r81 r88  
    2323  void Register_unit_Glue::genMealy_gpr_write (void)
    2424  {
    25     log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
    26 
    27     for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
     25    log_begin(Register_unit_Glue,FUNCTION);
     26    log_function(Register_unit_Glue,FUNCTION,_name.c_str());
     27//     if (not PORT_READ(in_NRESET))
     28//       {
     29//      for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
     30//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     31//          PORT_WRITE(out_GPR_WRITE_ACK [j], 0);
     32//       }
     33//     else
    2834      {
    29         Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_GPR_WRITE_OOO_ENGINE_ID[j]):0;
    30         Tcontrol_t registerfile_ack = PORT_READ(in_GPR_WRITE_REGISTERFILE_ACK [ooo_engine_id][j]);
    31         Tcontrol_t status_ack       = PORT_READ(in_GPR_WRITE_STATUS_ACK       [ooo_engine_id][j]);
    32 
    33         // multiplexor
    34         PORT_WRITE(out_GPR_WRITE_ACK [j],registerfile_ack and status_ack);
     35        for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
     36          {
     37            Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_GPR_WRITE_OOO_ENGINE_ID[j]):0;
     38            Tcontrol_t registerfile_ack = PORT_READ(in_GPR_WRITE_REGISTERFILE_ACK [ooo_engine_id][j]);
     39            Tcontrol_t status_ack       = PORT_READ(in_GPR_WRITE_STATUS_ACK       [ooo_engine_id][j]);
     40           
     41            // multiplexor
     42            PORT_WRITE(out_GPR_WRITE_ACK [j],registerfile_ack and status_ack);
     43          }
    3544      }
    36 
    37     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
     45   
     46    log_end(Register_unit_Glue,FUNCTION);
    3847  };
    3948

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_gpr_write_status.cpp

    r81 r88  
    2323  void Register_unit_Glue::genMealy_gpr_write_status (void)
    2424  {
    25     log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
     25    log_begin(Register_unit_Glue,FUNCTION);
     26    log_function(Register_unit_Glue,FUNCTION,_name.c_str());
    2627
    27     for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
     28//     if (not PORT_READ(in_NRESET))
     29//       {
     30//      for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
     31//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     32//          PORT_WRITE(out_GPR_WRITE_STATUS_VAL       [i][j], 0);
     33//       }
     34//     else
    2835      {
    29         Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_GPR_WRITE_OOO_ENGINE_ID[j]):0;
    30         Tcontrol_t val              = PORT_READ(in_GPR_WRITE_VAL [j]);
    31         Tcontrol_t registerfile_ack = PORT_READ(in_GPR_WRITE_REGISTERFILE_ACK [ooo_engine_id][j]);
    32         Tcontrol_t status_val       = val and registerfile_ack;
    33        
    34         for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     36        for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
    3537          {
    36             Tcontrol_t id = (i == ooo_engine_id)?1:0;
    37             PORT_WRITE(out_GPR_WRITE_STATUS_VAL       [i][j], (id and status_val));
     38            Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_GPR_WRITE_OOO_ENGINE_ID[j]):0;
     39            Tcontrol_t val              = PORT_READ(in_GPR_WRITE_VAL [j]);
     40            Tcontrol_t registerfile_ack = PORT_READ(in_GPR_WRITE_REGISTERFILE_ACK [ooo_engine_id][j]);
     41            Tcontrol_t status_val       = val and registerfile_ack;
     42           
     43            for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     44              {
     45                Tcontrol_t id = (i == ooo_engine_id)?1:0;
     46                PORT_WRITE(out_GPR_WRITE_STATUS_VAL       [i][j], (id and status_val));
     47              }
    3848          }
    3949      }
    4050
    41     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
     51    log_end(Register_unit_Glue,FUNCTION);
    4252  };
    4353

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_insert.cpp

    r81 r88  
    2323  void Register_unit_Glue::genMealy_insert (void)
    2424  {
    25     log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
     25    log_begin(Register_unit_Glue,FUNCTION);
     26    log_function(Register_unit_Glue,FUNCTION,_name.c_str());
    2627
    2728    for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    28       {
    29         uint32_t x=_param->_nb_inst_insert_rob [i];
     29      for (uint32_t j=0; j<_param->_nb_inst_insert_rob [i]; j++)
     30        {
     31          Tcontrol_t val            = PORT_READ(in_INSERT_ROB_VAL [i][j]);
     32          Tcontrol_t gpr_use        = PORT_READ(in_INSERT_ROB_RD_USE [i][j]);
     33          Tcontrol_t spr_use        = PORT_READ(in_INSERT_ROB_RE_USE [i][j]);
     34          Tcontrol_t gpr_status_ack = PORT_READ(in_INSERT_ROB_GPR_STATUS_ACK [i][j]);
     35          Tcontrol_t spr_status_ack = PORT_READ(in_INSERT_ROB_SPR_STATUS_ACK [i][j]);
     36         
     37          Tcontrol_t ack            = (gpr_status_ack and
     38                                       spr_status_ack);     
     39          Tcontrol_t gpr_status_val = (val     and
     40                                       gpr_use and
     41                                       spr_status_ack);
     42          Tcontrol_t spr_status_val = (val     and
     43                                       spr_use and
     44                                       gpr_status_ack);
    3045
    31         for (uint32_t j=0; j<x; j++)
    32           {
    33             Tcontrol_t val = PORT_READ(in_INSERT_ROB_VAL [i][j]);
    34             Tcontrol_t gpr_use = PORT_READ(in_INSERT_ROB_RD_USE [i][j]);
    35             Tcontrol_t spr_use = PORT_READ(in_INSERT_ROB_RE_USE [i][j]);
    36             Tcontrol_t gpr_ack = PORT_READ(in_INSERT_ROB_GPR_STATUS_ACK [i][j]);
    37             Tcontrol_t spr_ack = PORT_READ(in_INSERT_ROB_SPR_STATUS_ACK [i][j]);
    38            
    39             PORT_WRITE(out_INSERT_ROB_ACK [i][j], gpr_ack and spr_ack);     
    40             PORT_WRITE(out_INSERT_ROB_GPR_STATUS_VAL [i][j], val and gpr_use and spr_ack);
    41             PORT_WRITE(out_INSERT_ROB_SPR_STATUS_VAL [i][j], val and spr_use and gpr_ack);
    42           }
    43       }
     46          log_printf(TRACE,OOO_Engine_Glue,FUNCTION,"  * insert_rob [%d][%d]",i,j);
     47          log_printf(TRACE,OOO_Engine_Glue,FUNCTION,"    * val            (r) : %d",val           );
     48          log_printf(TRACE,OOO_Engine_Glue,FUNCTION,"    * ack            (w) : %d",ack           );
     49          log_printf(TRACE,OOO_Engine_Glue,FUNCTION,"    * gpr_use (rd)   (r) : %d",gpr_use       );
     50          log_printf(TRACE,OOO_Engine_Glue,FUNCTION,"    * gpr_status_val (w) : %d",gpr_status_val);
     51          log_printf(TRACE,OOO_Engine_Glue,FUNCTION,"    * gpr_status_ack (r) : %d",gpr_status_ack);
     52          log_printf(TRACE,OOO_Engine_Glue,FUNCTION,"    * spr_use (re)   (r) : %d",spr_use       );
     53          log_printf(TRACE,OOO_Engine_Glue,FUNCTION,"    * spr_status_val (w) : %d",spr_status_val);
     54          log_printf(TRACE,OOO_Engine_Glue,FUNCTION,"    * spr_status_ack (r) : %d",spr_status_ack);
    4455
    45     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
     56          PORT_WRITE(out_INSERT_ROB_ACK            [i][j], ack           );
     57          PORT_WRITE(out_INSERT_ROB_GPR_STATUS_VAL [i][j], gpr_status_val);
     58          PORT_WRITE(out_INSERT_ROB_SPR_STATUS_VAL [i][j], spr_status_val);
     59
     60        }
     61
     62    log_end(Register_unit_Glue,FUNCTION);
    4663  };
    4764

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_retire.cpp

    r81 r88  
    88 */
    99
     10/*
    1011#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/include/Register_unit_Glue.h"
    1112
    … …  
    2324  void Register_unit_Glue::genMealy_retire (void)
    2425  {
    25     log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
     26    log_begin(Register_unit_Glue,FUNCTION);
     27    log_function(Register_unit_Glue,FUNCTION,_name.c_str());
    2628
    2729    for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    … …  
    5759      }
    5860
    59     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
     61    log_end(Register_unit_Glue,FUNCTION);
    6062  };
    6163
    … …  
    6870}; // end namespace behavioural
    6971}; // end namespace morpheo             
     72*/
    7073#endif
    7174//#endif

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_spr_read.cpp

    r81 r88  
    2323  void Register_unit_Glue::genMealy_spr_read (void)
    2424  {
    25     log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
     25    log_begin(Register_unit_Glue,FUNCTION);
     26    log_function(Register_unit_Glue,FUNCTION,_name.c_str());
    2627
    27     for (uint32_t j=0; j<_param->_nb_spr_read; j++)
     28//     if (not PORT_READ(in_NRESET))
     29//       {
     30//      for (uint32_t j=0; j<_param->_nb_spr_read; j++)
     31//        PORT_WRITE(out_SPR_READ_ACK      [j], 0);
     32//       }
     33//     else
    2834      {
    29         Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_SPR_READ_OOO_ENGINE_ID[j]):0;
    30         Tcontrol_t registerfile_ack = PORT_READ(in_SPR_READ_REGISTERFILE_ACK [ooo_engine_id][j]);
    31         Tcontrol_t status_ack       = PORT_READ(in_SPR_READ_STATUS_ACK       [ooo_engine_id][j]);
    32 
    33         // multiplexor
    34         PORT_WRITE(out_SPR_READ_ACK      [j], registerfile_ack and status_ack);
    35         PORT_WRITE(out_SPR_READ_DATA     [j], PORT_READ(in_SPR_READ_REGISTERFILE_DATA[ooo_engine_id][j]));
    36         PORT_WRITE(out_SPR_READ_DATA_VAL [j], PORT_READ(in_SPR_READ_STATUS_DATA_VAL  [ooo_engine_id][j]));
     35        for (uint32_t j=0; j<_param->_nb_spr_read; j++)
     36          {
     37            Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_SPR_READ_OOO_ENGINE_ID[j]):0;
     38            Tcontrol_t registerfile_ack = PORT_READ(in_SPR_READ_REGISTERFILE_ACK [ooo_engine_id][j]);
     39            Tcontrol_t status_ack       = PORT_READ(in_SPR_READ_STATUS_ACK       [ooo_engine_id][j]);
     40           
     41            // multiplexor
     42            PORT_WRITE(out_SPR_READ_ACK      [j], registerfile_ack and status_ack);
     43            PORT_WRITE(out_SPR_READ_DATA     [j], PORT_READ(in_SPR_READ_REGISTERFILE_DATA[ooo_engine_id][j]));
     44            PORT_WRITE(out_SPR_READ_DATA_VAL [j], PORT_READ(in_SPR_READ_STATUS_DATA_VAL  [ooo_engine_id][j]));
     45          }
    3746      }
    3847
    39     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
     48    log_end(Register_unit_Glue,FUNCTION);
    4049  };
    4150

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_spr_read_registerfile.cpp

    r81 r88  
    2323  void Register_unit_Glue::genMealy_spr_read_registerfile (void)
    2424  {
    25     log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
     25    log_begin(Register_unit_Glue,FUNCTION);
     26    log_function(Register_unit_Glue,FUNCTION,_name.c_str());
    2627
    27     for (uint32_t j=0; j<_param->_nb_spr_read; j++)
     28//     if (not PORT_READ(in_NRESET))
     29//       {
     30//      for (uint32_t j=0; j<_param->_nb_spr_read; j++)
     31//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     32//          PORT_WRITE(out_SPR_READ_REGISTERFILE_VAL [i][j],0);
     33//       }
     34//     else
    2835      {
    29         Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_SPR_READ_OOO_ENGINE_ID[j]):0;
    30         Tcontrol_t val              = PORT_READ(in_SPR_READ_VAL [j]);
    31         Tcontrol_t status_ack       = PORT_READ(in_SPR_READ_STATUS_ACK       [ooo_engine_id][j]);
    32    
    33         Tcontrol_t registerfile_val = val and status_ack;
    34 
    35         for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     36        for (uint32_t j=0; j<_param->_nb_spr_read; j++)
    3637          {
    37             Tcontrol_t id = (i == ooo_engine_id)?1:0;
    38             PORT_WRITE(out_SPR_READ_REGISTERFILE_VAL [i][j], (id and registerfile_val));
     38            Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_SPR_READ_OOO_ENGINE_ID[j]):0;
     39            Tcontrol_t val              = PORT_READ(in_SPR_READ_VAL [j]);
     40           
     41            Tcontrol_t registerfile_val = val and PORT_READ(in_SPR_READ_STATUS_ACK [ooo_engine_id][j]);
     42           
     43            for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     44              {
     45                Tcontrol_t id = (i == ooo_engine_id)?1:0;
     46                PORT_WRITE(out_SPR_READ_REGISTERFILE_VAL [i][j], (id and registerfile_val));
     47              }
    3948          }
    4049      }
    4150
    42     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
     51    log_end(Register_unit_Glue,FUNCTION);
    4352  };
    4453

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_spr_read_status.cpp

    r81 r88  
    2323  void Register_unit_Glue::genMealy_spr_read_status (void)
    2424  {
    25     log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
     25    log_begin(Register_unit_Glue,FUNCTION);
     26    log_function(Register_unit_Glue,FUNCTION,_name.c_str());
    2627
    27     for (uint32_t j=0; j<_param->_nb_spr_read; j++)
     28//     if (not PORT_READ(in_NRESET))
     29//       {
     30//      for (uint32_t j=0; j<_param->_nb_spr_read; j++)
     31//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     32//          PORT_WRITE(out_SPR_READ_STATUS_VAL       [i][j], 0);
     33//       }
     34//     else
    2835      {
    29         Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_SPR_READ_OOO_ENGINE_ID[j]):0;
    30         Tcontrol_t val              = PORT_READ(in_SPR_READ_VAL [j]);
    31         Tcontrol_t registerfile_ack = PORT_READ(in_SPR_READ_REGISTERFILE_ACK [ooo_engine_id][j]);
    32    
    33         Tcontrol_t status_val       = val and registerfile_ack;
    34 
    35         for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     36        for (uint32_t j=0; j<_param->_nb_spr_read; j++)
    3637          {
    37             Tcontrol_t id = (i == ooo_engine_id)?1:0;
    38             PORT_WRITE(out_SPR_READ_STATUS_VAL       [i][j], (id and status_val));
     38            Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_SPR_READ_OOO_ENGINE_ID[j]):0;
     39            Tcontrol_t val              = PORT_READ(in_SPR_READ_VAL [j]);
     40           
     41            Tcontrol_t status_val       = val and PORT_READ(in_SPR_READ_REGISTERFILE_ACK [ooo_engine_id][j]);
     42           
     43            for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     44              {
     45                Tcontrol_t id = (i == ooo_engine_id)?1:0;
     46                PORT_WRITE(out_SPR_READ_STATUS_VAL       [i][j], (id and status_val));
     47              }
    3948          }
    4049      }
    4150
    42     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
     51    log_end(Register_unit_Glue,FUNCTION);
    4352  };
    4453

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_spr_registerfile.cpp

    r81 r88  
    2323  void Register_unit_Glue::genMealy_spr_write_registerfile (void)
    2424  {
    25     log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
     25    log_begin(Register_unit_Glue,FUNCTION);
     26    log_function(Register_unit_Glue,FUNCTION,_name.c_str());
    2627
    27     for (uint32_t j=0; j<_param->_nb_spr_write; j++)
     28//     if (not PORT_READ(in_NRESET))
     29//       {
     30//      for (uint32_t j=0; j<_param->_nb_spr_write; j++)
     31//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     32//          PORT_WRITE(out_SPR_WRITE_REGISTERFILE_VAL [i][j], 0);
     33//       }
     34//     else
    2835      {
    29         Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_SPR_WRITE_OOO_ENGINE_ID[j]):0;
    30         Tcontrol_t val              = PORT_READ(in_SPR_WRITE_VAL [j]);
    31         Tcontrol_t status_ack       = PORT_READ(in_SPR_WRITE_STATUS_ACK       [ooo_engine_id][j]);
    32         Tcontrol_t registerfile_val = val and status_ack;
    33        
    34         for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     36        for (uint32_t j=0; j<_param->_nb_spr_write; j++)
    3537          {
    36             Tcontrol_t id = (i == ooo_engine_id)?1:0;
    37             PORT_WRITE(out_SPR_WRITE_REGISTERFILE_VAL [i][j], (id and registerfile_val));
     38            Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_SPR_WRITE_OOO_ENGINE_ID[j]):0;
     39            Tcontrol_t val              = PORT_READ(in_SPR_WRITE_VAL [j]);
     40            Tcontrol_t status_ack       = PORT_READ(in_SPR_WRITE_STATUS_ACK       [ooo_engine_id][j]);
     41            Tcontrol_t registerfile_val = val and status_ack;
     42           
     43            for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     44              {
     45                Tcontrol_t id = (i == ooo_engine_id)?1:0;
     46                PORT_WRITE(out_SPR_WRITE_REGISTERFILE_VAL [i][j], (id and registerfile_val));
     47              }
    3848          }
    3949      }
    4050
    41     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
     51    log_end(Register_unit_Glue,FUNCTION);
    4252  };
    4353

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_spr_write.cpp

    r81 r88  
    2323  void Register_unit_Glue::genMealy_spr_write (void)
    2424  {
    25     log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
     25    log_begin(Register_unit_Glue,FUNCTION);
     26    log_function(Register_unit_Glue,FUNCTION,_name.c_str());
    2627
    27     for (uint32_t j=0; j<_param->_nb_spr_write; j++)
     28//     if (not PORT_READ(in_NRESET))
     29//       {
     30//      for (uint32_t j=0; j<_param->_nb_spr_write; j++)
     31//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     32//          PORT_WRITE(out_SPR_WRITE_ACK [j], 0);
     33//       }
     34//     else
    2835      {
    29         Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_SPR_WRITE_OOO_ENGINE_ID[j]):0;
    30         Tcontrol_t registerfile_ack = PORT_READ(in_SPR_WRITE_REGISTERFILE_ACK [ooo_engine_id][j]);
    31         Tcontrol_t status_ack       = PORT_READ(in_SPR_WRITE_STATUS_ACK       [ooo_engine_id][j]);
    32 
    33         // multiplexor
    34         PORT_WRITE(out_SPR_WRITE_ACK [j],registerfile_ack and status_ack);
     36        for (uint32_t j=0; j<_param->_nb_spr_write; j++)
     37          {
     38            Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_SPR_WRITE_OOO_ENGINE_ID[j]):0;
     39            Tcontrol_t registerfile_ack = PORT_READ(in_SPR_WRITE_REGISTERFILE_ACK [ooo_engine_id][j]);
     40            Tcontrol_t status_ack       = PORT_READ(in_SPR_WRITE_STATUS_ACK       [ooo_engine_id][j]);
     41           
     42            // multiplexor
     43            PORT_WRITE(out_SPR_WRITE_ACK [j],registerfile_ack and status_ack);
     44          }
    3545      }
    3646
    37     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
     47    log_end(Register_unit_Glue,FUNCTION);
    3848  };
    3949

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_spr_write_status.cpp

    r81 r88  
    2323  void Register_unit_Glue::genMealy_spr_write_status (void)
    2424  {
    25     log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
     25    log_begin(Register_unit_Glue,FUNCTION);
     26    log_function(Register_unit_Glue,FUNCTION,_name.c_str());
    2627
    27     for (uint32_t j=0; j<_param->_nb_spr_write; j++)
     28//     if (not PORT_READ(in_NRESET))
     29//       {
     30//      for (uint32_t j=0; j<_param->_nb_spr_write; j++)
     31//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     32//          PORT_WRITE(out_SPR_WRITE_STATUS_VAL       [i][j], 0);
     33//       }
     34//     else
    2835      {
    29         Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_SPR_WRITE_OOO_ENGINE_ID[j]):0;
    30         Tcontrol_t val              = PORT_READ(in_SPR_WRITE_VAL [j]);
    31         Tcontrol_t registerfile_ack = PORT_READ(in_SPR_WRITE_REGISTERFILE_ACK [ooo_engine_id][j]);
    32         Tcontrol_t status_val       = val and registerfile_ack;
    33        
    34         for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     36        for (uint32_t j=0; j<_param->_nb_spr_write; j++)
    3537          {
    36             Tcontrol_t id = (i == ooo_engine_id)?1:0;
    37             PORT_WRITE(out_SPR_WRITE_STATUS_VAL       [i][j], (id and status_val));
     38            Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_SPR_WRITE_OOO_ENGINE_ID[j]):0;
     39            Tcontrol_t val              = PORT_READ(in_SPR_WRITE_VAL [j]);
     40            Tcontrol_t registerfile_ack = PORT_READ(in_SPR_WRITE_REGISTERFILE_ACK [ooo_engine_id][j]);
     41            Tcontrol_t status_val       = val and registerfile_ack;
     42           
     43            for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     44              {
     45                Tcontrol_t id = (i == ooo_engine_id)?1:0;
     46                PORT_WRITE(out_SPR_WRITE_STATUS_VAL       [i][j], (id and status_val));
     47              }
    3848          }
    3949      }
    4050
    41     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
     51    log_end(Register_unit_Glue,FUNCTION);
    4252  };
    4353

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_transition.cpp

    r81 r88  
    2222  void Register_unit_Glue::transition (void)
    2323  {
    24     log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
     24    log_begin(Register_unit_Glue,FUNCTION);
    2525
    2626#if defined(STATISTICS) or defined(VHDL_TESTBENCH)
    … …  
    2828#endif
    2929
    30     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
     30    log_end(Register_unit_Glue,FUNCTION);
    3131  };
    3232

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_vhdl_body.cpp

    r81 r88  
    3737        for (uint32_t i=_param->_nb_ooo_engine-1; i>=1; i--)
    3838          {
    39             vhdl->set_body ("\tin_GPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK and in_GPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_GPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(log2(_param->_nb_ooo_engine),i)+" else");
     39            vhdl->set_body ("\tin_GPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK and in_GPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_GPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else");
    4040          }
    4141        vhdl->set_body ("\tin_GPR_READ_REGISTERFILE_0_"+toString(j)+"_ACK and in_GPR_READ_STATUS_0_"+toString(j)+"_ACK;");
    … …  
    4848        for (uint32_t i=_param->_nb_ooo_engine-1; i>=1; i--)
    4949          {
    50             vhdl->set_body ("\tin_GPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_DATA when in_GPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(log2(_param->_nb_ooo_engine),i)+" else");
     50            vhdl->set_body ("\tin_GPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_DATA when in_GPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else");
    5151          }
    5252        vhdl->set_body ("\tin_GPR_READ_REGISTERFILE_0_"+toString(j)+"_DATA;");
    … …  
    5959        for (uint32_t i=_param->_nb_ooo_engine-1; i>=1; i--)
    6060          {
    61             vhdl->set_body ("\tin_GPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_DATA_VAL when in_GPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(log2(_param->_nb_ooo_engine),i)+" else");
     61            vhdl->set_body ("\tin_GPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_DATA_VAL when in_GPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else");
    6262          }
    6363        vhdl->set_body ("\tin_GPR_READ_STATUS_0_"+toString(j)+"_DATA_VAL;");
    … …  
    7171            for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    7272              {
    73                 vhdl->set_body ("out_GPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_VAL <= in_GPR_READ_"+toString(j)+"_VAL and in_GPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_GPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(log2(_param->_nb_ooo_engine),i)+" else '0';");
     73                vhdl->set_body ("out_GPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_VAL <= in_GPR_READ_"+toString(j)+"_VAL and in_GPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_GPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else '0';");
    7474              }
    7575          }
    … …  
    8080            for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    8181              {
    82                 vhdl->set_body ("out_GPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_VAL <= in_GPR_READ_"+toString(j)+"_VAL and in_GPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK when in_GPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(log2(_param->_nb_ooo_engine),i)+" else '0';");
     82                vhdl->set_body ("out_GPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_VAL <= in_GPR_READ_"+toString(j)+"_VAL and in_GPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK when in_GPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else '0';");
    8383              }
    8484          }
    … …  
    102102        for (uint32_t i=_param->_nb_ooo_engine-1; i>=1; i--)
    103103          {
    104             vhdl->set_body ("\tin_GPR_WRITE_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK and in_GPR_WRITE_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_GPR_WRITE_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(log2(_param->_nb_ooo_engine),i)+" else");
     104            vhdl->set_body ("\tin_GPR_WRITE_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK and in_GPR_WRITE_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_GPR_WRITE_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else");
    105105          }
    106106        vhdl->set_body ("\tin_GPR_WRITE_REGISTERFILE_0_"+toString(j)+"_ACK and in_GPR_WRITE_STATUS_0_"+toString(j)+"_ACK;");
    … …  
    114114            for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    115115              {
    116                 vhdl->set_body ("out_GPR_WRITE_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_VAL <= in_GPR_WRITE_"+toString(j)+"_VAL and in_GPR_WRITE_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_GPR_WRITE_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(log2(_param->_nb_ooo_engine),i)+" else '0';");
     116                vhdl->set_body ("out_GPR_WRITE_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_VAL <= in_GPR_WRITE_"+toString(j)+"_VAL and in_GPR_WRITE_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_GPR_WRITE_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else '0';");
    117117              }
    118118          }
    … …  
    123123            for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    124124              {
    125                 vhdl->set_body ("out_GPR_WRITE_STATUS_"+toString(i)+"_"+toString(j)+"_VAL <= in_GPR_WRITE_"+toString(j)+"_VAL and in_GPR_WRITE_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK when in_GPR_WRITE_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(log2(_param->_nb_ooo_engine),i)+" else '0';");
     125                vhdl->set_body ("out_GPR_WRITE_STATUS_"+toString(i)+"_"+toString(j)+"_VAL <= in_GPR_WRITE_"+toString(j)+"_VAL and in_GPR_WRITE_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK when in_GPR_WRITE_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else '0';");
    126126              }
    127127          }
    … …  
    145145        for (uint32_t i=_param->_nb_ooo_engine-1; i>=1; i--)
    146146          {
    147             vhdl->set_body ("\tin_SPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK and in_SPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_SPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(log2(_param->_nb_ooo_engine),i)+" else");
     147            vhdl->set_body ("\tin_SPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK and in_SPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_SPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else");
    148148          }
    149149        vhdl->set_body ("\tin_SPR_READ_REGISTERFILE_0_"+toString(j)+"_ACK and in_SPR_READ_STATUS_0_"+toString(j)+"_ACK;");
    … …  
    156156        for (uint32_t i=_param->_nb_ooo_engine-1; i>=1; i--)
    157157          {
    158             vhdl->set_body ("\tin_SPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_DATA when in_SPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(log2(_param->_nb_ooo_engine),i)+" else");
     158            vhdl->set_body ("\tin_SPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_DATA when in_SPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else");
    159159          }
    160160        vhdl->set_body ("\tin_SPR_READ_REGISTERFILE_0_"+toString(j)+"_DATA;");
    … …  
    167167        for (uint32_t i=_param->_nb_ooo_engine-1; i>=1; i--)
    168168          {
    169             vhdl->set_body ("\tin_SPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_DATA_VAL when in_SPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(log2(_param->_nb_ooo_engine),i)+" else");
     169            vhdl->set_body ("\tin_SPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_DATA_VAL when in_SPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else");
    170170          }
    171171        vhdl->set_body ("\tin_SPR_READ_STATUS_0_"+toString(j)+"_DATA_VAL;");
    … …  
    179179            for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    180180              {
    181                 vhdl->set_body ("out_SPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_VAL <= in_SPR_READ_"+toString(j)+"_VAL and in_SPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_SPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(log2(_param->_nb_ooo_engine),i)+" else '0';");
     181                vhdl->set_body ("out_SPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_VAL <= in_SPR_READ_"+toString(j)+"_VAL and in_SPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_SPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else '0';");
    182182              }
    183183          }
    … …  
    188188            for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    189189              {
    190                 vhdl->set_body ("out_SPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_VAL <= in_SPR_READ_"+toString(j)+"_VAL and in_SPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK when in_SPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(log2(_param->_nb_ooo_engine),i)+" else '0';");
     190                vhdl->set_body ("out_SPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_VAL <= in_SPR_READ_"+toString(j)+"_VAL and in_SPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK when in_SPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else '0';");
    191191              }
    192192          }
    … …  
    210210        for (uint32_t i=_param->_nb_ooo_engine-1; i>=1; i--)
    211211          {
    212             vhdl->set_body ("\tin_SPR_WRITE_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK and in_SPR_WRITE_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_SPR_WRITE_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(log2(_param->_nb_ooo_engine),i)+" else");
     212            vhdl->set_body ("\tin_SPR_WRITE_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK and in_SPR_WRITE_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_SPR_WRITE_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else");
    213213          }
    214214        vhdl->set_body ("\tin_SPR_WRITE_REGISTERFILE_0_"+toString(j)+"_ACK and in_SPR_WRITE_STATUS_0_"+toString(j)+"_ACK;");
    … …  
    222222            for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    223223              {
    224                 vhdl->set_body ("out_SPR_WRITE_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_VAL <= in_SPR_WRITE_"+toString(j)+"_VAL and in_SPR_WRITE_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_SPR_WRITE_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(log2(_param->_nb_ooo_engine),i)+" else '0';");
     224                vhdl->set_body ("out_SPR_WRITE_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_VAL <= in_SPR_WRITE_"+toString(j)+"_VAL and in_SPR_WRITE_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_SPR_WRITE_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else '0';");
    225225              }
    226226          }
    … …  
    231231            for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    232232              {
    233                 vhdl->set_body ("out_SPR_WRITE_STATUS_"+toString(i)+"_"+toString(j)+"_VAL <= in_SPR_WRITE_"+toString(j)+"_VAL and in_SPR_WRITE_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK when in_SPR_WRITE_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(log2(_param->_nb_ooo_engine),i)+" else '0';");
     233                vhdl->set_body ("out_SPR_WRITE_STATUS_"+toString(i)+"_"+toString(j)+"_VAL <= in_SPR_WRITE_"+toString(j)+"_VAL and in_SPR_WRITE_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK when in_SPR_WRITE_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else '0';");
    234234              }
    235235          }

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

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

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

    r81 r88  
    1616
    1717#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/include/Register_unit.h"
     18#include "Common/include/Time.h"
    1819
    1920using namespace std;
    … …  
    2829void test    (string name,
    2930              morpheo::behavioural::core::multi_execute_loop::execute_loop::register_unit::Parameters * param);
    30 
    31 class Time
    32 {
    33 private : timeval time_begin;
    34 // private : timeval time_end;
    35  
    36 public  : Time ()
    37   {
    38     gettimeofday(&time_begin     ,NULL);
    39   };
    40 
    41 public  : ~Time ()
    42   {
    43     cout << *this;
    44   };
    45 
    46 public  : friend ostream& operator<< (ostream& output_stream,
    47                                       const Time & x)
    48   {
    49     timeval time_end;
    50    
    51     gettimeofday(&time_end       ,NULL);
    52    
    53     uint32_t nb_cycles = static_cast<uint32_t>(sc_simulation_time());
    54 
    55     double average = static_cast<double>(nb_cycles) / static_cast<double>(time_end.tv_sec-x.time_begin.tv_sec);
    56    
    57     output_stream << nb_cycles << "\t(" << average << " cycles / seconds )" << endl;
    58 
    59     return output_stream;
    60   }
    61 };

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

    r81 r88  
    104104         _nb_special_register       ,
    105105         _nb_inst_insert_rob        ,
    106          _nb_inst_retire_rob        );
     106         _nb_inst_retire_rob        ,
     107         true //is_toplevel
     108         );
    107109     
    108110      cout << param->print(1);

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

    r82 r88  
    2222#endif
    2323
     24  Tusage_t _usage = USE_ALL;
     25
     26//   _usage = usage_unset(_usage,USE_SYSTEMC              );
     27//   _usage = usage_unset(_usage,USE_VHDL                 );
     28//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
     29//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
     30//   _usage = usage_unset(_usage,USE_POSITION             );
     31//   _usage = usage_unset(_usage,USE_STATISTICS           );
     32//   _usage = usage_unset(_usage,USE_INFORMATION          );
     33
    2434  Register_unit * _Register_unit = new Register_unit
    2535    (name.c_str(),
    … …  
    2838#endif
    2939     _param,
    30      USE_ALL);
     40     _usage);
    3141 
    3242#ifdef SYSTEMC
    … …  
    7585  sc_signal<Tspecial_address_t>  ***  in_INSERT_ROB_RE_NUM_REG        ;
    7686
    77     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    78   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_VAL               ;
    79   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_ACK               ;
    80   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RD_OLD_USE        ;
    81   sc_signal<Tgeneral_address_t>  ***  in_RETIRE_ROB_RD_OLD_NUM_REG    ; // old_use=1 : status[old_num_reg]<- 0
    82   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RD_NEW_USE        ;
    83   sc_signal<Tgeneral_address_t>  ***  in_RETIRE_ROB_RD_NEW_NUM_REG    ; // new_use=1 : status[new_num_reg]<- 1
    84   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RE_OLD_USE        ;
    85   sc_signal<Tspecial_address_t>  ***  in_RETIRE_ROB_RE_OLD_NUM_REG    ;
    86   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RE_NEW_USE        ;
    87   sc_signal<Tspecial_address_t>  ***  in_RETIRE_ROB_RE_NEW_NUM_REG    ;
     87//     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     88//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_VAL               ;
     89//   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_ACK               ;
     90//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RD_OLD_USE        ;
     91//   sc_signal<Tgeneral_address_t>  ***  in_RETIRE_ROB_RD_OLD_NUM_REG    ; // old_use=1 : status[old_num_reg]<- 0
     92//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RD_NEW_USE        ;
     93//   sc_signal<Tgeneral_address_t>  ***  in_RETIRE_ROB_RD_NEW_NUM_REG    ; // new_use=1 : status[new_num_reg]<- 1
     94//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RE_OLD_USE        ;
     95//   sc_signal<Tspecial_address_t>  ***  in_RETIRE_ROB_RE_OLD_NUM_REG    ;
     96//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RE_NEW_USE        ;
     97//   sc_signal<Tspecial_address_t>  ***  in_RETIRE_ROB_RE_NEW_NUM_REG    ;
    8898
    8999  string rename = "signal";
    … …  
    192202       }
    193203
    194     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    195       in_RETIRE_ROB_VAL            = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
    196      out_RETIRE_ROB_ACK            = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
    197       in_RETIRE_ROB_RD_OLD_USE     = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
    198       in_RETIRE_ROB_RD_OLD_NUM_REG = new sc_signal<Tgeneral_address_t> ** [_param->_nb_ooo_engine];
    199       in_RETIRE_ROB_RE_OLD_USE     = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
    200       in_RETIRE_ROB_RE_OLD_NUM_REG = new sc_signal<Tspecial_address_t> ** [_param->_nb_ooo_engine];
    201       in_RETIRE_ROB_RD_NEW_USE     = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
    202       in_RETIRE_ROB_RD_NEW_NUM_REG = new sc_signal<Tgeneral_address_t> ** [_param->_nb_ooo_engine];
    203       in_RETIRE_ROB_RE_NEW_USE     = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
    204       in_RETIRE_ROB_RE_NEW_NUM_REG = new sc_signal<Tspecial_address_t> ** [_param->_nb_ooo_engine];
    205 
    206      for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    207        {
    208          uint32_t x=_param->_nb_inst_retire_rob [i];
    209 
    210           in_RETIRE_ROB_VAL            [i] = new sc_signal<Tcontrol_t        > * [x];
    211          out_RETIRE_ROB_ACK            [i] = new sc_signal<Tcontrol_t        > * [x];
    212           in_RETIRE_ROB_RD_OLD_USE     [i] = new sc_signal<Tcontrol_t        > * [x];
    213           in_RETIRE_ROB_RD_OLD_NUM_REG [i] = new sc_signal<Tgeneral_address_t> * [x];
    214           in_RETIRE_ROB_RE_OLD_USE     [i] = new sc_signal<Tcontrol_t        > * [x];
    215           in_RETIRE_ROB_RE_OLD_NUM_REG [i] = new sc_signal<Tspecial_address_t> * [x];
    216           in_RETIRE_ROB_RD_NEW_USE     [i] = new sc_signal<Tcontrol_t        > * [x];
    217           in_RETIRE_ROB_RD_NEW_NUM_REG [i] = new sc_signal<Tgeneral_address_t> * [x];
    218           in_RETIRE_ROB_RE_NEW_USE     [i] = new sc_signal<Tcontrol_t        > * [x];
    219           in_RETIRE_ROB_RE_NEW_NUM_REG [i] = new sc_signal<Tspecial_address_t> * [x];
    220 
    221          for (uint32_t j=0; j<x; j++)
    222            {
    223               in_RETIRE_ROB_VAL            [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
    224              out_RETIRE_ROB_ACK            [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
    225               in_RETIRE_ROB_RD_OLD_USE     [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
    226               in_RETIRE_ROB_RD_OLD_NUM_REG [i][j] = new sc_signal<Tgeneral_address_t> (rename.c_str());
    227               in_RETIRE_ROB_RE_OLD_USE     [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
    228               in_RETIRE_ROB_RE_OLD_NUM_REG [i][j] = new sc_signal<Tspecial_address_t> (rename.c_str());
    229               in_RETIRE_ROB_RD_NEW_USE     [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
    230               in_RETIRE_ROB_RD_NEW_NUM_REG [i][j] = new sc_signal<Tgeneral_address_t> (rename.c_str());
    231               in_RETIRE_ROB_RE_NEW_USE     [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
    232               in_RETIRE_ROB_RE_NEW_NUM_REG [i][j] = new sc_signal<Tspecial_address_t> (rename.c_str());
    233            }
    234        }
     204//     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     205//       in_RETIRE_ROB_VAL            = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
     206//      out_RETIRE_ROB_ACK            = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
     207//       in_RETIRE_ROB_RD_OLD_USE     = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
     208//       in_RETIRE_ROB_RD_OLD_NUM_REG = new sc_signal<Tgeneral_address_t> ** [_param->_nb_ooo_engine];
     209//       in_RETIRE_ROB_RE_OLD_USE     = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
     210//       in_RETIRE_ROB_RE_OLD_NUM_REG = new sc_signal<Tspecial_address_t> ** [_param->_nb_ooo_engine];
     211//       in_RETIRE_ROB_RD_NEW_USE     = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
     212//       in_RETIRE_ROB_RD_NEW_NUM_REG = new sc_signal<Tgeneral_address_t> ** [_param->_nb_ooo_engine];
     213//       in_RETIRE_ROB_RE_NEW_USE     = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
     214//       in_RETIRE_ROB_RE_NEW_NUM_REG = new sc_signal<Tspecial_address_t> ** [_param->_nb_ooo_engine];
     215
     216//      for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     217//        {
     218//       uint32_t x=_param->_nb_inst_retire_rob [i];
     219
     220//        in_RETIRE_ROB_VAL            [i] = new sc_signal<Tcontrol_t        > * [x];
     221//       out_RETIRE_ROB_ACK            [i] = new sc_signal<Tcontrol_t        > * [x];
     222//        in_RETIRE_ROB_RD_OLD_USE     [i] = new sc_signal<Tcontrol_t        > * [x];
     223//        in_RETIRE_ROB_RD_OLD_NUM_REG [i] = new sc_signal<Tgeneral_address_t> * [x];
     224//        in_RETIRE_ROB_RE_OLD_USE     [i] = new sc_signal<Tcontrol_t        > * [x];
     225//        in_RETIRE_ROB_RE_OLD_NUM_REG [i] = new sc_signal<Tspecial_address_t> * [x];
     226//        in_RETIRE_ROB_RD_NEW_USE     [i] = new sc_signal<Tcontrol_t        > * [x];
     227//        in_RETIRE_ROB_RD_NEW_NUM_REG [i] = new sc_signal<Tgeneral_address_t> * [x];
     228//        in_RETIRE_ROB_RE_NEW_USE     [i] = new sc_signal<Tcontrol_t        > * [x];
     229//        in_RETIRE_ROB_RE_NEW_NUM_REG [i] = new sc_signal<Tspecial_address_t> * [x];
     230
     231//       for (uint32_t j=0; j<x; j++)
     232//         {
     233//            in_RETIRE_ROB_VAL            [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
     234//           out_RETIRE_ROB_ACK            [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
     235//            in_RETIRE_ROB_RD_OLD_USE     [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
     236//            in_RETIRE_ROB_RD_OLD_NUM_REG [i][j] = new sc_signal<Tgeneral_address_t> (rename.c_str());
     237//            in_RETIRE_ROB_RE_OLD_USE     [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
     238//            in_RETIRE_ROB_RE_OLD_NUM_REG [i][j] = new sc_signal<Tspecial_address_t> (rename.c_str());
     239//            in_RETIRE_ROB_RD_NEW_USE     [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
     240//            in_RETIRE_ROB_RD_NEW_NUM_REG [i][j] = new sc_signal<Tgeneral_address_t> (rename.c_str());
     241//            in_RETIRE_ROB_RE_NEW_USE     [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
     242//            in_RETIRE_ROB_RE_NEW_NUM_REG [i][j] = new sc_signal<Tspecial_address_t> (rename.c_str());
     243//         }
     244//        }
    235245
    236246 
    … …  
    292302        (*(_Register_unit-> in_INSERT_ROB_RE_NUM_REG [i][j]))(*( in_INSERT_ROB_RE_NUM_REG [i][j]));
    293303      }
    294   for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    295     for (uint32_t j=0; j<_param->_nb_inst_retire_rob [i]; j++)
    296       {
    297         (*(_Register_unit-> in_RETIRE_ROB_VAL            [i][j]))(*( in_RETIRE_ROB_VAL            [i][j]));
    298         (*(_Register_unit->out_RETIRE_ROB_ACK            [i][j]))(*(out_RETIRE_ROB_ACK            [i][j]));
    299         (*(_Register_unit-> in_RETIRE_ROB_RD_OLD_USE     [i][j]))(*( in_RETIRE_ROB_RD_OLD_USE     [i][j]));
    300         (*(_Register_unit-> in_RETIRE_ROB_RD_OLD_NUM_REG [i][j]))(*( in_RETIRE_ROB_RD_OLD_NUM_REG [i][j]));
    301         (*(_Register_unit-> in_RETIRE_ROB_RE_OLD_USE     [i][j]))(*( in_RETIRE_ROB_RE_OLD_USE     [i][j]));
    302         (*(_Register_unit-> in_RETIRE_ROB_RE_OLD_NUM_REG [i][j]))(*( in_RETIRE_ROB_RE_OLD_NUM_REG [i][j]));
    303         (*(_Register_unit-> in_RETIRE_ROB_RD_NEW_USE     [i][j]))(*( in_RETIRE_ROB_RD_NEW_USE     [i][j]));
    304         (*(_Register_unit-> in_RETIRE_ROB_RD_NEW_NUM_REG [i][j]))(*( in_RETIRE_ROB_RD_NEW_NUM_REG [i][j]));
    305         (*(_Register_unit-> in_RETIRE_ROB_RE_NEW_USE     [i][j]))(*( in_RETIRE_ROB_RE_NEW_USE     [i][j]));
    306         (*(_Register_unit-> in_RETIRE_ROB_RE_NEW_NUM_REG [i][j]))(*( in_RETIRE_ROB_RE_NEW_NUM_REG [i][j]));
    307       }
     304//   for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     305//     for (uint32_t j=0; j<_param->_nb_inst_retire_rob [i]; j++)
     306//       {
     307//      (*(_Register_unit-> in_RETIRE_ROB_VAL            [i][j]))(*( in_RETIRE_ROB_VAL            [i][j]));
     308//      (*(_Register_unit->out_RETIRE_ROB_ACK            [i][j]))(*(out_RETIRE_ROB_ACK            [i][j]));
     309//      (*(_Register_unit-> in_RETIRE_ROB_RD_OLD_USE     [i][j]))(*( in_RETIRE_ROB_RD_OLD_USE     [i][j]));
     310//      (*(_Register_unit-> in_RETIRE_ROB_RD_OLD_NUM_REG [i][j]))(*( in_RETIRE_ROB_RD_OLD_NUM_REG [i][j]));
     311//      (*(_Register_unit-> in_RETIRE_ROB_RE_OLD_USE     [i][j]))(*( in_RETIRE_ROB_RE_OLD_USE     [i][j]));
     312//      (*(_Register_unit-> in_RETIRE_ROB_RE_OLD_NUM_REG [i][j]))(*( in_RETIRE_ROB_RE_OLD_NUM_REG [i][j]));
     313//      (*(_Register_unit-> in_RETIRE_ROB_RD_NEW_USE     [i][j]))(*( in_RETIRE_ROB_RD_NEW_USE     [i][j]));
     314//      (*(_Register_unit-> in_RETIRE_ROB_RD_NEW_NUM_REG [i][j]))(*( in_RETIRE_ROB_RD_NEW_NUM_REG [i][j]));
     315//      (*(_Register_unit-> in_RETIRE_ROB_RE_NEW_USE     [i][j]))(*( in_RETIRE_ROB_RE_NEW_USE     [i][j]));
     316//      (*(_Register_unit-> in_RETIRE_ROB_RE_NEW_NUM_REG [i][j]))(*( in_RETIRE_ROB_RE_NEW_NUM_REG [i][j]));
     317//       }
    308318 
    309319  cout << "<" << name << "> Start Simulation ............" << endl;
    … …  
    331341  const  int32_t percent_transaction_insert     = 70;
    332342  const  int32_t percent_transaction_insert_use = 70;
    333   const  int32_t percent_transaction_retire     = 70;
    334   const  int32_t percent_transaction_retire_use = 70;
     343//   const  int32_t percent_transaction_retire     = 70;
     344//   const  int32_t percent_transaction_retire_use = 70;
    335345  const uint32_t nb_request                     = max_nb_general_register;
    336346
    … …  
    365375      for (uint32_t j=0; j<_param->_nb_inst_insert_rob [i]; j++)
    366376        in_INSERT_ROB_VAL [i][j]->write(0);
    367       for (uint32_t j=0; j<_param->_nb_inst_retire_rob [i]; j++)
    368         in_RETIRE_ROB_VAL [i][j]->write(0);
     377//       for (uint32_t j=0; j<_param->_nb_inst_retire_rob [i]; j++)
     378//      in_RETIRE_ROB_VAL [i][j]->write(0);
    369379    }
    370380     
    … …  
    709719        }
    710720
    711       LABEL("retire rob");
    712 
    713       cpt = 0;
    714      
    715       while (cpt < nb_request)
    716         {
    717           for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    718             {
    719               uint32_t x=_param->_nb_inst_retire_rob [i];
    720               for (uint32_t j=0; j<x; j++)
    721                 {
    722                   in_RETIRE_ROB_VAL            [i][j]->write((rand() % 100) < percent_transaction_retire);
    723                   in_RETIRE_ROB_RD_OLD_USE     [i][j]->write((rand() % 100) < percent_transaction_retire_use);
    724                   in_RETIRE_ROB_RD_OLD_NUM_REG [i][j]->write(rand() % _param->_nb_general_register [i]);
    725                   in_RETIRE_ROB_RD_NEW_USE     [i][j]->write((rand() % 100) < percent_transaction_retire_use);
    726                   in_RETIRE_ROB_RD_NEW_NUM_REG [i][j]->write(rand() % _param->_nb_general_register [i]);           
    727                   in_RETIRE_ROB_RE_OLD_USE     [i][j]->write((rand() % 100) < percent_transaction_retire_use);
    728                   in_RETIRE_ROB_RE_OLD_NUM_REG [i][j]->write(rand() % _param->_nb_special_register [i]);           
    729                   in_RETIRE_ROB_RE_NEW_USE     [i][j]->write((rand() % 100) < percent_transaction_retire_use);
    730                   in_RETIRE_ROB_RE_NEW_NUM_REG [i][j]->write(rand() % _param->_nb_special_register [i]);           
    731                 }
    732             }
    733          
    734           SC_START(1);
    735          
    736           for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    737             {
    738               uint32_t x=_param->_nb_inst_retire_rob [i];
    739               for (uint32_t j=0; j<x; j++)
    740                 {
    741                   if (in_RETIRE_ROB_VAL [i][j]->read() and out_RETIRE_ROB_ACK [i][j]->read())
    742                     {
    743                       cpt ++;
     721//       LABEL("retire rob");
     722
     723//       cpt = 0;
     724     
     725//       while (cpt < nb_request)
     726//      {
     727//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     728//          {
     729//            uint32_t x=_param->_nb_inst_retire_rob [i];
     730//            for (uint32_t j=0; j<x; j++)
     731//              {
     732//                in_RETIRE_ROB_VAL            [i][j]->write((rand() % 100) < percent_transaction_retire);
     733//                in_RETIRE_ROB_RD_OLD_USE     [i][j]->write((rand() % 100) < percent_transaction_retire_use);
     734//                in_RETIRE_ROB_RD_OLD_NUM_REG [i][j]->write(rand() % _param->_nb_general_register [i]);
     735//                in_RETIRE_ROB_RD_NEW_USE     [i][j]->write((rand() % 100) < percent_transaction_retire_use);
     736//                in_RETIRE_ROB_RD_NEW_NUM_REG [i][j]->write(rand() % _param->_nb_general_register [i]);           
     737//                in_RETIRE_ROB_RE_OLD_USE     [i][j]->write((rand() % 100) < percent_transaction_retire_use);
     738//                in_RETIRE_ROB_RE_OLD_NUM_REG [i][j]->write(rand() % _param->_nb_special_register [i]);           
     739//                in_RETIRE_ROB_RE_NEW_USE     [i][j]->write((rand() % 100) < percent_transaction_retire_use);
     740//                in_RETIRE_ROB_RE_NEW_NUM_REG [i][j]->write(rand() % _param->_nb_special_register [i]);           
     741//              }
     742//          }
     743         
     744//        SC_START(1);
     745         
     746//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     747//          {
     748//            uint32_t x=_param->_nb_inst_retire_rob [i];
     749//            for (uint32_t j=0; j<x; j++)
     750//              {
     751//                if (in_RETIRE_ROB_VAL [i][j]->read() and out_RETIRE_ROB_ACK [i][j]->read())
     752//                  {
     753//                    cpt ++;
    744754                     
    745                       if (in_RETIRE_ROB_RD_OLD_USE [i][j]->read())
    746                         gpr_status [i][in_RETIRE_ROB_RD_OLD_NUM_REG [i][j]->read()] = 0;
    747                       if (in_RETIRE_ROB_RD_NEW_USE [i][j]->read())
    748                         gpr_status [i][in_RETIRE_ROB_RD_NEW_NUM_REG [i][j]->read()] = 1;
    749                       if (in_RETIRE_ROB_RE_OLD_USE [i][j]->read())
    750                         spr_status [i][in_RETIRE_ROB_RE_OLD_NUM_REG [i][j]->read()] = 0;
    751                       if (in_RETIRE_ROB_RE_NEW_USE [i][j]->read())
    752                         spr_status [i][in_RETIRE_ROB_RE_NEW_NUM_REG [i][j]->read()] = 1;
    753                     }
    754                 }
    755             }
    756         }
    757       for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    758         for (uint32_t j=0; j<_param->_nb_inst_retire_rob [i]; j++)
    759           in_RETIRE_ROB_VAL [i][j]->write(0);
     755//                    if (in_RETIRE_ROB_RD_OLD_USE [i][j]->read())
     756//                      gpr_status [i][in_RETIRE_ROB_RD_OLD_NUM_REG [i][j]->read()] = 0;
     757//                    if (in_RETIRE_ROB_RD_NEW_USE [i][j]->read())
     758//                      gpr_status [i][in_RETIRE_ROB_RD_NEW_NUM_REG [i][j]->read()] = 1;
     759//                    if (in_RETIRE_ROB_RE_OLD_USE [i][j]->read())
     760//                      spr_status [i][in_RETIRE_ROB_RE_OLD_NUM_REG [i][j]->read()] = 0;
     761//                    if (in_RETIRE_ROB_RE_NEW_USE [i][j]->read())
     762//                      spr_status [i][in_RETIRE_ROB_RE_NEW_NUM_REG [i][j]->read()] = 1;
     763//                  }
     764//              }
     765//          }
     766//      }
     767//       for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     768//      for (uint32_t j=0; j<_param->_nb_inst_retire_rob [i]; j++)
     769//        in_RETIRE_ROB_VAL [i][j]->write(0);
    760770
    761771      LABEL("(GPR) Read - and test data writted");
    … …  
    889899  delete []  in_INSERT_ROB_RE_USE            ;
    890900  delete []  in_INSERT_ROB_RE_NUM_REG        ;
    891   delete []  in_RETIRE_ROB_VAL               ;
    892   delete [] out_RETIRE_ROB_ACK               ;
    893   delete []  in_RETIRE_ROB_RD_OLD_USE        ;
    894   delete []  in_RETIRE_ROB_RD_OLD_NUM_REG    ;
    895   delete []  in_RETIRE_ROB_RD_NEW_USE        ;
    896   delete []  in_RETIRE_ROB_RD_NEW_NUM_REG    ;
    897   delete []  in_RETIRE_ROB_RE_OLD_USE        ;
    898   delete []  in_RETIRE_ROB_RE_OLD_NUM_REG    ;
    899   delete []  in_RETIRE_ROB_RE_NEW_USE        ;
    900   delete []  in_RETIRE_ROB_RE_NEW_NUM_REG    ;
     901//   delete []  in_RETIRE_ROB_VAL               ;
     902//   delete [] out_RETIRE_ROB_ACK               ;
     903//   delete []  in_RETIRE_ROB_RD_OLD_USE        ;
     904//   delete []  in_RETIRE_ROB_RD_OLD_NUM_REG    ;
     905//   delete []  in_RETIRE_ROB_RD_NEW_USE        ;
     906//   delete []  in_RETIRE_ROB_RD_NEW_NUM_REG    ;
     907//   delete []  in_RETIRE_ROB_RE_OLD_USE        ;
     908//   delete []  in_RETIRE_ROB_RE_OLD_NUM_REG    ;
     909//   delete []  in_RETIRE_ROB_RE_NEW_USE        ;
     910//   delete []  in_RETIRE_ROB_RE_NEW_NUM_REG    ;
    901911#endif
    902912

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

    r81 r88  
    2525  {
    2626    //-----[ fields ]------------------------------------------------------------
    27   public : const uint32_t    _nb_ooo_engine            ;
    28   public : const uint32_t    _size_general_data        ;
    29   public : const uint32_t    _size_special_data        ;
    30   public : const uint32_t    _nb_gpr_read              ;
    31   public : const uint32_t    _nb_gpr_write             ;
    32   public : const uint32_t    _nb_gpr_bank              ;
    33   public : const uint32_t    _nb_gpr_port_read_by_bank ;
    34   public : const uint32_t    _nb_gpr_port_write_by_bank;
    35   public : const uint32_t    _nb_spr_read              ;
    36   public : const uint32_t    _nb_spr_write             ;
    37   public : const uint32_t    _nb_spr_bank              ;
    38   public : const uint32_t    _nb_spr_port_read_by_bank ;
    39   public : const uint32_t    _nb_spr_port_write_by_bank;
    40   public : const uint32_t  * _nb_general_register      ;
    41   public : const uint32_t  * _nb_special_register      ;
    42   public : const uint32_t  * _nb_inst_insert_rob       ;
    43   public : const uint32_t  * _nb_inst_retire_rob       ;
     27  public : uint32_t    _nb_ooo_engine            ;
     28//public : uint32_t    _size_general_data        ;
     29//public : uint32_t    _size_special_data        ;
     30  public : uint32_t    _nb_gpr_read              ;
     31  public : uint32_t    _nb_gpr_write             ;
     32  public : uint32_t    _nb_gpr_bank              ;
     33  public : uint32_t    _nb_gpr_port_read_by_bank ;
     34  public : uint32_t    _nb_gpr_port_write_by_bank;
     35  public : uint32_t    _nb_spr_read              ;
     36  public : uint32_t    _nb_spr_write             ;
     37  public : uint32_t    _nb_spr_bank              ;
     38  public : uint32_t    _nb_spr_port_read_by_bank ;
     39  public : uint32_t    _nb_spr_port_write_by_bank;
     40  public : uint32_t  * _nb_general_register      ;
     41  public : uint32_t  * _nb_special_register      ;
     42  public : uint32_t  * _nb_inst_insert_rob       ;
     43  public : uint32_t  * _nb_inst_retire_rob       ;
    4444
    45   public : const bool        _have_port_ooo_engine_id  ;
    46   public :       uint32_t    _size_gpr_address         ;
    47   public :       uint32_t    _size_spr_address         ;
     45//public : bool        _have_port_ooo_engine_id  ;
     46  public : uint32_t    _size_gpr_address         ;
     47  public : uint32_t    _size_spr_address         ;
    4848
    4949  public : morpheo::behavioural::generic::registerfile::Parameters                                                     ** _param_gpr        ;
    … …  
    5151  public : morpheo::behavioural::generic::registerfile::Parameters                                                     ** _param_spr        ;
    5252  public : morpheo::behavioural::generic::registerfile::Parameters                                                     ** _param_spr_status ;
    53   public : morpheo::behavioural::generic::registerfile::registerfile_multi_banked::Parameters                          ** __param_gpr       ;
    54   public : morpheo::behavioural::generic::registerfile::registerfile_monolithic  ::Parameters                          ** __param_gpr_status;
    55   public : morpheo::behavioural::generic::registerfile::registerfile_multi_banked::Parameters                          ** __param_spr       ;
    56   public : morpheo::behavioural::generic::registerfile::registerfile_monolithic  ::Parameters                          ** __param_spr_status;
     53  private: morpheo::behavioural::generic::registerfile::registerfile_multi_banked::Parameters                          ** __param_gpr       ;
     54  private: morpheo::behavioural::generic::registerfile::registerfile_monolithic  ::Parameters                          ** __param_gpr_status;
     55  private: morpheo::behavioural::generic::registerfile::registerfile_multi_banked::Parameters                          ** __param_spr       ;
     56  private: morpheo::behavioural::generic::registerfile::registerfile_monolithic  ::Parameters                          ** __param_spr_status;
    5757  public : morpheo::behavioural::core::multi_execute_loop::execute_loop::register_unit::register_unit_glue::Parameters  * _param_glue       ;
    5858
    … …  
    7474                        uint32_t  * nb_special_register      ,
    7575                        uint32_t  * nb_inst_insert_rob       ,
    76                         uint32_t  * nb_inst_retire_rob       );
     76                        uint32_t  * nb_inst_retire_rob       ,
     77                        bool        is_toplevel=false);
    7778
    78   public : Parameters  (Parameters & param) ;
     79//public : Parameters  (Parameters & param) ;
    7980  public : ~Parameters () ;
    8081
     82  public :        void            copy       (void);
     83
    8184  public :        Parameters_test msg_error  (void);
     85
    8286  public :        std::string   print      (uint32_t depth);
    8387  public : friend std::ostream& operator<< (std::ostream& output_stream,

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

    r82 r88  
    102102  public    : SC_IN (Tspecial_address_t)  ***  in_INSERT_ROB_RE_NUM_REG        ;
    103103
    104     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    105   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_VAL               ;
    106   public    : SC_OUT(Tcontrol_t        )  *** out_RETIRE_ROB_ACK               ;
    107   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RD_OLD_USE        ;
    108   public    : SC_IN (Tgeneral_address_t)  ***  in_RETIRE_ROB_RD_OLD_NUM_REG    ; // old_use=1 : status[old_num_reg]<- 0
    109   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RD_NEW_USE        ;
    110   public    : SC_IN (Tgeneral_address_t)  ***  in_RETIRE_ROB_RD_NEW_NUM_REG    ; // new_use=1 : status[new_num_reg]<- 1
    111   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RE_OLD_USE        ;
    112   public    : SC_IN (Tspecial_address_t)  ***  in_RETIRE_ROB_RE_OLD_NUM_REG    ;
    113   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RE_NEW_USE        ;
    114   public    : SC_IN (Tspecial_address_t)  ***  in_RETIRE_ROB_RE_NEW_NUM_REG    ;
     104//     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     105//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_VAL               ;
     106//   public    : SC_OUT(Tcontrol_t        )  *** out_RETIRE_ROB_ACK               ;
     107//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RD_OLD_USE        ;
     108//   public    : SC_IN (Tgeneral_address_t)  ***  in_RETIRE_ROB_RD_OLD_NUM_REG    ; // old_use=1 : status[old_num_reg]<- 0
     109//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RD_NEW_USE        ;
     110//   public    : SC_IN (Tgeneral_address_t)  ***  in_RETIRE_ROB_RD_NEW_NUM_REG    ; // new_use=1 : status[new_num_reg]<- 1
     111//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RE_OLD_USE        ;
     112//   public    : SC_IN (Tspecial_address_t)  ***  in_RETIRE_ROB_RE_OLD_NUM_REG    ;
     113//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RE_NEW_USE        ;
     114//   public    : SC_IN (Tspecial_address_t)  ***  in_RETIRE_ROB_RE_NEW_NUM_REG    ;
    115115
    116116    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   

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

    r81 r88  
    3434                          uint32_t  * nb_special_register      ,
    3535                          uint32_t  * nb_inst_insert_rob       ,
    36                           uint32_t  * nb_inst_retire_rob       ):
    37     _nb_ooo_engine             (nb_ooo_engine            ),
    38     _size_general_data         (size_general_data        ),
    39     _size_special_data         (size_special_data        ),
    40     _nb_gpr_read               (nb_gpr_read              ),
    41     _nb_gpr_write              (nb_gpr_write             ),
    42     _nb_gpr_bank               (nb_gpr_bank              ),
    43     _nb_gpr_port_read_by_bank  (nb_gpr_port_read_by_bank ),
    44     _nb_gpr_port_write_by_bank (nb_gpr_port_write_by_bank),
    45     _nb_spr_read               (nb_spr_read              ),
    46     _nb_spr_write              (nb_spr_write             ),
    47     _nb_spr_bank               (nb_spr_bank              ),
    48     _nb_spr_port_read_by_bank  (nb_spr_port_read_by_bank ),
    49     _nb_spr_port_write_by_bank (nb_spr_port_write_by_bank),
    50     _nb_general_register       (nb_general_register      ),
    51     _nb_special_register       (nb_special_register      ),
    52     _nb_inst_insert_rob        (nb_inst_insert_rob       ),
    53     _nb_inst_retire_rob        (nb_inst_retire_rob       ),
    54     _have_port_ooo_engine_id   (nb_ooo_engine>1          )
    55    
     36                          uint32_t  * nb_inst_retire_rob       ,
     37                          bool        is_toplevel              )
    5638  {
    5739    log_printf(FUNC,Register_unit,FUNCTION,"Begin");
     40
     41
     42    _nb_ooo_engine             = nb_ooo_engine            ;
     43    _nb_gpr_read               = nb_gpr_read              ;
     44    _nb_gpr_write              = nb_gpr_write             ;
     45    _nb_gpr_bank               = nb_gpr_bank              ;
     46    _nb_gpr_port_read_by_bank  = nb_gpr_port_read_by_bank ;
     47    _nb_gpr_port_write_by_bank = nb_gpr_port_write_by_bank;
     48    _nb_spr_read               = nb_spr_read              ;
     49    _nb_spr_write              = nb_spr_write             ;
     50    _nb_spr_bank               = nb_spr_bank              ;
     51    _nb_spr_port_read_by_bank  = nb_spr_port_read_by_bank ;
     52    _nb_spr_port_write_by_bank = nb_spr_port_write_by_bank;
     53    _nb_general_register       = nb_general_register      ;
     54    _nb_special_register       = nb_special_register      ;
     55    _nb_inst_insert_rob        = nb_inst_insert_rob       ;
     56    _nb_inst_retire_rob        = nb_inst_retire_rob       ;
    5857
    5958    _size_gpr_address = log2(nb_general_register [0]);
    … …  
    7473          _size_spr_address = new_size;
    7574      }
    76 
    7775
    7876    _param_gpr         = new morpheo::behavioural::generic::registerfile::Parameters * [_nb_ooo_engine];
    … …  
    8684    __param_spr_status = new morpheo::behavioural::generic::registerfile::registerfile_monolithic  ::Parameters * [_nb_ooo_engine];
    8785   
    88    for (uint32_t i=0; i<_nb_ooo_engine; i++)
    89      {
    90        Tcrossbar_t crossbar = PARTIAL_CROSSBAR;
    91  
    92        __param_gpr        [i] = new morpheo::behavioural::generic::registerfile::registerfile_multi_banked::Parameters
    93          (_nb_gpr_read              ,
    94           _nb_gpr_write             ,
    95           _nb_general_register[i]   ,
    96           _size_general_data        ,
    97           _nb_gpr_bank              ,
    98           _nb_gpr_port_read_by_bank ,
    99           _nb_gpr_port_write_by_bank,
    100           crossbar                  );
    101 
    102        __param_gpr_status [i] = new morpheo::behavioural::generic::registerfile::registerfile_monolithic  ::Parameters
    103          (_nb_gpr_read ,
    104           _nb_gpr_write+_nb_inst_insert_rob[i]+2*_nb_inst_retire_rob[i],
    105           0,
    106           nb_general_register[i],
    107           1);
    108 
    109        __param_spr        [i] = new morpheo::behavioural::generic::registerfile::registerfile_multi_banked::Parameters
    110          (_nb_spr_read              ,
    111           _nb_spr_write             ,
    112           _nb_special_register[i]   ,
    113           _size_special_data        ,
    114           _nb_spr_bank              ,
    115           _nb_spr_port_read_by_bank ,
    116           _nb_spr_port_write_by_bank,
    117           crossbar                  );
    118 
    119        __param_spr_status [i] = new morpheo::behavioural::generic::registerfile::registerfile_monolithic  ::Parameters
    120          (_nb_spr_read ,
    121           _nb_spr_write+_nb_inst_insert_rob[i]+2*_nb_inst_retire_rob[i],
    122           0,
    123           nb_special_register[i],
    124           1);   
    125 
    126        _param_gpr        [i] = new morpheo::behavioural::generic::registerfile::Parameters (__param_gpr        [i]);
    127        _param_gpr_status [i] = new morpheo::behavioural::generic::registerfile::Parameters (__param_gpr_status [i]);
    128        _param_spr        [i] = new morpheo::behavioural::generic::registerfile::Parameters (__param_spr        [i]);
    129        _param_spr_status [i] = new morpheo::behavioural::generic::registerfile::Parameters (__param_spr_status [i]);
    130      }
    131 
    132    _param_glue       = new morpheo::behavioural::core::multi_execute_loop::execute_loop::register_unit::register_unit_glue::Parameters  (_nb_ooo_engine        ,
    133                                                                                                                                          _size_general_data    ,
    134                                                                                                                                          _size_special_data    ,
    135                                                                                                                                          _nb_gpr_read          ,
    136                                                                                                                                          _nb_spr_read          ,   
    137                                                                                                                                          _nb_gpr_write         ,
    138                                                                                                                                          _nb_spr_write         ,
    139                                                                                                                                          _nb_inst_insert_rob   ,
    140                                                                                                                                          _nb_inst_retire_rob   );
    141      
     86    for (uint32_t i=0; i<_nb_ooo_engine; i++)
     87      {
     88        Tcrossbar_t crossbar = PARTIAL_CROSSBAR;
     89       
     90        __param_gpr        [i] = new morpheo::behavioural::generic::registerfile::registerfile_multi_banked::Parameters
     91          (_nb_gpr_read              ,
     92           _nb_gpr_write             ,
     93           _nb_general_register[i]   ,
     94            size_general_data        ,
     95           _nb_gpr_bank              ,
     96           _nb_gpr_port_read_by_bank ,
     97           _nb_gpr_port_write_by_bank,
     98           crossbar                  );
     99       
     100        __param_gpr_status [i] = new morpheo::behavioural::generic::registerfile::registerfile_monolithic  ::Parameters
     101          (_nb_gpr_read ,
     102//         _nb_gpr_write+_nb_inst_insert_rob[i]+2*_nb_inst_retire_rob[i],
     103           _nb_gpr_write+_nb_inst_insert_rob[i],
     104           0,
     105           nb_general_register[i],
     106           1);
     107       
     108        __param_spr        [i] = new morpheo::behavioural::generic::registerfile::registerfile_multi_banked::Parameters
     109          (_nb_spr_read              ,
     110           _nb_spr_write             ,
     111           _nb_special_register[i]   ,
     112            size_special_data        ,
     113           _nb_spr_bank              ,
     114           _nb_spr_port_read_by_bank ,
     115           _nb_spr_port_write_by_bank,
     116           crossbar                  );
     117       
     118        __param_spr_status [i] = new morpheo::behavioural::generic::registerfile::registerfile_monolithic  ::Parameters
     119          (_nb_spr_read ,
     120//         _nb_spr_write+_nb_inst_insert_rob[i]+2*_nb_inst_retire_rob[i],
     121           _nb_spr_write+_nb_inst_insert_rob[i],
     122           0,
     123           nb_special_register[i],
     124           1);   
     125       
     126        _param_gpr        [i] = new morpheo::behavioural::generic::registerfile::Parameters (__param_gpr        [i]);
     127        _param_gpr_status [i] = new morpheo::behavioural::generic::registerfile::Parameters (__param_gpr_status [i]);
     128        _param_spr        [i] = new morpheo::behavioural::generic::registerfile::Parameters (__param_spr        [i]);
     129        _param_spr_status [i] = new morpheo::behavioural::generic::registerfile::Parameters (__param_spr_status [i]);
     130      }
    142131   
    143 
    144 
     132    _param_glue       = new morpheo::behavioural::core::multi_execute_loop::execute_loop::register_unit::register_unit_glue::Parameters  (_nb_ooo_engine        ,
     133                                                                                                                                           size_general_data    ,
     134                                                                                                                                           size_special_data    ,
     135                                                                                                                                          _nb_gpr_read          ,
     136                                                                                                                                          _nb_spr_read          ,   
     137                                                                                                                                          _nb_gpr_write         ,
     138                                                                                                                                          _nb_spr_write         ,
     139                                                                                                                                          _nb_inst_insert_rob   ,
     140                                                                                                                                          _nb_inst_retire_rob   );
     141   
    145142    test();
    146     log_printf(FUNC,Register_unit,FUNCTION,"End");
     143   
     144    if (is_toplevel)
     145      {
     146        _size_ooo_engine_id        = log2(nb_ooo_engine);
     147        _size_general_data         = size_general_data;
     148        _size_special_data         = size_special_data;
     149       
     150        _have_port_ooo_engine_id   = _size_ooo_engine_id > 0;
     151
     152        copy();
     153      }
     154   
     155   log_printf(FUNC,Register_unit,FUNCTION,"End");
    147156  };
    148157 
     158// #undef  FUNCTION
     159// #define FUNCTION "Register_unit::Parameters (copy)"
     160//   Parameters::Parameters (Parameters & param):
     161//     _nb_ooo_engine             (param._nb_ooo_engine            ),
     162//     _size_general_data         (param._size_general_data        ),
     163//     _size_special_data         (param._size_special_data        ),
     164//     _nb_gpr_read               (param._nb_gpr_read              ),
     165//     _nb_gpr_write              (param._nb_gpr_write             ),
     166//     _nb_gpr_bank               (param._nb_gpr_bank              ),
     167//     _nb_gpr_port_read_by_bank  (param._nb_gpr_port_read_by_bank ),
     168//     _nb_gpr_port_write_by_bank (param._nb_gpr_port_write_by_bank),
     169//     _nb_spr_read               (param._nb_spr_read              ),
     170//     _nb_spr_write              (param._nb_spr_write             ),
     171//     _nb_spr_bank               (param._nb_spr_bank              ),
     172//     _nb_spr_port_read_by_bank  (param._nb_spr_port_read_by_bank ),
     173//     _nb_spr_port_write_by_bank (param._nb_spr_port_write_by_bank),
     174//     _nb_general_register       (param._nb_general_register      ),
     175//     _nb_special_register       (param._nb_special_register      ),
     176//     _nb_inst_insert_rob        (param._nb_inst_insert_rob       ),
     177//     _nb_inst_retire_rob        (param._nb_inst_retire_rob       ),
     178//     _have_port_ooo_engine_id   (param._have_port_ooo_engine_id  )
     179//   {
     180//     log_printf(FUNC,Register_unit,FUNCTION,"Begin");
     181
     182//     _size_gpr_address = param._size_gpr_address;
     183//     _size_spr_address = param._size_spr_address;
     184
     185//     __param_gpr        = param.__param_gpr       ;
     186//     __param_gpr_status = param.__param_gpr_status;
     187//     __param_spr        = param.__param_spr       ;
     188//     __param_spr_status = param.__param_spr_status;
     189//     _param_gpr         = param._param_gpr       ;
     190//     _param_gpr_status  = param._param_gpr_status;
     191//     _param_spr         = param._param_spr       ;
     192//     _param_spr_status  = param._param_spr_status;
     193//     _param_glue        = param._param_glue      ;
     194
     195//     test();
     196//     log_printf(FUNC,Register_unit,FUNCTION,"End");
     197//   };
     198
    149199#undef  FUNCTION
    150 #define FUNCTION "Register_unit::Parameters (copy)"
    151   Parameters::Parameters (Parameters & param):
    152     _nb_ooo_engine             (param._nb_ooo_engine            ),
    153     _size_general_data         (param._size_general_data        ),
    154     _size_special_data         (param._size_special_data        ),
    155     _nb_gpr_read               (param._nb_gpr_read              ),
    156     _nb_gpr_write              (param._nb_gpr_write             ),
    157     _nb_gpr_bank               (param._nb_gpr_bank              ),
    158     _nb_gpr_port_read_by_bank  (param._nb_gpr_port_read_by_bank ),
    159     _nb_gpr_port_write_by_bank (param._nb_gpr_port_write_by_bank),
    160     _nb_spr_read               (param._nb_spr_read              ),
    161     _nb_spr_write              (param._nb_spr_write             ),
    162     _nb_spr_bank               (param._nb_spr_bank              ),
    163     _nb_spr_port_read_by_bank  (param._nb_spr_port_read_by_bank ),
    164     _nb_spr_port_write_by_bank (param._nb_spr_port_write_by_bank),
    165     _nb_general_register       (param._nb_general_register      ),
    166     _nb_special_register       (param._nb_special_register      ),
    167     _nb_inst_insert_rob        (param._nb_inst_insert_rob       ),
    168     _nb_inst_retire_rob        (param._nb_inst_retire_rob       ),
    169     _have_port_ooo_engine_id   (param._have_port_ooo_engine_id  )
     200#define FUNCTION "Register_unit::~Parameters"
     201  Parameters::~Parameters (void)
    170202  {
    171203    log_printf(FUNC,Register_unit,FUNCTION,"Begin");
    172204
    173     _size_gpr_address = param._size_gpr_address;
    174     _size_spr_address = param._size_spr_address;
    175 
    176     __param_gpr        = param.__param_gpr       ;
    177     __param_gpr_status = param.__param_gpr_status;
    178     __param_spr        = param.__param_spr       ;
    179     __param_spr_status = param.__param_spr_status;
    180     _param_gpr         = param._param_gpr       ;
    181     _param_gpr_status  = param._param_gpr_status;
    182     _param_spr         = param._param_spr       ;
    183     _param_spr_status  = param._param_spr_status;
    184     _param_glue        = param._param_glue      ;
    185 
    186     test();
    187     log_printf(FUNC,Register_unit,FUNCTION,"End");
    188   };
    189 
    190 #undef  FUNCTION
    191 #define FUNCTION "Register_unit::~Parameters"
    192   Parameters::~Parameters ()
    193   {
    194     log_printf(FUNC,Register_unit,FUNCTION,"Begin");
    195 
    196     delete [] _param_gpr       ;
    197     delete [] _param_gpr_status;
    198     delete [] _param_spr       ;
    199     delete [] _param_spr_status;
     205    for (uint32_t i=0; i<_nb_ooo_engine; i++)
     206      {
     207        delete _param_gpr         [i];
     208        delete _param_gpr_status  [i];
     209        delete _param_spr         [i];
     210        delete _param_spr_status  [i];
     211        delete __param_gpr        [i];
     212        delete __param_gpr_status [i];
     213        delete __param_spr        [i];
     214        delete __param_spr_status [i];
     215      }
     216    delete [] _param_gpr        ;
     217    delete [] _param_gpr_status ;
     218    delete [] _param_spr        ;
     219    delete [] _param_spr_status ;
    200220    delete [] __param_gpr       ;
    201221    delete [] __param_gpr_status;
    … …  
    207227  };
    208228
     229#undef  FUNCTION
     230#define FUNCTION "Register_unit::copy"
     231  void Parameters::copy (void)
     232  {
     233    log_printf(FUNC,Register_unit,FUNCTION,"Begin");
     234
     235    for (uint32_t i=0; i<_nb_ooo_engine; i++)
     236      {
     237        COPY(__param_gpr        [i]);
     238        COPY(__param_gpr_status [i]);
     239        COPY(__param_spr        [i]);
     240        COPY(__param_spr_status [i]);
     241      }
     242    COPY(_param_glue);
     243   
     244    log_printf(FUNC,Register_unit,FUNCTION,"End");
     245  };
     246
    209247}; // end namespace register_unit
    210248}; // end namespace execute_loop

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

    r81 r88  
    3737    log_printf(FUNC,Register_unit,FUNCTION,"Begin");
    3838
     39#if DEBUG_Register_unit == true
     40    log_printf(INFO,Register_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
     41
     42    std::cout << *param << std::endl;
     43#endif   
     44
    3945    log_printf(INFO,Register_unit,FUNCTION,"Allocation");
    4046    allocation (
    … …  
    4551
    4652#ifdef STATISTICS
    47     log_printf(INFO,Register_unit,FUNCTION,"Allocation of statistics");
     53    if (usage_is_set(_usage,USE_STATISTICS))
     54      {
     55        log_printf(INFO,Register_unit,FUNCTION,_("<%s> : Allocation of statistics"),_name.c_str());
    4856
    49     // Allocation of statistics
    50     statistics_declaration(param_statistics);
     57        statistics_declaration(param_statistics);
     58      }
    5159#endif
    5260
    5361#ifdef VHDL
    54     // generate the vhdl
    55     log_printf(INFO,Register_unit,FUNCTION,"Generate the vhdl");
    56 
    57     vhdl();
     62    if (usage_is_set(_usage,USE_VHDL))
     63      {
     64        // generate the vhdl
     65        log_printf(INFO,Register_unit,FUNCTION,"Generate the vhdl");
     66       
     67        vhdl();
     68      }
    5869#endif
    5970
    6071#ifdef SYSTEMC
     72    if (usage_is_set(_usage,USE_SYSTEMC))
     73      {
    6174//#if defined(STATISTICS) or defined(VHDL_TESTBENCH)
    6275    log_printf(INFO,Register_unit,FUNCTION,"Method - transition");
    … …  
    7083    // List dependency information
    7184#endif   
    72 
     85      }
    7386#endif
    7487    log_printf(FUNC,Register_unit,FUNCTION,"End");
    … …  
    8295
    8396#ifdef STATISTICS
    84     log_printf(INFO,Register_unit,FUNCTION,"Generate Statistics file");
    85     delete _stat;
     97    if (usage_is_set(_usage,USE_STATISTICS))
     98      {
     99        log_printf(INFO,Register_unit,FUNCTION,"Generate Statistics file");
     100        delete _stat;
     101      }
    86102#endif
    87103

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/src/Register_unit_allocation.cpp

    r82 r88  
    22 * $Id$
    33 *
    4  * [ Description ]
     4 * [ Description ]
    55 *
    66 */
    … …  
    88#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/include/Register_unit.h"
    99
    10 namespace morpheo                    {
     10namespace morpheo {
    1111namespace behavioural {
    1212namespace core {
    … …  
    1414namespace execute_loop {
    1515namespace register_unit {
    16 
    17 
    1816
    1917#undef  FUNCTION
    … …  
    4038    _interfaces = entity->set_interfaces();
    4139
    42     // ~~~~~[ Interface : "" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     40    // ~~~~~[ Interface : "" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    4341
    4442    Interface * interface = _interfaces->set_interface(""
    … …  
    5351    in_NRESET       = interface->set_signal_in  <Tcontrol_t> ("nreset",1, RESET_VHDL_YES);
    5452
    55     // ~~~~~[ Interface "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     53    // ~~~~~[ Interface "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    5654    in_GPR_READ_VAL                 = new SC_IN (Tcontrol_t        )   * [_param->_nb_gpr_read];
    5755    out_GPR_READ_ACK                 = new SC_OUT(Tcontrol_t        )   * [_param->_nb_gpr_read];
    … …  
    7573        out_GPR_READ_ACK           [i]= interface->set_signal_valack_out (ACK);
    7674        if (_param->_have_port_ooo_engine_id == true)
    77           in_GPR_READ_OOO_ENGINE_ID [i]= interface->set_signal_in <Tcontext_t        > ("ooo_engine_id" , log2(_param->_nb_ooo_engine));
     75          in_GPR_READ_OOO_ENGINE_ID [i]= interface->set_signal_in <Tcontext_t        > ("ooo_engine_id" , _param->_size_ooo_engine_id);
    7876        in_GPR_READ_NUM_REG       [i]= interface->set_signal_in <Tgeneral_address_t> ("num_reg"       , _param->_size_gpr_address);
    7977        out_GPR_READ_DATA          [i]= interface->set_signal_out<Tgeneral_data_t   > ("data"          , _param->_size_general_data);
    … …  
    8179      }
    8280
    83     // ~~~~~[ Interface "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     81    // ~~~~~[ Interface "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    8482    in_GPR_WRITE_VAL                 = new SC_IN (Tcontrol_t        )   * [_param->_nb_gpr_write];
    8583    out_GPR_WRITE_ACK                 = new SC_OUT(Tcontrol_t        )   * [_param->_nb_gpr_write];
    … …  
    102100        out_GPR_WRITE_ACK           [i]= interface->set_signal_valack_out (ACK);
    103101        if (_param->_have_port_ooo_engine_id == true)
    104           in_GPR_WRITE_OOO_ENGINE_ID [i]= interface->set_signal_in <Tcontext_t        > ("ooo_engine_id" , log2(_param->_nb_ooo_engine));
     102          in_GPR_WRITE_OOO_ENGINE_ID [i]= interface->set_signal_in <Tcontext_t        > ("ooo_engine_id" , _param->_size_ooo_engine_id);
    105103        in_GPR_WRITE_NUM_REG       [i]= interface->set_signal_in <Tgeneral_address_t> ("num_reg"       , _param->_size_gpr_address);
    106104        in_GPR_WRITE_DATA          [i]= interface->set_signal_in <Tgeneral_data_t   > ("data"          , _param->_size_general_data);
    107105      }
    108106
    109     // ~~~~~[ Interface "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     107    // ~~~~~[ Interface "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    110108    in_SPR_READ_VAL                 = new SC_IN (Tcontrol_t        )   * [_param->_nb_spr_read];
    111109    out_SPR_READ_ACK                 = new SC_OUT(Tcontrol_t        )   * [_param->_nb_spr_read];
    … …  
    129127        out_SPR_READ_ACK           [i]= interface->set_signal_valack_out (ACK);
    130128        if (_param->_have_port_ooo_engine_id == true)
    131           in_SPR_READ_OOO_ENGINE_ID [i]= interface->set_signal_in <Tcontext_t        > ("ooo_engine_id" , log2(_param->_nb_ooo_engine));
     129          in_SPR_READ_OOO_ENGINE_ID [i]= interface->set_signal_in <Tcontext_t        > ("ooo_engine_id" , _param->_size_ooo_engine_id);
    132130        in_SPR_READ_NUM_REG       [i]= interface->set_signal_in <Tspecial_address_t> ("num_reg"       , _param->_size_spr_address);
    133131        out_SPR_READ_DATA          [i]= interface->set_signal_out<Tspecial_data_t   > ("data"          , _param->_size_special_data);
    … …  
    135133      }
    136134
    137     // ~~~~~[ Interface "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     135    // ~~~~~[ Interface "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    138136    in_SPR_WRITE_VAL                 = new SC_IN (Tcontrol_t        )   * [_param->_nb_spr_write];
    139137    out_SPR_WRITE_ACK                 = new SC_OUT(Tcontrol_t        )   * [_param->_nb_spr_write];
    … …  
    156154        out_SPR_WRITE_ACK           [i]= interface->set_signal_valack_out (ACK);
    157155        if (_param->_have_port_ooo_engine_id == true)
    158           in_SPR_WRITE_OOO_ENGINE_ID [i]= interface->set_signal_in <Tcontext_t        > ("ooo_engine_id" , log2(_param->_nb_ooo_engine));
     156          in_SPR_WRITE_OOO_ENGINE_ID [i]= interface->set_signal_in <Tcontext_t        > ("ooo_engine_id" , _param->_size_ooo_engine_id);
    159157        in_SPR_WRITE_NUM_REG       [i]= interface->set_signal_in <Tspecial_address_t> ("num_reg"       , _param->_size_spr_address);
    160158        in_SPR_WRITE_DATA          [i]= interface->set_signal_in <Tspecial_data_t   > ("data"          , _param->_size_special_data);
    161159      }
    162160
    163     // ~~~~~[ Interface "insert_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     161    // ~~~~~[ Interface "insert_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    164162    in_INSERT_ROB_VAL        = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    165163    out_INSERT_ROB_ACK        = new SC_OUT(Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    … …  
    201199      }
    202200
    203     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    204     in_RETIRE_ROB_VAL            = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    205     out_RETIRE_ROB_ACK            = new SC_OUT(Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    206     in_RETIRE_ROB_RD_OLD_USE     = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    207     in_RETIRE_ROB_RD_OLD_NUM_REG = new SC_IN (Tgeneral_address_t)  ** [_param->_nb_ooo_engine];
    208     in_RETIRE_ROB_RE_OLD_USE     = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    209     in_RETIRE_ROB_RE_OLD_NUM_REG = new SC_IN (Tspecial_address_t)  ** [_param->_nb_ooo_engine];
    210     in_RETIRE_ROB_RD_NEW_USE     = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    211     in_RETIRE_ROB_RD_NEW_NUM_REG = new SC_IN (Tgeneral_address_t)  ** [_param->_nb_ooo_engine];
    212     in_RETIRE_ROB_RE_NEW_USE     = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
    213     in_RETIRE_ROB_RE_NEW_NUM_REG = new SC_IN (Tspecial_address_t)  ** [_param->_nb_ooo_engine];
    214 
    215     for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    216       {
    217         uint32_t x=_param->_nb_inst_retire_rob [i];
    218 
    219         in_RETIRE_ROB_VAL            [i] = new SC_IN (Tcontrol_t        )  * [x];
    220         out_RETIRE_ROB_ACK            [i] = new SC_OUT(Tcontrol_t        )  * [x];
    221         in_RETIRE_ROB_RD_OLD_USE     [i] = new SC_IN (Tcontrol_t        )  * [x];
    222         in_RETIRE_ROB_RD_OLD_NUM_REG [i] = new SC_IN (Tgeneral_address_t)  * [x];
    223         in_RETIRE_ROB_RE_OLD_USE     [i] = new SC_IN (Tcontrol_t        )  * [x];
    224         in_RETIRE_ROB_RE_OLD_NUM_REG [i] = new SC_IN (Tspecial_address_t)  * [x];
    225         in_RETIRE_ROB_RD_NEW_USE     [i] = new SC_IN (Tcontrol_t        )  * [x];
    226         in_RETIRE_ROB_RD_NEW_NUM_REG [i] = new SC_IN (Tgeneral_address_t)  * [x];
    227         in_RETIRE_ROB_RE_NEW_USE     [i] = new SC_IN (Tcontrol_t        )  * [x];
    228         in_RETIRE_ROB_RE_NEW_NUM_REG [i] = new SC_IN (Tspecial_address_t)  * [x];
    229 
    230         for (uint32_t j=0; j<x; j++)
    231           {
    232             Interface_fifo * interface = _interfaces->set_interface("retire_rob_"+toString(i)+"_"+toString(j)
    233 #ifdef POSITION
    234                                                                     ,IN
    235                                                                     ,WEST
    236                                                                     ,"Interface to update status (retire)"
    237 #endif
    238                                                                     );
    239 
    240 
    241             in_RETIRE_ROB_VAL            [i][j] = interface->set_signal_valack_in  (VAL);
    242            out_RETIRE_ROB_ACK            [i][j] = interface->set_signal_valack_out (ACK);
    243             in_RETIRE_ROB_RD_OLD_USE     [i][j] = interface->set_signal_in <Tcontrol_t        > ("rd_old_use"    , 1);
    244             in_RETIRE_ROB_RD_OLD_NUM_REG [i][j] = interface->set_signal_in <Tgeneral_address_t> ("rd_old_num_reg", _param->_size_gpr_address);
    245             in_RETIRE_ROB_RE_OLD_USE     [i][j] = interface->set_signal_in <Tcontrol_t        > ("re_old_use"    , 1);
    246             in_RETIRE_ROB_RE_OLD_NUM_REG [i][j] = interface->set_signal_in <Tspecial_address_t> ("re_old_num_reg", _param->_size_spr_address);
    247             in_RETIRE_ROB_RD_NEW_USE     [i][j] = interface->set_signal_in <Tcontrol_t        > ("rd_new_use"    , 1);
    248             in_RETIRE_ROB_RD_NEW_NUM_REG [i][j] = interface->set_signal_in <Tgeneral_address_t> ("rd_new_num_reg", _param->_size_gpr_address);
    249             in_RETIRE_ROB_RE_NEW_USE     [i][j] = interface->set_signal_in <Tcontrol_t        > ("re_new_use"    , 1);
    250             in_RETIRE_ROB_RE_NEW_NUM_REG [i][j] = interface->set_signal_in <Tspecial_address_t> ("re_new_num_reg", _param->_size_spr_address);
    251           }
    252       }
    253     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
     201//     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     202//     in_RETIRE_ROB_VAL            = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
     203//     out_RETIRE_ROB_ACK            = new SC_OUT(Tcontrol_t        )  ** [_param->_nb_ooo_engine];
     204//     in_RETIRE_ROB_RD_OLD_USE     = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
     205//     in_RETIRE_ROB_RD_OLD_NUM_REG = new SC_IN (Tgeneral_address_t)  ** [_param->_nb_ooo_engine];
     206//     in_RETIRE_ROB_RE_OLD_USE     = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
     207//     in_RETIRE_ROB_RE_OLD_NUM_REG = new SC_IN (Tspecial_address_t)  ** [_param->_nb_ooo_engine];
     208//     in_RETIRE_ROB_RD_NEW_USE     = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
     209//     in_RETIRE_ROB_RD_NEW_NUM_REG = new SC_IN (Tgeneral_address_t)  ** [_param->_nb_ooo_engine];
     210//     in_RETIRE_ROB_RE_NEW_USE     = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
     211//     in_RETIRE_ROB_RE_NEW_NUM_REG = new SC_IN (Tspecial_address_t)  ** [_param->_nb_ooo_engine];
     212
     213//     for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     214//       {
     215//      uint32_t x=_param->_nb_inst_retire_rob [i];
     216
     217//      in_RETIRE_ROB_VAL            [i] = new SC_IN (Tcontrol_t        )  * [x];
     218//      out_RETIRE_ROB_ACK            [i] = new SC_OUT(Tcontrol_t        )  * [x];
     219//      in_RETIRE_ROB_RD_OLD_USE     [i] = new SC_IN (Tcontrol_t        )  * [x];
     220//      in_RETIRE_ROB_RD_OLD_NUM_REG [i] = new SC_IN (Tgeneral_address_t)  * [x];
     221//      in_RETIRE_ROB_RE_OLD_USE     [i] = new SC_IN (Tcontrol_t        )  * [x];
     222//      in_RETIRE_ROB_RE_OLD_NUM_REG [i] = new SC_IN (Tspecial_address_t)  * [x];
     223//      in_RETIRE_ROB_RD_NEW_USE     [i] = new SC_IN (Tcontrol_t        )  * [x];
     224//      in_RETIRE_ROB_RD_NEW_NUM_REG [i] = new SC_IN (Tgeneral_address_t)  * [x];
     225//      in_RETIRE_ROB_RE_NEW_USE     [i] = new SC_IN (Tcontrol_t        )  * [x];
     226//      in_RETIRE_ROB_RE_NEW_NUM_REG [i] = new SC_IN (Tspecial_address_t)  * [x];
     227
     228//      for (uint32_t j=0; j<x; j++)
     229//        {
     230//          Interface_fifo * interface = _interfaces->set_interface("retire_rob_"+toString(i)+"_"+toString(j)
     231// #ifdef POSITION
     232//                                                                  ,IN
     233//                                                                  ,WEST
     234//                                                                  ,"Interface to update status (retire)"
     235// #endif
     236//                                                                  );
     237
     238
     239//          in_RETIRE_ROB_VAL            [i][j] = interface->set_signal_valack_in  (VAL);
     240//         out_RETIRE_ROB_ACK            [i][j] = interface->set_signal_valack_out (ACK);
     241//          in_RETIRE_ROB_RD_OLD_USE     [i][j] = interface->set_signal_in <Tcontrol_t        > ("rd_old_use"    , 1);
     242//          in_RETIRE_ROB_RD_OLD_NUM_REG [i][j] = interface->set_signal_in <Tgeneral_address_t> ("rd_old_num_reg", _param->_size_gpr_address);
     243//          in_RETIRE_ROB_RE_OLD_USE     [i][j] = interface->set_signal_in <Tcontrol_t        > ("re_old_use"    , 1);
     244//          in_RETIRE_ROB_RE_OLD_NUM_REG [i][j] = interface->set_signal_in <Tspecial_address_t> ("re_old_num_reg", _param->_size_spr_address);
     245//          in_RETIRE_ROB_RD_NEW_USE     [i][j] = interface->set_signal_in <Tcontrol_t        > ("rd_new_use"    , 1);
     246//          in_RETIRE_ROB_RD_NEW_NUM_REG [i][j] = interface->set_signal_in <Tgeneral_address_t> ("rd_new_num_reg", _param->_size_gpr_address);
     247//          in_RETIRE_ROB_RE_NEW_USE     [i][j] = interface->set_signal_in <Tcontrol_t        > ("re_new_use"    , 1);
     248//          in_RETIRE_ROB_RE_NEW_NUM_REG [i][j] = interface->set_signal_in <Tspecial_address_t> ("re_new_num_reg", _param->_size_spr_address);
     249//        }
     250//       }
     251
     252    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    254253
    255254    std::string name;
    … …  
    263262      {
    264263        name = _name+"_gpr_"+toString(i);
     264        log_printf(INFO,Register_unit,FUNCTION,_("Create   : %s"),name.c_str());
    265265
    266266        component_gpr        [i] = new morpheo::behavioural::generic::registerfile::RegisterFile::RegisterFile
    … …  
    284284
    285285        name = _name+"_gpr_status_"+toString(i);
     286        log_printf(INFO,Register_unit,FUNCTION,_("Create   : %s"),name.c_str());
    286287
    287288        component_gpr_status [i] = new morpheo::behavioural::generic::registerfile::RegisterFile::RegisterFile
    … …  
    305306
    306307        name = _name+"_spr_"+toString(i);
     308        log_printf(INFO,Register_unit,FUNCTION,_("Create   : %s"),name.c_str());
    307309         
    308310        component_spr        [i] = new morpheo::behavioural::generic::registerfile::RegisterFile::RegisterFile
    … …  
    325327
    326328        name = _name+"_spr_status_"+toString(i);
     329        log_printf(INFO,Register_unit,FUNCTION,_("Create   : %s"),name.c_str());
    327330
    328331        component_spr_status [i] = new morpheo::behavioural::generic::registerfile::RegisterFile::RegisterFile
    … …  
    347350
    348351    name = _name+"_glue";
     352    log_printf(INFO,Register_unit,FUNCTION,_("Create   : %s"),name.c_str());
    349353     
    350354    component_glue       = new morpheo::behavioural::core::multi_execute_loop::execute_loop::register_unit::register_unit_glue::Register_unit_Glue::Register_unit_Glue     
    … …  
    373377        name_component = _name+"_gpr_"+toString(i);
    374378       
    375         std::cout << "Instance : " << name_component << std::endl;
     379        log_printf(INFO,Register_unit,FUNCTION,_("Instance : %s"),name_component.c_str());
    376380       
    377381#ifdef POSITION
    … …  
    430434          name_component = _name+"_gpr_status_"+toString(i);
    431435         
    432           std::cout << "Instance : " << name_component << std::endl;
     436          log_printf(INFO,Register_unit,FUNCTION,_("Instance : %s"),name_component.c_str());
    433437         
    434438#ifdef POSITION
    … …  
    516520            }
    517521
    518           for (uint32_t j=0; j<_param->_nb_inst_retire_rob [i]; j++)
    519             {
    520               _component->port_map(name_component,
    521                                    "in_WRITE_"+toString(x)+"_VAL" ,
    522                                    _name+"_glue",
    523                                    "out_RETIRE_ROB_GPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_VAL");
    524               _component->port_map(name_component,
    525                                    "out_WRITE_"+toString(x)+"_ACK",
    526                                    _name+"_glue",
    527                                    "in_RETIRE_ROB_GPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_ACK" );
    528 
    529               _component->port_map(name_component,
    530                                    "in_WRITE_"+toString(x)+"_DATA" ,
    531                                    _name+"_glue",
    532                                    "out_CONST_0");
    533               _component->port_map(_name+"_glue",
    534                                    "out_CONST_0",
    535                                    name_component,
    536                                    "in_WRITE_"+toString(x)+"_DATA" );
    537 
    538               _component->port_map(name_component,
    539                                    "in_WRITE_"+toString(x++)+"_ADDRESS",
    540                                    _name,
    541                                    "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_OLD_NUM_REG");
     522//        for (uint32_t j=0; j<_param->_nb_inst_retire_rob [i]; j++)
     523//          {
     524//            _component->port_map(name_component,
     525//                                 "in_WRITE_"+toString(x)+"_VAL" ,
     526//                                 _name+"_glue",
     527//                                 "out_RETIRE_ROB_GPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_VAL");
     528//            _component->port_map(name_component,
     529//                                 "out_WRITE_"+toString(x)+"_ACK",
     530//                                 _name+"_glue",
     531//                                 "in_RETIRE_ROB_GPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_ACK" );
     532
     533//            _component->port_map(name_component,
     534//                                 "in_WRITE_"+toString(x)+"_DATA" ,
     535//                                 _name+"_glue",
     536//                                 "out_CONST_0");
     537//            _component->port_map(_name+"_glue",
     538//                                 "out_CONST_0",
     539//                                 name_component,
     540//                                 "in_WRITE_"+toString(x)+"_DATA" );
     541
     542//            _component->port_map(name_component,
     543//                                 "in_WRITE_"+toString(x++)+"_ADDRESS",
     544//                                 _name,
     545//                                 "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_OLD_NUM_REG");
    542546             
    543               _component->port_map(name_component,
    544                                    "in_WRITE_"+toString(x)+"_VAL" ,
    545                                    _name+"_glue",
    546                                    "out_RETIRE_ROB_GPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_VAL");
    547               _component->port_map(name_component,
    548                                    "out_WRITE_"+toString(x)+"_ACK",
    549                                    _name+"_glue",
    550                                    "in_RETIRE_ROB_GPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_ACK" );
    551 
    552               _component->port_map(name_component,
    553                                    "in_WRITE_"+toString(x)+"_DATA" ,
    554                                    _name+"_glue",
    555                                    "out_CONST_1"
    556                                    );
    557               _component->port_map(_name+"_glue",
    558                                    "out_CONST_1",
    559                                    name_component,
    560                                    "in_WRITE_"+toString(x)+"_DATA"
    561                                    );
    562 
    563               _component->port_map(name_component,
    564                                    "in_WRITE_"+toString(x++)+"_ADDRESS",
    565                                    _name,
    566                                    "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_NEW_NUM_REG");
    567             }
     547//            _component->port_map(name_component,
     548//                                 "in_WRITE_"+toString(x)+"_VAL" ,
     549//                                 _name+"_glue",
     550//                                 "out_RETIRE_ROB_GPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_VAL");
     551//            _component->port_map(name_component,
     552//                                 "out_WRITE_"+toString(x)+"_ACK",
     553//                                 _name+"_glue",
     554//                                 "in_RETIRE_ROB_GPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_ACK" );
     555
     556//            _component->port_map(name_component,
     557//                                 "in_WRITE_"+toString(x)+"_DATA" ,
     558//                                 _name+"_glue",
     559//                                 "out_CONST_1"
     560//                                 );
     561//            _component->port_map(_name+"_glue",
     562//                                 "out_CONST_1",
     563//                                 name_component,
     564//                                 "in_WRITE_"+toString(x)+"_DATA"
     565//                                 );
     566
     567//            _component->port_map(name_component,
     568//                                 "in_WRITE_"+toString(x++)+"_ADDRESS",
     569//                                 _name,
     570//                                 "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_NEW_NUM_REG");
     571//          }
    568572
    569573        }
    … …  
    574578        name_component = _name+"_spr_"+toString(i);
    575579       
    576         std::cout << "Instance : " << name_component << std::endl;
     580        log_printf(INFO,Register_unit,FUNCTION,_("Instance : %s"),name_component.c_str());
    577581       
    578582#ifdef POSITION
    … …  
    631635          name_component = _name+"_spr_status_"+toString(i);
    632636         
    633           std::cout << "Instance : " << name_component << std::endl;
    634          
     637          log_printf(INFO,Register_unit,FUNCTION,_("Instance : %s"),name_component.c_str());   
     638 
    635639#ifdef POSITION
    636640          _component->interface_map (name_component,"",
    … …  
    717721            }
    718722
    719           for (uint32_t j=0; j<_param->_nb_inst_retire_rob [i]; j++)
    720             {
    721               _component->port_map(name_component,
    722                                    "in_WRITE_"+toString(x)+"_VAL" ,
    723                                    _name+"_glue",
    724                                    "out_RETIRE_ROB_SPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_VAL");
    725               _component->port_map(name_component,
    726                                    "out_WRITE_"+toString(x)+"_ACK",
    727                                    _name+"_glue",
    728                                    "in_RETIRE_ROB_SPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_ACK" );
    729 
    730               _component->port_map(name_component,
    731                                    "in_WRITE_"+toString(x)+"_DATA" ,
    732                                    _name+"_glue",
    733                                    "out_CONST_0");
    734               _component->port_map(_name+"_glue",
    735                                    "out_CONST_0",
    736                                    name_component,
    737                                    "in_WRITE_"+toString(x)+"_DATA"
    738                                    );
    739 
    740               _component->port_map(name_component,
    741                                    "in_WRITE_"+toString(x++)+"_ADDRESS",
    742                                    _name,
    743                                    "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_OLD_NUM_REG");
     723//        for (uint32_t j=0; j<_param->_nb_inst_retire_rob [i]; j++)
     724//          {
     725//            _component->port_map(name_component,
     726//                                 "in_WRITE_"+toString(x)+"_VAL" ,
     727//                                 _name+"_glue",
     728//                                 "out_RETIRE_ROB_SPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_VAL");
     729//            _component->port_map(name_component,
     730//                                 "out_WRITE_"+toString(x)+"_ACK",
     731//                                 _name+"_glue",
     732//                                 "in_RETIRE_ROB_SPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_ACK" );
     733
     734//            _component->port_map(name_component,
     735//                                 "in_WRITE_"+toString(x)+"_DATA" ,
     736//                                 _name+"_glue",
     737//                                 "out_CONST_0");
     738//            _component->port_map(_name+"_glue",
     739//                                 "out_CONST_0",
     740//                                 name_component,
     741//                                 "in_WRITE_"+toString(x)+"_DATA"
     742//                                 );
     743
     744//            _component->port_map(name_component,
     745//                                 "in_WRITE_"+toString(x++)+"_ADDRESS",
     746//                                 _name,
     747//                                 "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_OLD_NUM_REG");
    744748             
    745               _component->port_map(name_component,
    746                                    "in_WRITE_"+toString(x)+"_VAL" ,
    747                                    _name+"_glue",
    748                                    "out_RETIRE_ROB_SPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_VAL");
    749               _component->port_map(name_component,
    750                                    "out_WRITE_"+toString(x)+"_ACK",
    751                                    _name+"_glue",
    752                                    "in_RETIRE_ROB_SPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_ACK" );
    753 
    754               _component->port_map(name_component,
    755                                    "in_WRITE_"+toString(x)+"_DATA" ,
    756                                    _name+"_glue",
    757                                    "out_CONST_1"
    758                                    );
    759               _component->port_map(_name+"_glue",
    760                                    "out_CONST_1",
    761                                    name_component,
    762                                    "in_WRITE_"+toString(x)+"_DATA"
    763                                    );
    764 
    765               _component->port_map(name_component,
    766                                    "in_WRITE_"+toString(x++)+"_ADDRESS",
    767                                    _name,
    768                                    "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_NEW_NUM_REG");
    769             }
     749//            _component->port_map(name_component,
     750//                                 "in_WRITE_"+toString(x)+"_VAL" ,
     751//                                 _name+"_glue",
     752//                                 "out_RETIRE_ROB_SPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_VAL");
     753//            _component->port_map(name_component,
     754//                                 "out_WRITE_"+toString(x)+"_ACK",
     755//                                 _name+"_glue",
     756//                                 "in_RETIRE_ROB_SPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_ACK" );
     757
     758//            _component->port_map(name_component,
     759//                                 "in_WRITE_"+toString(x)+"_DATA" ,
     760//                                 _name+"_glue",
     761//                                 "out_CONST_1"
     762//                                 );
     763//            _component->port_map(_name+"_glue",
     764//                                 "out_CONST_1",
     765//                                 name_component,
     766//                                 "in_WRITE_"+toString(x)+"_DATA"
     767//                                 );
     768
     769//            _component->port_map(name_component,
     770//                                 "in_WRITE_"+toString(x++)+"_ADDRESS",
     771//                                 _name,
     772//                                 "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_NEW_NUM_REG");
     773//          }
    770774
    771775        }
    … …  
    775779      name_component = _name+"_glue";
    776780     
    777       std::cout << "Instance : " << name_component << std::endl;
    778     
     781      log_printf(INFO,Register_unit,FUNCTION,_("Instance : %s"),name_component.c_str()); 
     782   
    779783#ifdef POSITION
    780784      _component->interface_map (name_component,"",
    … …  
    10101014        }
    10111015
    1012       for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
    1013         {
    1014           uint32_t x     =_param->_nb_inst_retire_rob [i];
    1015           uint32_t gpr_j = _param->_nb_gpr_write + _param->_nb_inst_insert_rob [i];
    1016           uint32_t spr_j = _param->_nb_spr_write + _param->_nb_inst_insert_rob [i];
    1017 
    1018           for (uint32_t j=0; j<x; j++)
    1019             {
    1020               _component->port_map(name_component,
    1021                                    "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_VAL",
    1022                                    _name,
    1023                                    "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_VAL");
    1024               _component->port_map(name_component,
    1025                                    "out_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_ACK",
    1026                                    _name,
    1027                                    "out_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_ACK");
    1028               _component->port_map(name_component,
    1029                                    "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_OLD_USE",
    1030                                    _name,
    1031                                    "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_OLD_USE");
    1032               _component->port_map(name_component,
    1033                                    "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_NEW_USE",
    1034                                    _name,
    1035                                    "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_NEW_USE");
    1036               _component->port_map(name_component,
    1037                                    "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_OLD_USE",
    1038                                    _name,
    1039                                    "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_OLD_USE");
    1040               _component->port_map(name_component,
    1041                                    "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_NEW_USE",
    1042                                    _name,
    1043                                    "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_NEW_USE");
     1016//       for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     1017//      {
     1018//        uint32_t x     =_param->_nb_inst_retire_rob [i];
     1019//        uint32_t gpr_j = _param->_nb_gpr_write + _param->_nb_inst_insert_rob [i];
     1020//        uint32_t spr_j = _param->_nb_spr_write + _param->_nb_inst_insert_rob [i];
     1021
     1022//        for (uint32_t j=0; j<x; j++)
     1023//          {
     1024//            _component->port_map(name_component,
     1025//                                 "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_VAL",
     1026//                                 _name,
     1027//                                 "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_VAL");
     1028//            _component->port_map(name_component,
     1029//                                 "out_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_ACK",
     1030//                                 _name,
     1031//                                 "out_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_ACK");
     1032//            _component->port_map(name_component,
     1033//                                 "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_OLD_USE",
     1034//                                 _name,
     1035//                                 "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_OLD_USE");
     1036//            _component->port_map(name_component,
     1037//                                 "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_NEW_USE",
     1038//                                 _name,
     1039//                                 "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_NEW_USE");
     1040//            _component->port_map(name_component,
     1041//                                 "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_OLD_USE",
     1042//                                 _name,
     1043//                                 "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_OLD_USE");
     1044//            _component->port_map(name_component,
     1045//                                 "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_NEW_USE",
     1046//                                 _name,
     1047//                                 "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_NEW_USE");
    10441048           
    1045               _component->port_map(name_component,
    1046                                    "out_RETIRE_ROB_GPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_VAL",
    1047                                    _name+"_gpr_status_"+toString(i),
    1048                                    "in_WRITE_"+toString(gpr_j)+"_VAL");
    1049               _component->port_map(name_component,
    1050                                    "in_RETIRE_ROB_GPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_ACK",
    1051                                    _name+"_gpr_status_"+toString(i),
    1052                                    "out_WRITE_"+toString(gpr_j++)+"_ACK");
    1053               _component->port_map(name_component,
    1054                                    "out_RETIRE_ROB_GPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_VAL",
    1055                                    _name+"_gpr_status_"+toString(i),
    1056                                    "in_WRITE_"+toString(gpr_j)+"_VAL");
    1057               _component->port_map(name_component,
    1058                                    "in_RETIRE_ROB_GPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_ACK",
    1059                                    _name+"_gpr_status_"+toString(i),
    1060                                    "out_WRITE_"+toString(gpr_j++)+"_ACK");
    1061               _component->port_map(name_component,
    1062                                    "out_RETIRE_ROB_SPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_VAL",
    1063                                    _name+"_spr_status_"+toString(i),
    1064                                    "in_WRITE_"+toString(spr_j)+"_VAL");
    1065               _component->port_map(name_component,
    1066                                    "in_RETIRE_ROB_SPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_ACK",
    1067                                    _name+"_spr_status_"+toString(i),
    1068                                    "out_WRITE_"+toString(spr_j++)+"_ACK");
    1069               _component->port_map(name_component,
    1070                                    "out_RETIRE_ROB_SPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_VAL",
    1071                                    _name+"_spr_status_"+toString(i),
    1072                                    "in_WRITE_"+toString(spr_j)+"_VAL");
    1073               _component->port_map(name_component,
    1074                                    "in_RETIRE_ROB_SPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_ACK",
    1075                                    _name+"_spr_status_"+toString(i),
    1076                                    "out_WRITE_"+toString(spr_j++)+"_ACK");
    1077             }
    1078         }
     1049//            _component->port_map(name_component,
     1050//                                 "out_RETIRE_ROB_GPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_VAL",
     1051//                                 _name+"_gpr_status_"+toString(i),
     1052//                                 "in_WRITE_"+toString(gpr_j)+"_VAL");
     1053//            _component->port_map(name_component,
     1054//                                 "in_RETIRE_ROB_GPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_ACK",
     1055//                                 _name+"_gpr_status_"+toString(i),
     1056//                                 "out_WRITE_"+toString(gpr_j++)+"_ACK");
     1057//            _component->port_map(name_component,
     1058//                                 "out_RETIRE_ROB_GPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_VAL",
     1059//                                 _name+"_gpr_status_"+toString(i),
     1060//                                 "in_WRITE_"+toString(gpr_j)+"_VAL");
     1061//            _component->port_map(name_component,
     1062//                                 "in_RETIRE_ROB_GPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_ACK",
     1063//                                 _name+"_gpr_status_"+toString(i),
     1064//                                 "out_WRITE_"+toString(gpr_j++)+"_ACK");
     1065//            _component->port_map(name_component,
     1066//                                 "out_RETIRE_ROB_SPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_VAL",
     1067//                                 _name+"_spr_status_"+toString(i),
     1068//                                 "in_WRITE_"+toString(spr_j)+"_VAL");
     1069//            _component->port_map(name_component,
     1070//                                 "in_RETIRE_ROB_SPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_ACK",
     1071//                                 _name+"_spr_status_"+toString(i),
     1072//                                 "out_WRITE_"+toString(spr_j++)+"_ACK");
     1073//            _component->port_map(name_component,
     1074//                                 "out_RETIRE_ROB_SPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_VAL",
     1075//                                 _name+"_spr_status_"+toString(i),
     1076//                                 "in_WRITE_"+toString(spr_j)+"_VAL");
     1077//            _component->port_map(name_component,
     1078//                                 "in_RETIRE_ROB_SPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_ACK",
     1079//                                 _name+"_spr_status_"+toString(i),
     1080//                                 "out_WRITE_"+toString(spr_j++)+"_ACK");
     1081//          }
     1082//      }
    10791083    }// glue
    10801084
    1081 //     _component->test_map ();
    1082 
    1083 #ifdef POSITION
    1084     _component->generate_file();
     1085#if DEBUG_Register_unit == true
     1086    _component->test_map ();
     1087#endif
     1088
     1089#ifdef POSITION
     1090    if (usage_is_set(_usage,USE_POSITION))
     1091      _component->generate_file();
    10851092#endif
    10861093

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/src/Register_unit_deallocation.cpp

    r81 r88  
    2222    log_printf(FUNC,Register_unit,FUNCTION,"Begin");
    2323
     24    if (usage_is_set(_usage,USE_SYSTEMC))
     25      {
    2426//#if defined(STATISTICS) or defined(VHDL_TESTBENCH)
    2527    delete     in_CLOCK ;
    … …  
    5961    delete []  in_INSERT_ROB_RE_USE            ;
    6062    delete []  in_INSERT_ROB_RE_NUM_REG        ;
    61     delete []  in_RETIRE_ROB_VAL               ;
    62     delete [] out_RETIRE_ROB_ACK               ;
    63     delete []  in_RETIRE_ROB_RD_OLD_USE        ;
    64     delete []  in_RETIRE_ROB_RD_OLD_NUM_REG    ;
    65     delete []  in_RETIRE_ROB_RD_NEW_USE        ;
    66     delete []  in_RETIRE_ROB_RD_NEW_NUM_REG    ;
    67     delete []  in_RETIRE_ROB_RE_OLD_USE        ;
    68     delete []  in_RETIRE_ROB_RE_OLD_NUM_REG    ;
    69     delete []  in_RETIRE_ROB_RE_NEW_USE        ;
    70     delete []  in_RETIRE_ROB_RE_NEW_NUM_REG    ;
     63//     delete []  in_RETIRE_ROB_VAL               ;
     64//     delete [] out_RETIRE_ROB_ACK               ;
     65//     delete []  in_RETIRE_ROB_RD_OLD_USE        ;
     66//     delete []  in_RETIRE_ROB_RD_OLD_NUM_REG    ;
     67//     delete []  in_RETIRE_ROB_RD_NEW_USE        ;
     68//     delete []  in_RETIRE_ROB_RD_NEW_NUM_REG    ;
     69//     delete []  in_RETIRE_ROB_RE_OLD_USE        ;
     70//     delete []  in_RETIRE_ROB_RE_OLD_NUM_REG    ;
     71//     delete []  in_RETIRE_ROB_RE_NEW_USE        ;
     72//     delete []  in_RETIRE_ROB_RE_NEW_NUM_REG    ;
     73      }
    7174
    7275    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/src/Register_unit_end_cycle.cpp

    r81 r88  
    2323
    2424#ifdef STATISTICS
    25     _stat->end_cycle();
     25    if (usage_is_set(_usage,USE_STATISTICS))
     26      _stat->end_cycle();
    2627#endif   
    2728
    … …  
    2930    // Evaluation before read the ouput signal
    3031//  sc_start(0);
    31     _interfaces->testbench();
     32    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
     33      _interfaces->testbench();
    3234#endif
    3335
Note: See TracChangeset for help on using the changeset viewer.