Ignore:
Timestamp:
Dec 8, 2007, 5:12:36 PM (17 years ago)
Author:
rosiere
Message:

read_queue : systemC et vhdl ok !
queue : quelques petits modif pour avoir une queue de taille 1
nettoyage des fichiers *mkf*

Location:
trunk/IPs/systemC/processor/Morpheo
Files:
3 added
14 deleted
31 edited
1 moved

Legend:

Unmodified
Added
Removed

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/Makefile.deps

    r54 r68  
    22# $Id$
    33#
    4 # [ Description ]
     4# [ Description ]
    55#
    66# Makefile
    … …  
    1313include                         $(DIR_MORPHEO)/Behavioural/Makefile.deps
    1414endif
     15ifndef Queue
     16include                         $(DIR_MORPHEO)/Behavioural/Generic/Queue/Makefile.deps
     17endif
    1518
    16 #-----[ Library ]------------------------------------------
    17 Read_queue_LIBRARY              =       -lRead_queue    \
     19#-----[ Library ]------------------------------------------
     20Read_queue_LIBRARY              =       -lRead_queue            \
     21                                        $(Queue_LIBRARY)        \
    1822                                        $(Behavioural_LIBRARY) 
    1923
    2024Read_queue_DIR_LIBRARY          =       -L$(DIR_MORPHEO)/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/lib      \
     25                                        $(Queue_DIR_LIBRARY) \
    2126                                        $(Behavioural_DIR_LIBRARY)
    2227
    23 #-----[ Rules ]--------------------------------------------
     28Read_queue_DEPENDENCIES         =       Queue_library   \
     29                                        Behavioural_library
    2430
    25 Read_queue_library              :
     31Read_queue_CLEAN                =       Queue_library_clean     \
     32                                        Behavioural_library_clean
     33
     34#-----[ Rules ]--------------------------------------------
     35
     36.NOTPARALLEL                    : Read_queue_library Read_queue_library_clean
     37
     38Read_queue_library              : $(Read_queue_DEPENDENCIES)
    2639                                @\
    27                                 $(MAKE) Behavioural_library; \
    2840                                $(MAKE) --directory=$(DIR_MORPHEO)/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue --makefile=Makefile;
    2941       
    30 Read_queue_library_clean        :
     42Read_queue_library_clean        : $(Read_queue_CLEAN)
    3143                                @\
    32                                 $(MAKE) Behavioural_library_clean; \
    3344                                $(MAKE) --directory=$(DIR_MORPHEO)/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue --makefile=Makefile clean;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/SelfTest/config1.cfg

    r66 r68  
    6632      32      *2      # nb_packet         
    7716      16      +1      # size_general_data 
    8 8       8       +1      # size_special_data 
    9 16      16      *2      # nb_general_register
    10 2       2       +1      # nb_special_register
     816      16      +1      # size_special_data 
     94       4       *2      # nb_general_register
     104       4       +1      # nb_special_register
    111140      40      +1      # nb_operation       
    12126       6       +1      # nb_type           
    13 1       4       *2      # nb_gpr_write
    14 1       4       *2      # nb_spr_write
     132       4       *2      # nb_gpr_write
     142       4       *2      # nb_spr_write

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

    r66 r68  
    214214  (*(_Read_queue->in_NRESET))        (*(NRESET));
    215215
    216  
    217216  (*(_Read_queue-> in_READ_QUEUE_IN_VAL            )) (*(READ_QUEUE_IN_VAL            ));
    218217  (*(_Read_queue->out_READ_QUEUE_IN_ACK            )) (*(READ_QUEUE_IN_ACK            ));
    219   (*(_Read_queue-> in_READ_QUEUE_IN_CONTEXT_ID     )) (*(READ_QUEUE_IN_CONTEXT_ID     ));
    220   (*(_Read_queue-> in_READ_QUEUE_IN_FRONT_END_ID   )) (*(READ_QUEUE_IN_FRONT_END_ID   ));
    221   (*(_Read_queue-> in_READ_QUEUE_IN_OOO_ENGINE_ID  )) (*(READ_QUEUE_IN_OOO_ENGINE_ID  ));
    222   (*(_Read_queue-> in_READ_QUEUE_IN_ROB_ID         )) (*(READ_QUEUE_IN_ROB_ID         ));
     218  if(_param->_have_port_context_id   )
     219    (*(_Read_queue-> in_READ_QUEUE_IN_CONTEXT_ID     )) (*(READ_QUEUE_IN_CONTEXT_ID     ));
     220  if(_param->_have_port_front_end_id )
     221    (*(_Read_queue-> in_READ_QUEUE_IN_FRONT_END_ID   )) (*(READ_QUEUE_IN_FRONT_END_ID   ));
     222  if(_param->_have_port_ooo_engine_id)
     223    (*(_Read_queue-> in_READ_QUEUE_IN_OOO_ENGINE_ID  )) (*(READ_QUEUE_IN_OOO_ENGINE_ID  ));
     224  if(_param->_have_port_rob_id       )
     225    (*(_Read_queue-> in_READ_QUEUE_IN_ROB_ID         )) (*(READ_QUEUE_IN_ROB_ID         ));
    223226  (*(_Read_queue-> in_READ_QUEUE_IN_OPERATION      )) (*(READ_QUEUE_IN_OPERATION      ));
    224227  (*(_Read_queue-> in_READ_QUEUE_IN_TYPE           )) (*(READ_QUEUE_IN_TYPE           ));
    … …  
    238241  (*(_Read_queue->out_READ_QUEUE_OUT_VAL           )) (*(READ_QUEUE_OUT_VAL           ));
    239242  (*(_Read_queue-> in_READ_QUEUE_OUT_ACK           )) (*(READ_QUEUE_OUT_ACK           ));
    240   (*(_Read_queue->out_READ_QUEUE_OUT_CONTEXT_ID    )) (*(READ_QUEUE_OUT_CONTEXT_ID    ));
    241   (*(_Read_queue->out_READ_QUEUE_OUT_FRONT_END_ID  )) (*(READ_QUEUE_OUT_FRONT_END_ID  ));
    242   (*(_Read_queue->out_READ_QUEUE_OUT_OOO_ENGINE_ID )) (*(READ_QUEUE_OUT_OOO_ENGINE_ID ));
    243   (*(_Read_queue->out_READ_QUEUE_OUT_ROB_ID        )) (*(READ_QUEUE_OUT_ROB_ID        ));
     243  if(_param->_have_port_context_id   )
     244    (*(_Read_queue->out_READ_QUEUE_OUT_CONTEXT_ID    )) (*(READ_QUEUE_OUT_CONTEXT_ID    ));
     245  if(_param->_have_port_front_end_id )
     246    (*(_Read_queue->out_READ_QUEUE_OUT_FRONT_END_ID  )) (*(READ_QUEUE_OUT_FRONT_END_ID  ));
     247  if(_param->_have_port_ooo_engine_id)
     248    (*(_Read_queue->out_READ_QUEUE_OUT_OOO_ENGINE_ID )) (*(READ_QUEUE_OUT_OOO_ENGINE_ID ));
     249  if(_param->_have_port_rob_id       )
     250    (*(_Read_queue->out_READ_QUEUE_OUT_ROB_ID        )) (*(READ_QUEUE_OUT_ROB_ID        ));
    244251  (*(_Read_queue->out_READ_QUEUE_OUT_OPERATION     )) (*(READ_QUEUE_OUT_OPERATION     ));
    245252  (*(_Read_queue->out_READ_QUEUE_OUT_TYPE          )) (*(READ_QUEUE_OUT_TYPE          ));
    … …  
    267274      (*(_Read_queue->out_GPR_READ_VAL         [i])) (*(GPR_READ_VAL         [i]));
    268275      (*(_Read_queue-> in_GPR_READ_ACK         [i])) (*(GPR_READ_ACK         [i]));
    269       (*(_Read_queue->out_GPR_READ_OOO_ENGINE_ID  [i])) (*(GPR_READ_OOO_ENGINE_ID  [i]));
     276      if(_param->_have_port_ooo_engine_id)
     277        (*(_Read_queue->out_GPR_READ_OOO_ENGINE_ID  [i])) (*(GPR_READ_OOO_ENGINE_ID  [i]));
    270278      (*(_Read_queue->out_GPR_READ_NUM_REG     [i])) (*(GPR_READ_NUM_REG     [i]));
    271279      (*(_Read_queue-> in_GPR_READ_DATA        [i])) (*(GPR_READ_DATA        [i]));
    … …  
    277285      (*(_Read_queue->out_SPR_READ_VAL         [i])) (*(SPR_READ_VAL         [i]));
    278286      (*(_Read_queue-> in_SPR_READ_ACK         [i])) (*(SPR_READ_ACK         [i]));
    279       (*(_Read_queue->out_SPR_READ_OOO_ENGINE_ID  [i])) (*(SPR_READ_OOO_ENGINE_ID  [i]));
     287      if(_param->_have_port_ooo_engine_id)
     288        (*(_Read_queue->out_SPR_READ_OOO_ENGINE_ID  [i])) (*(SPR_READ_OOO_ENGINE_ID  [i]));
    280289      (*(_Read_queue->out_SPR_READ_NUM_REG     [i])) (*(SPR_READ_NUM_REG     [i]));
    281290      (*(_Read_queue-> in_SPR_READ_DATA        [i])) (*(SPR_READ_DATA        [i]));
    … …  
    286295    {
    287296      (*(_Read_queue-> in_GPR_WRITE_VAL        [i])) (*(GPR_WRITE_VAL        [i]));
    288       (*(_Read_queue-> in_GPR_WRITE_OOO_ENGINE_ID [i])) (*(GPR_WRITE_OOO_ENGINE_ID [i]));
     297      if(_param->_have_port_ooo_engine_id)
     298        (*(_Read_queue-> in_GPR_WRITE_OOO_ENGINE_ID [i])) (*(GPR_WRITE_OOO_ENGINE_ID [i]));
    289299      (*(_Read_queue-> in_GPR_WRITE_NUM_REG    [i])) (*(GPR_WRITE_NUM_REG    [i]));
    290300      (*(_Read_queue-> in_GPR_WRITE_DATA       [i])) (*(GPR_WRITE_DATA       [i]));
    … …  
    294304    {
    295305      (*(_Read_queue-> in_SPR_WRITE_VAL        [i])) (*(SPR_WRITE_VAL        [i]));
    296       (*(_Read_queue-> in_SPR_WRITE_OOO_ENGINE_ID [i])) (*(SPR_WRITE_OOO_ENGINE_ID [i]));
     306      if(_param->_have_port_ooo_engine_id)
     307        (*(_Read_queue-> in_SPR_WRITE_OOO_ENGINE_ID [i])) (*(SPR_WRITE_OOO_ENGINE_ID [i]));
    297308      (*(_Read_queue-> in_SPR_WRITE_NUM_REG    [i])) (*(SPR_WRITE_NUM_REG    [i]));
    298309      (*(_Read_queue-> in_SPR_WRITE_DATA       [i])) (*(SPR_WRITE_DATA       [i]));
    … …  
    308319  // Initialisation
    309320  const uint32_t nb_request = _param->_nb_packet;
    310 //const uint32_t seed       = 0;
     321  // const uint32_t seed       = 0;
    311322  const uint32_t seed       = static_cast<uint32_t>(time(NULL));
    312323  srand(seed);
    … …  
    342353    {
    343354      LABEL("Iteration "+toString(iteration));
    344       int32_t percent_transaction_queue_in     = (rand()%50)+25;
    345       int32_t percent_transaction_queue_out    = (rand()%50)+25;
    346       int32_t percent_registerfile_valid       = (rand()%50)+25;
    347       int32_t percent_transaction_registerfile = (rand()%74)+25;
    348       int32_t percent_transaction_bypass       = (rand()%50)+25;
    349      
     355      int32_t percent_transaction_queue_in     = (rand()%45)+30;
     356      int32_t percent_transaction_queue_out    = (rand()%45)+30;
     357      int32_t percent_registerfile_valid       = (rand()%45)+30;
     358      int32_t percent_transaction_registerfile = (rand()%45)+30;
     359      int32_t percent_transaction_bypass       = (rand()%45)+30;
     360      int32_t percent_must_read_reg            = (rand()%45)+30;
     361
    350362      LABEL("Initialisation");
    351363
    … …  
    353365        {
    354366          _ooo_engine_id   [i] = rand()% _param->_nb_ooo_engine         ;
    355           _read_ra      [i] = rand()% 2                              ;
     367          _read_ra      [i] = (rand()%100)<percent_must_read_reg;
    356368          _num_reg_ra   [i] = rand()% _param->_nb_general_register   ;
    357           _read_rb      [i] = rand()% 2                              ;
     369          _read_rb      [i] = (rand()%100)<percent_must_read_reg;
    358370          _num_reg_rb   [i] = rand()% _param->_nb_general_register   ;
    359           _read_rc      [i] = rand()% 2                              ;
     371          _read_rc      [i] = (rand()%100)<percent_must_read_reg;
    360372          _num_reg_rc   [i] = rand()% _param->_nb_special_register   ;
    361373        }
    … …  
    386398            {
    387399              READ_QUEUE_IN_VAL            ->write(1);
    388               READ_QUEUE_IN_OOO_ENGINE_ID  ->write(_ooo_engine_id [request_in]);
    389               READ_QUEUE_IN_CONTEXT_ID     ->write((2*_ooo_engine_id [request_in])%_param->_nb_context  );
    390               READ_QUEUE_IN_FRONT_END_ID   ->write((3*_ooo_engine_id [request_in])%_param->_nb_front_end);
    391               READ_QUEUE_IN_ROB_ID      ->write(request_in);
     400              if(_param->_have_port_ooo_engine_id)
     401                READ_QUEUE_IN_OOO_ENGINE_ID  ->write(_ooo_engine_id [request_in]);
     402              if(_param->_have_port_context_id   )
     403                READ_QUEUE_IN_CONTEXT_ID     ->write((2*_ooo_engine_id [request_in])%_param->_nb_context  );
     404              if(_param->_have_port_front_end_id )
     405                READ_QUEUE_IN_FRONT_END_ID   ->write((3*_ooo_engine_id [request_in])%_param->_nb_front_end);
     406              if(_param->_have_port_rob_id       )
     407                READ_QUEUE_IN_ROB_ID      ->write(request_in);
    392408              READ_QUEUE_IN_OPERATION   ->write(0);
    393409              READ_QUEUE_IN_TYPE        ->write(0);
    … …  
    419435                {
    420436                  Tgeneral_address_t num_reg = GPR_READ_NUM_REG       [i]->read();
    421                   Tcontext_t         context = GPR_READ_OOO_ENGINE_ID [i]->read();
    422 
    423                   GPR_READ_DATA     [i]->write(_gpr    [num_reg][context]);
    424                   GPR_READ_DATA_VAL [i]->write(_gpr_val[num_reg][context]);
     437                  Tcontext_t         ooo_engine;
     438                  if(_param->_have_port_ooo_engine_id)
     439                    ooo_engine = GPR_READ_OOO_ENGINE_ID [i]->read();
     440                  else
     441                    ooo_engine = 0;
     442
     443                  GPR_READ_DATA     [i]->write(_gpr    [num_reg][ooo_engine]);
     444                  GPR_READ_DATA_VAL [i]->write(_gpr_val[num_reg][ooo_engine]);
    425445                }
    426446            }
    … …  
    432452                {
    433453                  Tspecial_address_t num_reg = SPR_READ_NUM_REG       [i]->read();
    434                   Tcontext_t         context = SPR_READ_OOO_ENGINE_ID [i]->read();
    435 
    436                   SPR_READ_DATA     [i]->write(_spr    [num_reg][context]);
    437                   SPR_READ_DATA_VAL [i]->write(_spr_val[num_reg][context]);
     454                  Tcontext_t         ooo_engine;
     455                  if(_param->_have_port_ooo_engine_id)
     456                    ooo_engine = SPR_READ_OOO_ENGINE_ID [i]->read();
     457                  else
     458                    ooo_engine = 0;
     459
     460                  SPR_READ_DATA     [i]->write(_spr    [num_reg][ooo_engine]);
     461                  SPR_READ_DATA_VAL [i]->write(_spr_val[num_reg][ooo_engine]);
    438462                }
    439463            }
    … …  
    448472             
    449473              GPR_WRITE_VAL           [i]->write(val);       
    450               GPR_WRITE_OOO_ENGINE_ID [i]->write(ooo_engine);
     474              if(_param->_have_port_ooo_engine_id)
     475                GPR_WRITE_OOO_ENGINE_ID [i]->write(ooo_engine);
    451476              GPR_WRITE_NUM_REG       [i]->write(num_reg);
    452477              GPR_WRITE_DATA          [i]->write(data);
    … …  
    466491             
    467492              SPR_WRITE_VAL            [i]->write(val);       
    468               SPR_WRITE_OOO_ENGINE_ID  [i]->write(ooo_engine);
     493              if(_param->_have_port_ooo_engine_id)
     494                SPR_WRITE_OOO_ENGINE_ID  [i]->write(ooo_engine);
    469495              SPR_WRITE_NUM_REG        [i]->write(num_reg);
    470496              SPR_WRITE_DATA           [i]->write(data);
    … …  
    490516              (READ_QUEUE_OUT_ACK->read() == 1))
    491517            {
    492               Tpacket_t  rob_id = READ_QUEUE_OUT_ROB_ID->read();
     518              Tpacket_t  rob_id;
     519              if(_param->_have_port_rob_id       )
     520                rob_id = READ_QUEUE_OUT_ROB_ID->read();
     521              else
     522                rob_id = 0;
    493523              Tcontext_t ctxt   = _ooo_engine_id [rob_id];
    494524              LABEL("Accepted READ_QUEUE_OUT ["+toString(rob_id)+"]");
    … …  
    498528              request_out ++;
    499529
    500               TEST(Tcontext_t        ,READ_QUEUE_OUT_OOO_ENGINE_ID ->read(),ctxt);
    501               TEST(Tcontext_t        ,READ_QUEUE_OUT_CONTEXT_ID    ->read(),(2*ctxt)%_param->_nb_context  );
    502               TEST(Tcontext_t        ,READ_QUEUE_OUT_FRONT_END_ID  ->read(),(3*ctxt)%_param->_nb_front_end);
     530              if(_param->_have_port_ooo_engine_id)
     531                TEST(Tcontext_t        ,READ_QUEUE_OUT_OOO_ENGINE_ID ->read(),ctxt);
     532              if(_param->_have_port_context_id   )
     533                TEST(Tcontext_t        ,READ_QUEUE_OUT_CONTEXT_ID    ->read(),(2*ctxt)%_param->_nb_context  );
     534              if(_param->_have_port_front_end_id )
     535                TEST(Tcontext_t        ,READ_QUEUE_OUT_FRONT_END_ID  ->read(),(3*ctxt)%_param->_nb_front_end);
    503536
    504537              TEST(Tcontrol_t        ,READ_QUEUE_OUT_READ_RA    ->read(),_read_ra      [rob_id]);
    … …  
    533566  cout << "<" << name << "> ............ Stop Simulation" << endl;
    534567
    535 //   delete    CLOCK;
    536 //   delete    NRESET;
    537 
    538 //   delete    READ_QUEUE_IN_VAL          ;
    539 //   delete    READ_QUEUE_IN_ACK          ;
    540 //   delete    READ_QUEUE_IN_CONTEXT_ID   ;
    541 //   delete    READ_QUEUE_IN_FRONT_END_ID;
    542 //   delete    READ_QUEUE_IN_OOO_ENGINE_ID;
    543 //   delete    READ_QUEUE_IN_ROB_ID    ;
    544 //   delete    READ_QUEUE_IN_OPERATION    ;
    545 //   delete    READ_QUEUE_IN_TYPE         ;
    546 //   delete    READ_QUEUE_IN_HAS_IMMEDIAT ;
    547 //   delete    READ_QUEUE_IN_IMMEDIAT     ;
    548 //   delete    READ_QUEUE_IN_READ_RA      ;
    549 //   delete    READ_QUEUE_IN_NUM_REG_RA   ;
    550 //   delete    READ_QUEUE_IN_READ_RB      ;
    551 //   delete    READ_QUEUE_IN_NUM_REG_RB   ;
    552 //   delete    READ_QUEUE_IN_READ_RC      ;
    553 //   delete    READ_QUEUE_IN_NUM_REG_RC   ;
    554 //   delete    READ_QUEUE_IN_WRITE_RD     ;
    555 //   delete    READ_QUEUE_IN_NUM_REG_RD   ;
    556 //   delete    READ_QUEUE_IN_WRITE_RE     ;
    557 //   delete    READ_QUEUE_IN_NUM_REG_RE   ;
    558 
    559 //   delete    READ_QUEUE_OUT_VAL         ;
    560 //   delete    READ_QUEUE_OUT_ACK         ;
    561 //   delete    READ_QUEUE_OUT_CONTEXT_ID  ;
    562 //   delete    READ_QUEUE_OUT_FRONT_END_ID;
    563 //   delete    READ_QUEUE_OUT_OOO_ENGINE_ID;
    564 //   delete    READ_QUEUE_OUT_ROB_ID      ;
    565 //   delete    READ_QUEUE_OUT_OPERATION   ;
    566 //   delete    READ_QUEUE_OUT_TYPE        ;
    567 //   delete    READ_QUEUE_OUT_HAS_IMMEDIAT;
    568 //   delete    READ_QUEUE_OUT_IMMEDIAT    ;
    569 //   delete    READ_QUEUE_OUT_READ_RA     ;
    570 //   delete    READ_QUEUE_OUT_NUM_REG_RA  ;
    571 //   delete    READ_QUEUE_OUT_DATA_RA_VAL ;
    572 //   delete    READ_QUEUE_OUT_DATA_RA     ;
    573 //   delete    READ_QUEUE_OUT_READ_RB     ;
    574 //   delete    READ_QUEUE_OUT_NUM_REG_RB  ;
    575 //   delete    READ_QUEUE_OUT_DATA_RB_VAL ;
    576 //   delete    READ_QUEUE_OUT_DATA_RB     ;
    577 //   delete    READ_QUEUE_OUT_READ_RC     ;
    578 //   delete    READ_QUEUE_OUT_NUM_REG_RC  ;
    579 //   delete    READ_QUEUE_OUT_DATA_RC_VAL ;
    580 //   delete    READ_QUEUE_OUT_DATA_RC     ;
    581 //   delete    READ_QUEUE_OUT_WRITE_RD    ;
    582 //   delete    READ_QUEUE_OUT_NUM_REG_RD  ;
    583 //   delete    READ_QUEUE_OUT_WRITE_RE    ;
    584 //   delete    READ_QUEUE_OUT_NUM_REG_RE  ;
    585 
    586 //   delete [] GPR_READ_VAL     ;
    587 //   delete [] GPR_READ_ACK     ;
    588 //   delete [] GPR_READ_NUM_REG ;
    589 //   delete [] GPR_READ_DATA    ;
    590 //   delete [] GPR_READ_DATA_VAL;
    591 //   delete [] GPR_READ_OOO_ENGINE_ID ;
    592 
    593 //   delete [] SPR_READ_VAL     ;
    594 //   delete [] SPR_READ_ACK     ;
    595 //   delete [] SPR_READ_NUM_REG ;
    596 //   delete [] SPR_READ_DATA    ;
    597 //   delete [] SPR_READ_DATA_VAL;
    598 //   delete [] SPR_READ_OOO_ENGINE_ID ;
    599 
    600 //   delete [] GPR_WRITE_VAL        ;
    601 //   delete [] GPR_WRITE_OOO_ENGINE_ID ;
    602 //   delete [] GPR_WRITE_NUM_REG    ;
    603 //   delete [] GPR_WRITE_DATA       ;
    604 
    605 //   delete [] SPR_WRITE_VAL        ;
    606 //   delete [] SPR_WRITE_OOO_ENGINE_ID ;
    607 //   delete [] SPR_WRITE_NUM_REG    ;
    608 //   delete [] SPR_WRITE_DATA       ;
     568   delete    CLOCK;
     569   delete    NRESET;
     570
     571   delete    READ_QUEUE_IN_VAL          ;
     572   delete    READ_QUEUE_IN_ACK          ;
     573   if(_param->_have_port_context_id   )
     574     delete    READ_QUEUE_IN_CONTEXT_ID   ;
     575   if(_param->_have_port_front_end_id )
     576     delete    READ_QUEUE_IN_FRONT_END_ID;
     577   if(_param->_have_port_ooo_engine_id )
     578     delete    READ_QUEUE_IN_OOO_ENGINE_ID;
     579   if(_param->_have_port_rob_id       )
     580     delete    READ_QUEUE_IN_ROB_ID    ;
     581   delete    READ_QUEUE_IN_OPERATION    ;
     582   delete    READ_QUEUE_IN_TYPE         ;
     583   delete    READ_QUEUE_IN_HAS_IMMEDIAT ;
     584   delete    READ_QUEUE_IN_IMMEDIAT     ;
     585   delete    READ_QUEUE_IN_READ_RA      ;
     586   delete    READ_QUEUE_IN_NUM_REG_RA   ;
     587   delete    READ_QUEUE_IN_READ_RB      ;
     588   delete    READ_QUEUE_IN_NUM_REG_RB   ;
     589   delete    READ_QUEUE_IN_READ_RC      ;
     590   delete    READ_QUEUE_IN_NUM_REG_RC   ;
     591   delete    READ_QUEUE_IN_WRITE_RD     ;
     592   delete    READ_QUEUE_IN_NUM_REG_RD   ;
     593   delete    READ_QUEUE_IN_WRITE_RE     ;
     594   delete    READ_QUEUE_IN_NUM_REG_RE   ;
     595
     596   delete    READ_QUEUE_OUT_VAL         ;
     597   delete    READ_QUEUE_OUT_ACK         ;
     598   if(_param->_have_port_context_id   )
     599     delete    READ_QUEUE_OUT_CONTEXT_ID  ;
     600   if(_param->_have_port_front_end_id )
     601     delete    READ_QUEUE_OUT_FRONT_END_ID;
     602   if(_param->_have_port_ooo_engine_id )
     603     delete    READ_QUEUE_OUT_OOO_ENGINE_ID;
     604   if(_param->_have_port_rob_id       )
     605     delete    READ_QUEUE_OUT_ROB_ID      ;
     606   delete    READ_QUEUE_OUT_OPERATION   ;
     607   delete    READ_QUEUE_OUT_TYPE        ;
     608   delete    READ_QUEUE_OUT_HAS_IMMEDIAT;
     609   delete    READ_QUEUE_OUT_IMMEDIAT    ;
     610   delete    READ_QUEUE_OUT_READ_RA     ;
     611   delete    READ_QUEUE_OUT_NUM_REG_RA  ;
     612   delete    READ_QUEUE_OUT_DATA_RA_VAL ;
     613   delete    READ_QUEUE_OUT_DATA_RA     ;
     614   delete    READ_QUEUE_OUT_READ_RB     ;
     615   delete    READ_QUEUE_OUT_NUM_REG_RB  ;
     616   delete    READ_QUEUE_OUT_DATA_RB_VAL ;
     617   delete    READ_QUEUE_OUT_DATA_RB     ;
     618   delete    READ_QUEUE_OUT_READ_RC     ;
     619   delete    READ_QUEUE_OUT_NUM_REG_RC  ;
     620   delete    READ_QUEUE_OUT_DATA_RC_VAL ;
     621   delete    READ_QUEUE_OUT_DATA_RC     ;
     622   delete    READ_QUEUE_OUT_WRITE_RD    ;
     623   delete    READ_QUEUE_OUT_NUM_REG_RD  ;
     624   delete    READ_QUEUE_OUT_WRITE_RE    ;
     625   delete    READ_QUEUE_OUT_NUM_REG_RE  ;
     626
     627   delete [] GPR_READ_VAL     ;
     628   delete [] GPR_READ_ACK     ;
     629   delete [] GPR_READ_NUM_REG ;
     630   delete [] GPR_READ_DATA    ;
     631   delete [] GPR_READ_DATA_VAL;
     632   if(_param->_have_port_ooo_engine_id )
     633     delete [] GPR_READ_OOO_ENGINE_ID ;
     634
     635   delete [] SPR_READ_VAL     ;
     636   delete [] SPR_READ_ACK     ;
     637   delete [] SPR_READ_NUM_REG ;
     638   delete [] SPR_READ_DATA    ;
     639   delete [] SPR_READ_DATA_VAL;
     640   if(_param->_have_port_ooo_engine_id )
     641     delete [] SPR_READ_OOO_ENGINE_ID ;
     642
     643   delete [] GPR_WRITE_VAL        ;
     644   if(_param->_have_port_ooo_engine_id )
     645     delete [] GPR_WRITE_OOO_ENGINE_ID ;
     646   delete [] GPR_WRITE_NUM_REG    ;
     647   delete [] GPR_WRITE_DATA       ;
     648
     649   delete [] SPR_WRITE_VAL        ;
     650   if(_param->_have_port_ooo_engine_id )
     651     delete [] SPR_WRITE_OOO_ENGINE_ID ;
     652   delete [] SPR_WRITE_NUM_REG    ;
     653   delete [] SPR_WRITE_DATA       ;
    609654#endif
    610655

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/include/Parameters.h

    r66 r68  
    5353  public : const uint32_t    _size_type            ;
    5454
     55  public : const bool        _have_port_context_id   ;
     56  public : const bool        _have_port_front_end_id ;
     57  public : const bool        _have_port_ooo_engine_id;
     58  public : const bool        _have_port_rob_id       ;
     59
     60  public : const uint32_t    _size_internal_queue;
     61
    5562    //-----[ methods ]-----------------------------------------------------------
    5663  public : Parameters  (uint32_t size_queue         ,

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Parameters.cpp

    r66 r68  
    5454    _size_special_register (static_cast<uint32_t>(log2(_nb_special_register))),
    5555    _size_operation        (static_cast<uint32_t>(log2(_nb_operation       ))),
    56     _size_type             (static_cast<uint32_t>(log2(_nb_type            )))
     56    _size_type             (static_cast<uint32_t>(log2(_nb_type            ))),
     57
     58    _have_port_context_id    (_size_context_id    > 0),
     59    _have_port_front_end_id  (_size_front_end_id  > 0),
     60    _have_port_ooo_engine_id (_size_ooo_engine_id > 0),
     61    _have_port_rob_id        (_size_rob_id        > 0),
     62
     63    _size_internal_queue     (  _size_context_id       //_context_id   
     64                              + _size_front_end_id     //_front_end_id
     65                              + _size_ooo_engine_id    //_ooo_engine_id
     66                              + _size_rob_id           //_rob_id       
     67                              + _size_operation        //_operation   
     68                              + _size_type             //_type         
     69                              + 1                      //_has_immediat
     70                              + _size_general_data     //_immediat     
     71                              + 1                      //_read_ra     
     72                              + _size_general_register //_num_reg_ra   
     73                              + 1                      //_read_rb     
     74                              + _size_general_register //_num_reg_rb   
     75                              + 1                      //_read_rc     
     76                              + _size_special_register //_num_reg_rc   
     77                              + 1                      //_write_rd     
     78                              + _size_general_register //_num_reg_rd   
     79                              + 1                      //_write_re     
     80                              + _size_special_register //_num_reg_re   
     81                                )
     82                               
     83
    5784  {
    5885    log_printf(FUNC,Read_queue,"Parameters","Begin");
    … …  
    85112    _size_special_register (param._size_special_register ),
    86113    _size_operation        (param._size_operation        ),
    87     _size_type             (param._size_type             )
     114    _size_type             (param._size_type             ),
     115
     116    _have_port_context_id    (param._have_port_context_id   ),
     117    _have_port_front_end_id  (param._have_port_front_end_id ),
     118    _have_port_ooo_engine_id (param._have_port_ooo_engine_id),
     119    _have_port_rob_id        (param._have_port_rob_id       ),
     120
     121    _size_internal_queue     (param._size_internal_queue    )
    88122  {
    89123    log_printf(FUNC,Read_queue,"Parameters (copy)","Begin");

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Parameters_msg_error.cpp

    r66 r68  
    2626    string msg = "";
    2727
    28     if (_size_queue < 2)
     28//     if (_size_queue < 2)
     29//       {
     30//         msg += "  - The read_queue must be have less a depth of 2";
     31//         msg += "    * size_queue                      : " + toString(_size_queue)    + "\n";
     32//       }
     33
     34    if (_nb_type < 2)
    2935      {
    30         msg += "  - The read_queue must be have less a depth of 2";
    31         msg += "    * size_queue                      : " + toString(_size_queue)    + "\n";
     36        msg += "  - The number of type must be > 1";
     37      }
     38    if (_nb_operation < 2)
     39      {
     40        msg += "  - The number of operation must be > 1";
    3241      }
    3342   

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue.cpp

    r66 r68  
    7777      sensitive << *(in_SPR_READ_ACK      [i]);
    7878    for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
    79       sensitive << *(in_GPR_WRITE_VAL        [i])
    80                 << *(in_GPR_WRITE_OOO_ENGINE_ID [i])
    81                 << *(in_GPR_WRITE_NUM_REG    [i]);
     79      {
     80        if (_param->_have_port_ooo_engine_id)
     81          sensitive << *(in_GPR_WRITE_OOO_ENGINE_ID [i]);
     82
     83        sensitive << *(in_GPR_WRITE_VAL        [i])
     84                  << *(in_GPR_WRITE_NUM_REG    [i]);
     85      }
    8286    for (uint32_t i=0; i<_param->_nb_spr_write; i++)
    83       sensitive << *(in_SPR_WRITE_VAL        [i])
    84                 << *(in_SPR_WRITE_OOO_ENGINE_ID [i])
    85                 << *(in_SPR_WRITE_NUM_REG    [i]);
    86 
     87      {
     88        if (_param->_have_port_ooo_engine_id)
     89          sensitive << *(in_SPR_WRITE_OOO_ENGINE_ID [i]);
     90        sensitive << *(in_SPR_WRITE_VAL        [i])
     91                 
     92                  << *(in_SPR_WRITE_NUM_REG    [i]);
     93      }
    8794#ifdef SYSTEMCASS_SPECIFIC
    8895    // List dependency information
    … …  
    94101      {
    95102        (*(out_READ_QUEUE_OUT_VAL)) (*(in_GPR_WRITE_VAL        [i]));
     103        if (_param->_have_port_ooo_engine_id)
    96104        (*(out_READ_QUEUE_OUT_VAL)) (*(in_GPR_WRITE_OOO_ENGINE_ID [i]));
    97105        (*(out_READ_QUEUE_OUT_VAL)) (*(in_GPR_WRITE_NUM_REG    [i]));
    … …  
    100108      {
    101109        (*(out_READ_QUEUE_OUT_VAL)) (*(in_SPR_WRITE_VAL        [i]));
     110        if (_param->_have_port_ooo_engine_id)
    102111        (*(out_READ_QUEUE_OUT_VAL)) (*(in_SPR_WRITE_OOO_ENGINE_ID [i]));
    103112        (*(out_READ_QUEUE_OUT_VAL)) (*(in_SPR_WRITE_NUM_REG    [i]));
    … …  
    115124                << *(in_GPR_READ_DATA_VAL [i]);
    116125    for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
    117       sensitive << *(in_GPR_WRITE_VAL        [i])
    118                 << *(in_GPR_WRITE_OOO_ENGINE_ID [i])
    119                 << *(in_GPR_WRITE_NUM_REG    [i])
    120                 << *(in_GPR_WRITE_DATA       [i]);
    121 
     126      {
     127        if (_param->_have_port_ooo_engine_id)
     128          sensitive << *(in_GPR_WRITE_OOO_ENGINE_ID [i]);
     129        sensitive << *(in_GPR_WRITE_VAL        [i])
     130                  << *(in_GPR_WRITE_NUM_REG    [i])
     131                  << *(in_GPR_WRITE_DATA       [i]);
     132      }
    122133#ifdef SYSTEMCASS_SPECIFIC
    123134    // List dependency information
    … …  
    134145      {
    135146        (*(out_READ_QUEUE_OUT_DATA_RA_VAL)) (*(in_GPR_WRITE_VAL        [i]));
    136         (*(out_READ_QUEUE_OUT_DATA_RA_VAL)) (*(in_GPR_WRITE_OOO_ENGINE_ID [i]));
     147        if (_param->_have_port_ooo_engine_id)
     148          (*(out_READ_QUEUE_OUT_DATA_RA_VAL)) (*(in_GPR_WRITE_OOO_ENGINE_ID [i]));
    137149        (*(out_READ_QUEUE_OUT_DATA_RA_VAL)) (*(in_GPR_WRITE_NUM_REG    [i]));
    138150        (*(out_READ_QUEUE_OUT_DATA_RB_VAL)) (*(in_GPR_WRITE_VAL        [i]));
    139         (*(out_READ_QUEUE_OUT_DATA_RB_VAL)) (*(in_GPR_WRITE_OOO_ENGINE_ID [i]));
     151        if (_param->_have_port_ooo_engine_id)
     152          (*(out_READ_QUEUE_OUT_DATA_RB_VAL)) (*(in_GPR_WRITE_OOO_ENGINE_ID [i]));
    140153        (*(out_READ_QUEUE_OUT_DATA_RB_VAL)) (*(in_GPR_WRITE_NUM_REG    [i]));
    141154
    142155        (*(out_READ_QUEUE_OUT_DATA_RA    )) (*(in_GPR_WRITE_VAL        [i]));
    143         (*(out_READ_QUEUE_OUT_DATA_RA    )) (*(in_GPR_WRITE_OOO_ENGINE_ID [i]));
     156        if (_param->_have_port_ooo_engine_id)
     157          (*(out_READ_QUEUE_OUT_DATA_RA    )) (*(in_GPR_WRITE_OOO_ENGINE_ID [i]));
    144158        (*(out_READ_QUEUE_OUT_DATA_RA    )) (*(in_GPR_WRITE_NUM_REG    [i]));
    145159        (*(out_READ_QUEUE_OUT_DATA_RA    )) (*(in_GPR_WRITE_DATA       [i]));
    146160        (*(out_READ_QUEUE_OUT_DATA_RB    )) (*(in_GPR_WRITE_VAL        [i]));
    147         (*(out_READ_QUEUE_OUT_DATA_RB    )) (*(in_GPR_WRITE_OOO_ENGINE_ID [i]));
     161        if (_param->_have_port_ooo_engine_id)
     162          (*(out_READ_QUEUE_OUT_DATA_RB    )) (*(in_GPR_WRITE_OOO_ENGINE_ID [i]));
    148163        (*(out_READ_QUEUE_OUT_DATA_RB    )) (*(in_GPR_WRITE_NUM_REG    [i]));
    149164        (*(out_READ_QUEUE_OUT_DATA_RB    )) (*(in_GPR_WRITE_DATA       [i]));
    … …  
    161176                << *(in_SPR_READ_DATA_VAL [i]);
    162177    for (uint32_t i=0; i<_param->_nb_spr_write; i++)
    163       sensitive << *(in_SPR_WRITE_VAL        [i])
    164                 << *(in_SPR_WRITE_OOO_ENGINE_ID [i])
    165                 << *(in_SPR_WRITE_NUM_REG    [i])
    166                 << *(in_SPR_WRITE_DATA       [i]);
    167 
     178      {
     179        if (_param->_have_port_ooo_engine_id)
     180          sensitive << *(in_SPR_WRITE_OOO_ENGINE_ID [i]);
     181        sensitive << *(in_SPR_WRITE_VAL        [i])
     182                  << *(in_SPR_WRITE_NUM_REG    [i])
     183                  << *(in_SPR_WRITE_DATA       [i]);
     184      }
    168185#ifdef SYSTEMCASS_SPECIFIC
    169186    // List dependency information
    … …  
    177194      {
    178195        (*(out_READ_QUEUE_OUT_DATA_RC_VAL)) (*(in_SPR_WRITE_VAL        [i]));
    179         (*(out_READ_QUEUE_OUT_DATA_RC_VAL)) (*(in_SPR_WRITE_OOO_ENGINE_ID [i]));
     196        if (_param->_have_port_ooo_engine_id)
     197          (*(out_READ_QUEUE_OUT_DATA_RC_VAL)) (*(in_SPR_WRITE_OOO_ENGINE_ID [i]));
    180198        (*(out_READ_QUEUE_OUT_DATA_RC_VAL)) (*(in_SPR_WRITE_NUM_REG    [i]));
    181199
    182200        (*(out_READ_QUEUE_OUT_DATA_RC    )) (*(in_SPR_WRITE_VAL        [i]));
    183         (*(out_READ_QUEUE_OUT_DATA_RC    )) (*(in_SPR_WRITE_OOO_ENGINE_ID [i]));
     201        if (_param->_have_port_ooo_engine_id)
     202          (*(out_READ_QUEUE_OUT_DATA_RC    )) (*(in_SPR_WRITE_OOO_ENGINE_ID [i]));
    184203        (*(out_READ_QUEUE_OUT_DATA_RC    )) (*(in_SPR_WRITE_NUM_REG    [i]));
    185204        (*(out_READ_QUEUE_OUT_DATA_RC    )) (*(in_SPR_WRITE_DATA       [i]));

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_allocation.cpp

    r66 r68  
    5959#endif
    6060                                                              );
    61      
     61
    6262       in_READ_QUEUE_IN_VAL            = interface->set_signal_valack_in        ("val"    , VAL);
    6363      out_READ_QUEUE_IN_ACK            = interface->set_signal_valack_out       ("ack"    , ACK);
     64      if(_param->_have_port_context_id  )
    6465       in_READ_QUEUE_IN_CONTEXT_ID     = interface->set_signal_in  <Tcontext_t        > ("context_id"   ,_param->_size_context_id       );
     66      if(_param->_have_port_front_end_id)
    6567       in_READ_QUEUE_IN_FRONT_END_ID   = interface->set_signal_in  <Tcontext_t        > ("front_end_id" ,_param->_size_front_end_id     );
    66        in_READ_QUEUE_IN_OOO_ENGINE_ID  = interface->set_signal_in  <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id    );
     68       if(_param->_have_port_ooo_engine_id)
     69         in_READ_QUEUE_IN_OOO_ENGINE_ID  = interface->set_signal_in  <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id    );
     70      if(_param->_have_port_rob_id      )
    6771       in_READ_QUEUE_IN_ROB_ID         = interface->set_signal_in  <Tpacket_t         > ("rob_id"      ,_param->_size_rob_id           );
    6872       in_READ_QUEUE_IN_OPERATION      = interface->set_signal_in  <Toperation_t      > ("operation"   ,_param->_size_operation        );
    … …  
    9599       in_READ_QUEUE_OUT_ACK            = interface->set_signal_valack_in        ("ack"    , ACK);
    96100
    97       out_READ_QUEUE_OUT_CONTEXT_ID     = interface->set_signal_out <Tcontext_t        > ("context_id"   ,_param->_size_context_id       );
    98       out_READ_QUEUE_OUT_FRONT_END_ID   = interface->set_signal_out <Tcontext_t        > ("front_end_id" ,_param->_size_front_end_id     );
    99       out_READ_QUEUE_OUT_OOO_ENGINE_ID  = interface->set_signal_out <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id    );
    100       out_READ_QUEUE_OUT_ROB_ID         = interface->set_signal_out <Tpacket_t         > ("rob_id"      ,_param->_size_rob_id           );
     101      if(_param->_have_port_context_id  )
     102        out_READ_QUEUE_OUT_CONTEXT_ID     = interface->set_signal_out <Tcontext_t        > ("context_id"   ,_param->_size_context_id       );
     103      if(_param->_have_port_front_end_id)
     104        out_READ_QUEUE_OUT_FRONT_END_ID   = interface->set_signal_out <Tcontext_t        > ("front_end_id" ,_param->_size_front_end_id     );
     105      if(_param->_have_port_ooo_engine_id)
     106        out_READ_QUEUE_OUT_OOO_ENGINE_ID  = interface->set_signal_out <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id    );
     107      if(_param->_have_port_rob_id      )
     108        out_READ_QUEUE_OUT_ROB_ID         = interface->set_signal_out <Tpacket_t         > ("rob_id"      ,_param->_size_rob_id           );
    101109      out_READ_QUEUE_OUT_OPERATION      = interface->set_signal_out <Toperation_t      > ("operation"   ,_param->_size_operation        );
    102110      out_READ_QUEUE_OUT_TYPE           = interface->set_signal_out <Ttype_t           > ("type"        ,_param->_size_type             );
    … …  
    125133    out_GPR_READ_VAL          = new SC_OUT(Tcontrol_t        ) * [_param->_nb_gpr_read];
    126134     in_GPR_READ_ACK          = new SC_IN (Tcontrol_t        ) * [_param->_nb_gpr_read];
    127     out_GPR_READ_OOO_ENGINE_ID= new SC_OUT(Tcontext_t        ) * [_param->_nb_gpr_read];
     135    if(_param->_have_port_ooo_engine_id)
     136      out_GPR_READ_OOO_ENGINE_ID= new SC_OUT(Tcontext_t        ) * [_param->_nb_gpr_read];
    128137    out_GPR_READ_NUM_REG      = new SC_OUT(Tgeneral_address_t) * [_param->_nb_gpr_read];
    129138     in_GPR_READ_DATA         = new SC_IN (Tgeneral_data_t   ) * [_param->_nb_gpr_read];
    … …  
    142151        out_GPR_READ_VAL           [i] = interface->set_signal_valack_out       ("val"    , VAL);
    143152         in_GPR_READ_ACK           [i] = interface->set_signal_valack_in        ("ack"    , ACK);
    144         out_GPR_READ_OOO_ENGINE_ID [i] = interface->set_signal_out <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id);
     153        if(_param->_have_port_ooo_engine_id)
     154          out_GPR_READ_OOO_ENGINE_ID [i] = interface->set_signal_out <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id);
    145155        out_GPR_READ_NUM_REG       [i] = interface->set_signal_out <Tgeneral_address_t> ("num_reg"  ,_param->_size_general_register);
    146156         in_GPR_READ_DATA          [i] = interface->set_signal_in  <Tgeneral_data_t   > ("data"     ,_param->_size_general_data);
    … …  
    152162    out_SPR_READ_VAL          = new SC_OUT(Tcontrol_t        ) * [_param->_nb_spr_read];
    153163     in_SPR_READ_ACK          = new SC_IN (Tcontrol_t        ) * [_param->_nb_spr_read];
    154     out_SPR_READ_OOO_ENGINE_ID= new SC_OUT(Tcontext_t        ) * [_param->_nb_spr_read];
     164    if(_param->_have_port_ooo_engine_id)
     165      out_SPR_READ_OOO_ENGINE_ID= new SC_OUT(Tcontext_t        ) * [_param->_nb_spr_read];
    155166    out_SPR_READ_NUM_REG      = new SC_OUT(Tspecial_address_t) * [_param->_nb_spr_read];
    156167     in_SPR_READ_DATA         = new SC_IN (Tspecial_data_t   ) * [_param->_nb_spr_read];
    … …  
    169180        out_SPR_READ_VAL           [i] = interface->set_signal_valack_out       ("val"    , VAL);
    170181         in_SPR_READ_ACK           [i] = interface->set_signal_valack_in        ("ack"    , ACK);
    171         out_SPR_READ_OOO_ENGINE_ID [i] = interface->set_signal_out <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id);
     182        if(_param->_have_port_ooo_engine_id)
     183          out_SPR_READ_OOO_ENGINE_ID [i] = interface->set_signal_out <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id);
    172184        out_SPR_READ_NUM_REG       [i] = interface->set_signal_out <Tspecial_address_t> ("num_reg"   ,_param->_size_special_register);
    173185         in_SPR_READ_DATA          [i] = interface->set_signal_in  <Tspecial_data_t   > ("data"      ,_param->_size_special_data);
    … …  
    178190   
    179191     in_GPR_WRITE_VAL          = new SC_IN (Tcontrol_t        ) * [_param->_nb_gpr_write];
    180      in_GPR_WRITE_OOO_ENGINE_ID= new SC_IN (Tcontext_t        ) * [_param->_nb_gpr_write];
     192     if(_param->_have_port_ooo_engine_id)
     193       in_GPR_WRITE_OOO_ENGINE_ID= new SC_IN (Tcontext_t        ) * [_param->_nb_gpr_write];
    181194     in_GPR_WRITE_NUM_REG      = new SC_IN (Tgeneral_address_t) * [_param->_nb_gpr_write];
    182195     in_GPR_WRITE_DATA         = new SC_IN (Tgeneral_data_t   ) * [_param->_nb_gpr_write];
    … …  
    193206
    194207         in_GPR_WRITE_VAL           [i] = interface->set_signal_valack_in        ("val"    , VAL);
    195          in_GPR_WRITE_OOO_ENGINE_ID [i] = interface->set_signal_in  <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id);
     208         if(_param->_have_port_ooo_engine_id)
     209           in_GPR_WRITE_OOO_ENGINE_ID [i] = interface->set_signal_in  <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id);
    196210         in_GPR_WRITE_NUM_REG       [i] = interface->set_signal_in  <Tgeneral_address_t> ("num_reg"   ,_param->_size_general_register);
    197211         in_GPR_WRITE_DATA          [i] = interface->set_signal_in  <Tgeneral_data_t   > ("data"      ,_param->_size_general_data);
    … …  
    201215   
    202216     in_SPR_WRITE_VAL          = new SC_IN (Tcontrol_t        ) * [_param->_nb_spr_write];
    203      in_SPR_WRITE_OOO_ENGINE_ID= new SC_IN (Tcontext_t        ) * [_param->_nb_spr_write];
     217     if(_param->_have_port_ooo_engine_id)
     218       in_SPR_WRITE_OOO_ENGINE_ID= new SC_IN (Tcontext_t        ) * [_param->_nb_spr_write];
    204219     in_SPR_WRITE_NUM_REG      = new SC_IN (Tspecial_address_t) * [_param->_nb_spr_write];
    205220     in_SPR_WRITE_DATA         = new SC_IN (Tspecial_data_t   ) * [_param->_nb_spr_write];
    … …  
    216231
    217232         in_SPR_WRITE_VAL           [i] = interface->set_signal_valack_in ("val"    , VAL);
    218          in_SPR_WRITE_OOO_ENGINE_ID [i] = interface->set_signal_in  <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id);
     233         if(_param->_have_port_ooo_engine_id)
     234           in_SPR_WRITE_OOO_ENGINE_ID [i] = interface->set_signal_in  <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id);
    219235         in_SPR_WRITE_NUM_REG       [i] = interface->set_signal_in  <Tspecial_address_t> ("num_reg"   ,_param->_size_special_register);
    220236         in_SPR_WRITE_DATA          [i] = interface->set_signal_in  <Tspecial_data_t   > ("data"      ,_param->_size_special_data);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_deallocation.cpp

    r66 r68  
    3030    delete     in_READ_QUEUE_IN_VAL            ;
    3131    delete    out_READ_QUEUE_IN_ACK            ;
    32     delete     in_READ_QUEUE_IN_CONTEXT_ID     ;
    33     delete     in_READ_QUEUE_IN_FRONT_END_ID   ;
    34     delete     in_READ_QUEUE_IN_OOO_ENGINE_ID  ;
    35     delete     in_READ_QUEUE_IN_ROB_ID         ;
     32
     33    if(_param->_have_port_context_id   )
     34      delete     in_READ_QUEUE_IN_CONTEXT_ID     ;
     35    if(_param->_have_port_front_end_id )
     36      delete     in_READ_QUEUE_IN_FRONT_END_ID   ;
     37    if(_param->_have_port_ooo_engine_id)
     38      delete     in_READ_QUEUE_IN_OOO_ENGINE_ID  ;
     39    if(_param->_have_port_rob_id       )
     40      delete     in_READ_QUEUE_IN_ROB_ID         ;
    3641    delete     in_READ_QUEUE_IN_OPERATION      ;
    3742    delete     in_READ_QUEUE_IN_TYPE           ;
    … …  
    5257    delete    out_READ_QUEUE_OUT_VAL            ;
    5358    delete     in_READ_QUEUE_OUT_ACK            ;
    54     delete    out_READ_QUEUE_OUT_CONTEXT_ID     ;
    55     delete    out_READ_QUEUE_OUT_FRONT_END_ID   ;
    56     delete    out_READ_QUEUE_OUT_OOO_ENGINE_ID  ;
    57     delete    out_READ_QUEUE_OUT_ROB_ID         ;
     59
     60    if(_param->_have_port_context_id   )
     61      delete    out_READ_QUEUE_OUT_CONTEXT_ID     ;
     62    if(_param->_have_port_front_end_id )
     63      delete    out_READ_QUEUE_OUT_FRONT_END_ID   ;
     64    if(_param->_have_port_ooo_engine_id)
     65      delete    out_READ_QUEUE_OUT_OOO_ENGINE_ID  ;
     66    if(_param->_have_port_rob_id       )
     67      delete    out_READ_QUEUE_OUT_ROB_ID         ;
    5868    delete    out_READ_QUEUE_OUT_OPERATION      ;
    5969    delete    out_READ_QUEUE_OUT_TYPE           ;
    … …  
    8191    delete [] out_GPR_READ_VAL       ;
    8292    delete []  in_GPR_READ_ACK       ;
    83     delete [] out_GPR_READ_OOO_ENGINE_ID;
     93    if(_param->_have_port_ooo_engine_id)
     94      delete [] out_GPR_READ_OOO_ENGINE_ID;
    8495    delete [] out_GPR_READ_NUM_REG   ;
    8596    delete []  in_GPR_READ_DATA      ;
    … …  
    90101    delete [] out_SPR_READ_VAL       ;
    91102    delete []  in_SPR_READ_ACK       ;
    92     delete [] out_SPR_READ_OOO_ENGINE_ID;
     103    if(_param->_have_port_ooo_engine_id)
     104      delete [] out_SPR_READ_OOO_ENGINE_ID;
    93105    delete [] out_SPR_READ_NUM_REG   ;
    94106    delete []  in_SPR_READ_DATA      ;
    … …  
    98110   
    99111    delete []  in_GPR_WRITE_VAL       ;
    100     delete []  in_GPR_WRITE_OOO_ENGINE_ID;
     112    if(_param->_have_port_ooo_engine_id)
     113      delete []  in_GPR_WRITE_OOO_ENGINE_ID;
    101114    delete []  in_GPR_WRITE_NUM_REG   ;
    102115    delete []  in_GPR_WRITE_DATA      ;
    … …  
    105118   
    106119    delete []  in_SPR_WRITE_VAL       ;
    107     delete []  in_SPR_WRITE_OOO_ENGINE_ID;
     120    if(_param->_have_port_ooo_engine_id)
     121      delete []  in_SPR_WRITE_OOO_ENGINE_ID;
    108122    delete []  in_SPR_WRITE_NUM_REG   ;
    109123    delete []  in_SPR_WRITE_DATA      ;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_genMealy_read_queue_out_gpr.cpp

    r66 r68  
    6565    for (uint32_t i=0; i<_param->_nb_gpr_write ; i++)
    6666      {
     67        bool cmp;
     68
     69        if (_param->_have_port_ooo_engine_id)
     70          cmp = (PORT_READ (in_GPR_WRITE_OOO_ENGINE_ID [i]) == _queue_head->_ooo_engine_id);
     71        else
     72          cmp = true;
     73
    6774        // Test if this bypass is valid
    68         if ( (PORT_READ (in_GPR_WRITE_VAL           [i]) == 1) and
    69              (PORT_READ (in_GPR_WRITE_OOO_ENGINE_ID [i]) == _queue_head->_ooo_engine_id)
    70              )
     75        if ( (PORT_READ (in_GPR_WRITE_VAL [i]) == 1) and cmp)
    7176          {
    7277            Tgeneral_address_t gpr_write_num_reg = PORT_READ(in_GPR_WRITE_NUM_REG [i]);
    … …  
    7883
    7984                internal_READ_QUEUE_OUT_DATA_RA_VAL = 1;
     85#ifdef SYSTEMC_VHDL_COMPATIBILITY
     86                if (_queue_head->_read_ra == 1)
     87#endif
    8088                internal_READ_QUEUE_OUT_DATA_RA     = gpr_write_data;
    8189              }
    … …  
    8492                log_printf(TRACE,Read_queue,FUNCTION," * internal_READ_QUEUE_OUT_DATA_RB_VAL   - bypass hit (%d)",i);
    8593                internal_READ_QUEUE_OUT_DATA_RB_VAL = 1;
     94#ifdef SYSTEMC_VHDL_COMPATIBILITY
     95                if (_queue_head->_read_rb == 1)
     96#endif
    8697                internal_READ_QUEUE_OUT_DATA_RB     = gpr_write_data;
    8798              }

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_genMealy_read_queue_out_spr.cpp

    r66 r68  
    4545                                           PORT_READ(in_SPR_READ_DATA [0]));
    4646
    47 //     cout << "yo1 : " << internal_READ_QUEUE_OUT_DATA_RC << endl;
    48 
    4947    // Test all bypass
    5048    for (uint32_t i=0; i<_param->_nb_spr_write ; i++)
    5149      {
     50        bool cmp;
     51
     52        if (_param->_have_port_ooo_engine_id)
     53          cmp = (PORT_READ (in_SPR_WRITE_OOO_ENGINE_ID [i]) == _queue_head->_ooo_engine_id);
     54        else
     55          cmp = true;
     56           
    5257        // Test if this bypass is valid
    53         if ( (PORT_READ (in_SPR_WRITE_VAL           [i]) == 1) and
    54              (PORT_READ (in_SPR_WRITE_OOO_ENGINE_ID [i]) == _queue_head->_ooo_engine_id)
    55              )
     58        if ( (PORT_READ (in_SPR_WRITE_VAL [i]) == 1) and cmp)
    5659          {
    5760            if (_queue_head->_num_reg_rc == PORT_READ(in_SPR_WRITE_NUM_REG [i]))
    … …  
    5962                log_printf(TRACE,Read_queue,FUNCTION," * internal_READ_QUEUE_OUT_DATA_RC_VAL   - bypass hit (%d)",i);
    6063                internal_READ_QUEUE_OUT_DATA_RC_VAL = 1;
     64#ifdef SYSTEMC_VHDL_COMPATIBILITY
     65                if (_queue_head->_read_rc == 1)
     66#endif
    6167                internal_READ_QUEUE_OUT_DATA_RC     = PORT_READ(in_SPR_WRITE_DATA [i]);
    6268              }
    6369          }
    6470      }
    65 
    66 //     cout << "yo2 : " << internal_READ_QUEUE_OUT_DATA_RC << endl;
    6771
    6872    // Affectation out port

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_genMealy_read_queue_out_val.cpp

    r66 r68  
    4141    for (uint32_t i=0; i<_param->_nb_gpr_write ; i++)
    4242      {
     43        bool cmp;
     44
     45        if (_param->_have_port_ooo_engine_id)
     46          cmp = (PORT_READ (in_GPR_WRITE_OOO_ENGINE_ID [i]) == _queue_head->_ooo_engine_id);
     47        else
     48          cmp = true;
     49       
    4350        // Test if this bypass is valid
    44         if ( (PORT_READ (in_GPR_WRITE_VAL           [i]) == 1) and
    45              (PORT_READ (in_GPR_WRITE_OOO_ENGINE_ID [i]) == _queue_head->_ooo_engine_id)
    46              )
     51        if ((PORT_READ (in_GPR_WRITE_VAL           [i]) == 1) and cmp)
    4752          {
    4853            Tgeneral_address_t gpr_write_num_reg = PORT_READ(in_GPR_WRITE_NUM_REG [i]);
    … …  
    5863    for (uint32_t i=0; i<_param->_nb_spr_write ; i++)
    5964      {
     65        bool cmp;
     66
     67        if (_param->_have_port_ooo_engine_id)
     68          cmp = (PORT_READ (in_SPR_WRITE_OOO_ENGINE_ID [i]) == _queue_head->_ooo_engine_id);
     69        else
     70          cmp = true;
     71       
    6072        // Test if this bypass is valid
    61         if ( (PORT_READ (in_SPR_WRITE_VAL           [i]) == 1) and
    62              (PORT_READ (in_SPR_WRITE_OOO_ENGINE_ID [i]) == _queue_head->_ooo_engine_id)
    63              )
     73        if ((PORT_READ (in_SPR_WRITE_VAL           [i]) == 1) and cmp)
    6474          {
    6575            Tspecial_address_t spr_write_num_reg = PORT_READ(in_SPR_WRITE_NUM_REG [i]);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_genMoore.cpp

    r66 r68  
    3131
    3232    // ~~~~~[ Interface "read_queue_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    33 //  PORT_WRITE (out_READ_QUEUE_OUT_VAL         , not_empty    );              // in genMealy_val
    34 
    35     PORT_WRITE (out_READ_QUEUE_OUT_CONTEXT_ID   , _queue_head->_context_id  );
    36     PORT_WRITE (out_READ_QUEUE_OUT_FRONT_END_ID , _queue_head->_front_end_id);
    37     PORT_WRITE (out_READ_QUEUE_OUT_OOO_ENGINE_ID, _queue_head->_ooo_engine_id);
    38     PORT_WRITE (out_READ_QUEUE_OUT_ROB_ID      , _queue_head->_rob_id      );
     33    //  PORT_WRITE (out_READ_QUEUE_OUT_VAL         , not_empty    );              // in genMealy_val
     34   
     35    if(_param->_have_port_context_id   )
     36      PORT_WRITE (out_READ_QUEUE_OUT_CONTEXT_ID   , _queue_head->_context_id  );
     37    if(_param->_have_port_front_end_id )
     38      PORT_WRITE (out_READ_QUEUE_OUT_FRONT_END_ID , _queue_head->_front_end_id);
     39    if(_param->_have_port_ooo_engine_id)
     40      PORT_WRITE (out_READ_QUEUE_OUT_OOO_ENGINE_ID, _queue_head->_ooo_engine_id);
     41    if(_param->_have_port_rob_id       )
     42      PORT_WRITE (out_READ_QUEUE_OUT_ROB_ID      , _queue_head->_rob_id      );
    3943    PORT_WRITE (out_READ_QUEUE_OUT_OPERATION   , _queue_head->_operation   );
    4044    PORT_WRITE (out_READ_QUEUE_OUT_TYPE        , _queue_head->_type        );
    … …  
    6165    PORT_WRITE (out_GPR_READ_VAL           [0], not_empty and _queue_head->_read_ra_val);
    6266    PORT_WRITE (out_GPR_READ_VAL           [1], not_empty and _queue_head->_read_rb_val);
    63     PORT_WRITE (out_GPR_READ_OOO_ENGINE_ID [0],               _queue_head->_ooo_engine_id);
    64     PORT_WRITE (out_GPR_READ_OOO_ENGINE_ID [1],               _queue_head->_ooo_engine_id);
     67    if(_param->_have_port_ooo_engine_id)
     68      {
     69        PORT_WRITE (out_GPR_READ_OOO_ENGINE_ID [0],               _queue_head->_ooo_engine_id);
     70        PORT_WRITE (out_GPR_READ_OOO_ENGINE_ID [1],               _queue_head->_ooo_engine_id);
     71      }
    6572    PORT_WRITE (out_GPR_READ_NUM_REG       [0],               _queue_head->_num_reg_ra);
    6673    PORT_WRITE (out_GPR_READ_NUM_REG       [1],               _queue_head->_num_reg_rb);
    … …  
    6875    // ~~~~~[ Interface "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    6976    PORT_WRITE (out_SPR_READ_VAL           [0], not_empty and _queue_head->_read_rc_val);
    70     PORT_WRITE (out_SPR_READ_OOO_ENGINE_ID [0],               _queue_head->_ooo_engine_id);
     77    if(_param->_have_port_ooo_engine_id)
     78      PORT_WRITE (out_SPR_READ_OOO_ENGINE_ID [0],               _queue_head->_ooo_engine_id);
    7179    PORT_WRITE (out_SPR_READ_NUM_REG       [0],               _queue_head->_num_reg_rc);
    7280                   

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_transition.cpp

    r66 r68  
    4949        bool not_full      = not (_queue->size() == _param->_size_queue);
    5050        bool     empty     =     _queue->empty();
    51         bool nead_new_head = false;
     51        bool need_new_head = false;
    5252       
    5353        log_printf(TRACE,Read_queue,FUNCTION," * test transaction READ_QUEUE_IN  : %d,%d",PORT_READ(in_READ_QUEUE_IN_VAL), not_full);
    … …  
    5656            Tread_queue_entry_t * entry = new Tread_queue_entry_t;
    5757
    58             entry->_context_id   = PORT_READ(in_READ_QUEUE_IN_CONTEXT_ID  );
    59             entry->_front_end_id = PORT_READ(in_READ_QUEUE_IN_FRONT_END_ID);
    60             entry->_ooo_engine_id= PORT_READ(in_READ_QUEUE_IN_OOO_ENGINE_ID);
    61             entry->_rob_id       = PORT_READ(in_READ_QUEUE_IN_ROB_ID      );
     58            if(_param->_have_port_context_id   )
     59              entry->_context_id   = PORT_READ(in_READ_QUEUE_IN_CONTEXT_ID  );
     60            if(_param->_have_port_front_end_id )
     61              entry->_front_end_id = PORT_READ(in_READ_QUEUE_IN_FRONT_END_ID);
     62            if(_param->_have_port_ooo_engine_id)
     63              entry->_ooo_engine_id= PORT_READ(in_READ_QUEUE_IN_OOO_ENGINE_ID);
     64            if(_param->_have_port_rob_id       )
     65              entry->_rob_id       = PORT_READ(in_READ_QUEUE_IN_ROB_ID      );
    6266            entry->_operation    = PORT_READ(in_READ_QUEUE_IN_OPERATION   );
    6367            entry->_type         = PORT_READ(in_READ_QUEUE_IN_TYPE        );
    … …  
    8387              {
    8488                log_printf(TRACE,Read_queue,FUNCTION,"     * queue was    empty");
    85                 nead_new_head = true;
     89                need_new_head = true;
    8690              }
    8791          }
    … …  
    100104              {
    101105                log_printf(TRACE,Read_queue,FUNCTION,"     * queue was not empty");
    102                 nead_new_head = true;
     106                need_new_head = true;
    103107              }
    104108          }
    … …  
    119123          }
    120124
    121         if (nead_new_head == true)
     125        if (need_new_head == true)
    122126          {
    123127            log_printf(TRACE,Read_queue,FUNCTION," * new head");

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_vhdl.cpp

    r54 r68  
    88
    99#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/include/Read_queue.h"
     10#include "Behavioural/Generic/Queue/include/Queue.h"
    1011#include "Behavioural/include/Vhdl.h"
    1112
    … …  
    2324  {
    2425    log_printf(FUNC,Read_queue,"vhdl","Begin");
     26   
     27    //----- Queue -----
     28   
     29    morpheo::behavioural::generic::queue::Parameters * param_queue;
     30    morpheo::behavioural::generic::queue::Queue      * queue;
     31   
     32    param_queue = new morpheo::behavioural::generic::queue::Parameters
     33      (_param->_size_queue,
     34       _param->_size_internal_queue
     35       );
     36   
     37    string queue_name = _name + "_queue";
     38    queue = new morpheo::behavioural::generic::queue::Queue
     39      (queue_name.c_str()
     40#ifdef STATISTICS
     41       ,NULL
     42#endif
     43       ,param_queue
     44       ,USE_VHDL);
     45   
     46    _component->set_component(queue->_component
     47#ifdef POSITION
     48                              , 0, 0, 0, 0
     49#endif
     50                              , INSTANCE_LIBRARY
     51                              );
     52
    2553
    2654    Vhdl * vhdl = new Vhdl (_name);
    … …  
    3563
    3664    delete vhdl;
     65    delete param_queue;
     66    delete queue;
    3767
    3868    log_printf(FUNC,Read_queue,"vhdl","End");

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_vhdl_body.cpp

    r54 r68  
    2323    log_printf(FUNC,Read_queue,"vhdl_body","Begin");
    2424    vhdl->set_body ("");
     25    vhdl->set_body("");
     26    vhdl->set_body("-----------------------------------");
     27    vhdl->set_body("-- Instance queue                  ");
     28    vhdl->set_body("-----------------------------------");
     29    vhdl->set_body("");
     30
     31    vhdl->set_body("instance_"+_name+"_queue : "+_name+"_queue");
     32    vhdl->set_body("port map (");
     33    vhdl->set_body("\t  in_CLOCK       \t=>\t      in_CLOCK ");
     34    vhdl->set_body("\t, in_NRESET      \t=>\t      in_NRESET");
     35    vhdl->set_body("\t, in_INSERT_VAL  \t=>\tinternal_QUEUE_INSERT_VAL");
     36    vhdl->set_body("\t,out_INSERT_ACK  \t=>\tinternal_QUEUE_INSERT_ACK");
     37    vhdl->set_body("\t, in_INSERT_DATA \t=>\tinternal_QUEUE_INSERT_DATA");
     38    vhdl->set_body("\t,out_RETIRE_VAL  \t=>\tinternal_QUEUE_RETIRE_VAL");
     39    vhdl->set_body("\t, in_RETIRE_ACK  \t=>\tinternal_QUEUE_RETIRE_ACK");
     40    vhdl->set_body("\t,out_RETIRE_DATA \t=>\tinternal_QUEUE_RETIRE_DATA");
     41    vhdl->set_body(");");
     42
     43    vhdl->set_body("");
     44    vhdl->set_body("-----------------------------------");
     45    vhdl->set_body("-- Queue_data                      ");
     46    vhdl->set_body("-----------------------------------");
     47    vhdl->set_body("");
     48   
     49    uint32_t min = 0;
     50    uint32_t max;
     51
     52    if(_param->_have_port_context_id   )
     53      {
     54        max = min-1+_param->_size_context_id;
     55        vhdl->set_body ("internal_QUEUE_INSERT_DATA"+std_logic_range(_param->_size_internal_queue,max,min)+" <= in_READ_QUEUE_IN_CONTEXT_ID;");
     56        min = max+1;
     57      }
     58    if(_param->_have_port_front_end_id   )
     59      {
     60        max = min-1+_param->_size_front_end_id;
     61        vhdl->set_body ("internal_QUEUE_INSERT_DATA"+std_logic_range(_param->_size_internal_queue,max,min)+" <= in_READ_QUEUE_IN_FRONT_END_ID;");
     62        min = max+1;
     63      }
     64    if(_param->_have_port_ooo_engine_id   )
     65      {
     66        max = min-1+_param->_size_ooo_engine_id;
     67        vhdl->set_body ("internal_QUEUE_INSERT_DATA"+std_logic_range(_param->_size_internal_queue,max,min)+" <= in_READ_QUEUE_IN_OOO_ENGINE_ID;");
     68        min = max+1;
     69      }
     70    if(_param->_have_port_rob_id   )
     71      {
     72        max = min-1+_param->_size_rob_id;
     73        vhdl->set_body ("internal_QUEUE_INSERT_DATA"+std_logic_range(_param->_size_internal_queue,max,min)+" <= in_READ_QUEUE_IN_ROB_ID;");
     74        min = max+1;
     75      }
     76
     77    max = min-1+_param->_size_operation;
     78    vhdl->set_body ("internal_QUEUE_INSERT_DATA"+std_logic_range(_param->_size_internal_queue,max,min)+" <= in_READ_QUEUE_IN_OPERATION;");
     79    min = max+1;
     80
     81    max = min-1+_param->_size_type;
     82    vhdl->set_body ("internal_QUEUE_INSERT_DATA"+std_logic_range(_param->_size_internal_queue,max,min)+" <= in_READ_QUEUE_IN_TYPE;");
     83    min = max+1;
     84
     85    max = min;
     86    vhdl->set_body ("internal_QUEUE_INSERT_DATA"+std_logic_range(_param->_size_internal_queue,max,min)+" <= in_READ_QUEUE_IN_HAS_IMMEDIAT;");
     87    min = max+1;
     88
     89    max = min-1+_param->_size_general_data;
     90    vhdl->set_body ("internal_QUEUE_INSERT_DATA"+std_logic_range(_param->_size_internal_queue,max,min)+" <= in_READ_QUEUE_IN_IMMEDIAT;");
     91    min = max+1;
     92
     93    max = min;
     94    vhdl->set_body ("internal_QUEUE_INSERT_DATA"+std_logic_range(_param->_size_internal_queue,max,min)+" <= in_READ_QUEUE_IN_READ_RA;");
     95    min = max+1;
     96
     97    max = min-1+_param->_size_general_register;
     98    vhdl->set_body ("internal_QUEUE_INSERT_DATA"+std_logic_range(_param->_size_internal_queue,max,min)+" <= in_READ_QUEUE_IN_NUM_REG_RA;");
     99    min = max+1;
     100
     101    max = min;
     102    vhdl->set_body ("internal_QUEUE_INSERT_DATA"+std_logic_range(_param->_size_internal_queue,max,min)+" <= in_READ_QUEUE_IN_READ_RB;");
     103    min = max+1;
     104
     105    max = min-1+_param->_size_general_register;
     106    vhdl->set_body ("internal_QUEUE_INSERT_DATA"+std_logic_range(_param->_size_internal_queue,max,min)+" <= in_READ_QUEUE_IN_NUM_REG_RB;");
     107    min = max+1;
     108
     109    max = min;
     110    vhdl->set_body ("internal_QUEUE_INSERT_DATA"+std_logic_range(_param->_size_internal_queue,max,min)+" <= in_READ_QUEUE_IN_READ_RC;");
     111    min = max+1;
     112
     113    max = min-1+_param->_size_special_register;
     114    vhdl->set_body ("internal_QUEUE_INSERT_DATA"+std_logic_range(_param->_size_internal_queue,max,min)+" <= in_READ_QUEUE_IN_NUM_REG_RC;");
     115    min = max+1;
     116
     117    max = min;
     118    vhdl->set_body ("internal_QUEUE_INSERT_DATA"+std_logic_range(_param->_size_internal_queue,max,min)+" <= in_READ_QUEUE_IN_WRITE_RD;");
     119    min = max+1;
     120
     121    max = min-1+_param->_size_general_register;
     122    vhdl->set_body ("internal_QUEUE_INSERT_DATA"+std_logic_range(_param->_size_internal_queue,max,min)+" <= in_READ_QUEUE_IN_NUM_REG_RD;");
     123    min = max+1;
     124
     125    max = min;
     126    vhdl->set_body ("internal_QUEUE_INSERT_DATA"+std_logic_range(_param->_size_internal_queue,max,min)+" <= in_READ_QUEUE_IN_WRITE_RE;");
     127    min = max+1;
     128
     129    max = min-1+_param->_size_special_register;
     130    vhdl->set_body ("internal_QUEUE_INSERT_DATA"+std_logic_range(_param->_size_internal_queue,max,min)+" <= in_READ_QUEUE_IN_NUM_REG_RE;");
     131    min = max+1;
     132
     133    vhdl->set_body ("internal_QUEUE_RETIRE_ACK <= internal_READ_QUEUE_OUT_VAL and in_READ_QUEUE_OUT_ACK;");
     134
     135    vhdl->set_body("");
     136    vhdl->set_body("-----------------------------------");
     137    vhdl->set_body("-- Interface read");
     138    vhdl->set_body("-----------------------------------");
     139    vhdl->set_body("");
     140    vhdl->set_body("-- GPR");
     141    vhdl->set_body ("out_GPR_READ_0_VAL           <= internal_QUEUE_RETIRE_VAL and internal_READ_RA_VAL;");
     142    vhdl->set_body ("out_GPR_READ_1_VAL           <= internal_QUEUE_RETIRE_VAL and internal_READ_RB_VAL;");
     143    if(_param->_have_port_ooo_engine_id)
     144      {
     145        vhdl->set_body ("out_GPR_READ_0_OOO_ENGINE_ID <= internal_OOO_ENGINE_ID;");
     146        vhdl->set_body ("out_GPR_READ_1_OOO_ENGINE_ID <= internal_OOO_ENGINE_ID;");
     147      }
     148    vhdl->set_body ("out_GPR_READ_0_NUM_REG       <= internal_NUM_REG_RA;");
     149    vhdl->set_body ("out_GPR_READ_1_NUM_REG       <= internal_NUM_REG_RB;");
     150    vhdl->set_body("");
     151   
     152    vhdl->set_body("-- SPR");
     153    vhdl->set_body ("out_SPR_READ_0_VAL           <= internal_QUEUE_RETIRE_VAL and internal_READ_RC_VAL;");
     154    if(_param->_have_port_ooo_engine_id)
     155      {
     156        vhdl->set_body ("out_SPR_READ_0_OOO_ENGINE_ID <= internal_OOO_ENGINE_ID;");
     157      }
     158    vhdl->set_body ("out_SPR_READ_0_NUM_REG       <= internal_NUM_REG_RC;");
     159
     160    vhdl->set_body("");
     161    vhdl->set_body("-----------------------------------");
     162    vhdl->set_body("-- Interface read_queue_out");
     163    vhdl->set_body("-----------------------------------");
     164    vhdl->set_body("");
     165   
     166    if(_param->_have_port_context_id   )
     167      vhdl->set_body ("out_READ_QUEUE_OUT_CONTEXT_ID    <= internal_CONTEXT_ID   ;");
     168    if(_param->_have_port_front_end_id   )
     169      vhdl->set_body ("out_READ_QUEUE_OUT_FRONT_END_ID  <= internal_FRONT_END_ID ;");
     170    if(_param->_have_port_ooo_engine_id   )
     171      vhdl->set_body ("out_READ_QUEUE_OUT_OOO_ENGINE_ID <= internal_OOO_ENGINE_ID;");
     172    if(_param->_have_port_rob_id   )
     173      vhdl->set_body ("out_READ_QUEUE_OUT_ROB_ID        <= internal_ROB_ID       ;");
     174    vhdl->set_body ("out_READ_QUEUE_OUT_OPERATION     <= internal_OPERATION    ;");
     175    vhdl->set_body ("out_READ_QUEUE_OUT_TYPE          <= internal_TYPE         ;");
     176    vhdl->set_body ("out_READ_QUEUE_OUT_HAS_IMMEDIAT  <= internal_HAS_IMMEDIAT ;");
     177    vhdl->set_body ("out_READ_QUEUE_OUT_IMMEDIAT      <= internal_IMMEDIAT     ;");
     178    vhdl->set_body ("out_READ_QUEUE_OUT_READ_RA       <= internal_READ_RA      ;");
     179    vhdl->set_body ("out_READ_QUEUE_OUT_NUM_REG_RA    <= internal_NUM_REG_RA   ;");
     180    vhdl->set_body ("out_READ_QUEUE_OUT_DATA_RA_VAL   <= internal_NEXT_DATA_RA_VAL;");
     181    vhdl->set_body ("out_READ_QUEUE_OUT_DATA_RA       <= internal_NEXT_DATA_RA ;");
     182    vhdl->set_body ("out_READ_QUEUE_OUT_READ_RB       <= internal_READ_RB      ;");
     183    vhdl->set_body ("out_READ_QUEUE_OUT_NUM_REG_RB    <= internal_NUM_REG_RB   ;");
     184    vhdl->set_body ("out_READ_QUEUE_OUT_DATA_RB_VAL   <= internal_NEXT_DATA_RB_VAL;");
     185    vhdl->set_body ("out_READ_QUEUE_OUT_DATA_RB       <= internal_NEXT_DATA_RB ;");
     186    vhdl->set_body ("out_READ_QUEUE_OUT_READ_RC       <= internal_READ_RC      ;");
     187    vhdl->set_body ("out_READ_QUEUE_OUT_NUM_REG_RC    <= internal_NUM_REG_RC   ;");
     188    vhdl->set_body ("out_READ_QUEUE_OUT_DATA_RC_VAL   <= internal_NEXT_DATA_RC_VAL;");
     189    vhdl->set_body ("out_READ_QUEUE_OUT_DATA_RC       <= internal_NEXT_DATA_RC ;");
     190    vhdl->set_body ("out_READ_QUEUE_OUT_WRITE_RD      <= internal_WRITE_RD     ;");
     191    vhdl->set_body ("out_READ_QUEUE_OUT_NUM_REG_RD    <= internal_NUM_REG_RD   ;");
     192    vhdl->set_body ("out_READ_QUEUE_OUT_WRITE_RE      <= internal_WRITE_RE     ;");
     193    vhdl->set_body ("out_READ_QUEUE_OUT_NUM_REG_RE    <= internal_NUM_REG_RE   ;");
     194   
     195    vhdl->set_body("");
     196    vhdl->set_body("-----------------------------------");
     197    vhdl->set_body("-- next reg update");
     198    vhdl->set_body("-----------------------------------");
     199    vhdl->set_body("");
     200    vhdl->set_body("-- read_rx_val - 1 : must access at the registerFile (after access, is set at 0)");
     201   
     202    {
     203      vhdl->set_body("");
     204      vhdl->set_body("internal_NEXT_READ_RA_VAL <=");
     205      vhdl->set_body("\t'0' when");
     206      // bypass
     207      vhdl->set_body("\t\t-- check bypass");
     208      for (int32_t i=_param->_nb_gpr_write-1; i>=0 ; i--)
     209        {
     210          string cmp;
     211         
     212          if (_param->_have_port_ooo_engine_id)
     213            cmp = "and (in_GPR_WRITE_"+toString(i)+"_OOO_ENGINE_ID=internal_OOO_ENGINE_ID) ";
     214          else
     215            cmp = "";
     216         
     217          vhdl->set_body("\t\t((in_GPR_WRITE_"+toString(i)+"_VAL='1') "+cmp+"and (internal_NUM_REG_RA=in_GPR_WRITE_"+toString(i)+"_NUM_REG)) or");
     218        }
     219      vhdl->set_body("\t\tfalse else");
     220      vhdl->set_body("\tinternal_READ_RA_VAL and not in_GPR_READ_0_ACK;");
     221    }
     222    {
     223      vhdl->set_body("");
     224      vhdl->set_body("internal_NEXT_READ_RB_VAL <=");
     225      vhdl->set_body("\t'0' when");
     226      // bypass
     227      vhdl->set_body("\t\t-- check bypass");
     228      for (int32_t i=_param->_nb_gpr_write-1; i>=0 ; i--)
     229        {
     230          string cmp;
     231         
     232          if (_param->_have_port_ooo_engine_id)
     233            cmp = "and (in_GPR_WRITE_"+toString(i)+"_OOO_ENGINE_ID=internal_OOO_ENGINE_ID) ";
     234          else
     235            cmp = "";
     236         
     237          vhdl->set_body("\t\t((in_GPR_WRITE_"+toString(i)+"_VAL='1') "+cmp+"and (internal_NUM_REG_RB=in_GPR_WRITE_"+toString(i)+"_NUM_REG)) or");
     238        }
     239      vhdl->set_body("\t\tfalse else");
     240      vhdl->set_body("\tinternal_READ_RB_VAL and not in_GPR_READ_1_ACK;");
     241    }
     242    {
     243      vhdl->set_body("");
     244      vhdl->set_body("internal_NEXT_READ_RC_VAL <=");
     245      vhdl->set_body("\t'0' when");
     246      // bypass
     247      vhdl->set_body("\t\t-- check bypass");
     248      for (int32_t i=_param->_nb_spr_write-1; i>=0 ; i--)
     249        {
     250          string cmp;
     251         
     252          if (_param->_have_port_ooo_engine_id)
     253            cmp = "and (in_SPR_WRITE_"+toString(i)+"_OOO_ENGINE_ID=internal_OOO_ENGINE_ID) ";
     254          else
     255            cmp = "";
     256         
     257          vhdl->set_body("\t\t((in_SPR_WRITE_"+toString(i)+"_VAL='1') "+cmp+"and (internal_NUM_REG_RC=in_SPR_WRITE_"+toString(i)+"_NUM_REG)) or");
     258        }
     259      vhdl->set_body("\t\tfalse else");
     260      vhdl->set_body("\tinternal_READ_RC_VAL and not in_SPR_READ_0_ACK;");
     261    }
     262    {
     263      vhdl->set_body("");
     264      vhdl->set_body("internal_READ_QUEUE_OUT_VAL <= not internal_NEXT_READ_RA_VAL and not internal_NEXT_READ_RB_VAL and not internal_NEXT_READ_RC_VAL;");
     265      vhdl->set_body("     out_READ_QUEUE_OUT_VAL <= internal_READ_QUEUE_OUT_VAL and internal_QUEUE_RETIRE_VAL;");
     266     
     267    }
     268   
     269    vhdl->set_body("");
     270    vhdl->set_body("-- data_rx_val - 1 : the read of registerFile is valid");
     271   
     272    {
     273      vhdl->set_body("");
     274      vhdl->set_body("internal_NEXT_DATA_RA_VAL <=");
     275      vhdl->set_body("\t'1' when");
     276      // bypass
     277      vhdl->set_body("\t\t-- check bypass");
     278      for (int32_t i=_param->_nb_gpr_write-1; i>=0 ; i--)
     279        {
     280          string cmp;
     281       
     282          if (_param->_have_port_ooo_engine_id)
     283            cmp = "and (in_GPR_WRITE_"+toString(i)+"_OOO_ENGINE_ID=internal_OOO_ENGINE_ID) ";
     284          else
     285            cmp = "";
     286         
     287          vhdl->set_body("\t\t((in_GPR_WRITE_"+toString(i)+"_VAL='1') "+cmp+"and (internal_NUM_REG_RA=in_GPR_WRITE_"+toString(i)+"_NUM_REG)) or");
     288        }
     289      vhdl->set_body("\t\tfalse else");
     290      vhdl->set_body("\tinternal_DATA_RA_VAL or (internal_READ_RA_VAL and in_GPR_READ_0_ACK and in_GPR_READ_0_DATA_VAL);");
     291    }
     292    {
     293      vhdl->set_body("");
     294      vhdl->set_body("internal_NEXT_DATA_RB_VAL <=");
     295      vhdl->set_body("\t'1' when");
     296      // bypass
     297      vhdl->set_body("\t\t-- check bypass");
     298      for (int32_t i=_param->_nb_gpr_write-1; i>=0 ; i--)
     299        {
     300          string cmp;
     301         
     302          if (_param->_have_port_ooo_engine_id)
     303            cmp = "and (in_GPR_WRITE_"+toString(i)+"_OOO_ENGINE_ID=internal_OOO_ENGINE_ID) ";
     304        else
     305          cmp = "";
     306         
     307          vhdl->set_body("\t\t((in_GPR_WRITE_"+toString(i)+"_VAL='1') "+cmp+"and (internal_NUM_REG_RB=in_GPR_WRITE_"+toString(i)+"_NUM_REG)) or");
     308        }
     309      vhdl->set_body("\t\tfalse else");
     310      vhdl->set_body("\tinternal_DATA_RB_VAL or (internal_READ_RB_VAL and in_GPR_READ_1_ACK and in_GPR_READ_1_DATA_VAL);");
     311    }
     312    {
     313      vhdl->set_body("");
     314      vhdl->set_body("internal_NEXT_DATA_RC_VAL <=");
     315      vhdl->set_body("\t'1' when");
     316      // bypass
     317      vhdl->set_body("\t\t-- check bypass");
     318      for (int32_t i=_param->_nb_spr_write-1; i>=0 ; i--)
     319        {
     320          string cmp;
     321         
     322          if (_param->_have_port_ooo_engine_id)
     323            cmp = "and (in_SPR_WRITE_"+toString(i)+"_OOO_ENGINE_ID=internal_OOO_ENGINE_ID) ";
     324          else
     325            cmp = "";
     326         
     327          vhdl->set_body("\t\t((in_SPR_WRITE_"+toString(i)+"_VAL='1') "+cmp+"and (internal_NUM_REG_RC=in_SPR_WRITE_"+toString(i)+"_NUM_REG)) or");
     328        }
     329      vhdl->set_body("\t\tfalse else");
     330      vhdl->set_body("\tinternal_DATA_RC_VAL or (internal_READ_RC_VAL and in_SPR_READ_0_ACK and in_SPR_READ_0_DATA_VAL);");
     331    }
     332   
     333    vhdl->set_body("");
     334    vhdl->set_body("-- data_rx - data read");
     335    {
     336      vhdl->set_body("");
     337      vhdl->set_body("internal_NEXT_DATA_RA <=");
     338#ifdef SYSTEMC_VHDL_COMPATIBILITY
     339      vhdl->set_body("\t"+std_logic_others(_param->_size_general_data,0)+" when internal_READ_RA='0' else");
     340#endif
     341      // bypass
     342      vhdl->set_body("\t\t-- check bypass");
     343      for (int32_t i=_param->_nb_gpr_write-1; i>=0 ; i--)
     344        {
     345          string cmp;
     346       
     347          if (_param->_have_port_ooo_engine_id)
     348            cmp = "and (in_GPR_WRITE_"+toString(i)+"_OOO_ENGINE_ID=internal_OOO_ENGINE_ID) ";
     349          else
     350            cmp = "";
     351         
     352          vhdl->set_body("\tin_GPR_WRITE_"+toString(i)+"_DATA when ((in_GPR_WRITE_"+toString(i)+"_VAL='1') "+cmp+"and (internal_NUM_REG_RA=in_GPR_WRITE_"+toString(i)+"_NUM_REG)) else");
     353        }
     354      vhdl->set_body("\treg_DATA_RA when (internal_DATA_RA_VAL='1') else");
     355      vhdl->set_body("\tin_GPR_READ_0_DATA;");
     356    }
     357    {
     358      vhdl->set_body("");
     359      vhdl->set_body("internal_NEXT_DATA_RB <=");
     360#ifdef SYSTEMC_VHDL_COMPATIBILITY
     361      vhdl->set_body("\t"+std_logic_others(_param->_size_general_data,0)+" when internal_READ_RB='0' else");
     362#endif
     363      // bypass
     364      vhdl->set_body("\t\t-- check bypass");
     365      for (int32_t i=_param->_nb_gpr_write-1; i>=0 ; i--)
     366        {
     367          string cmp;
     368       
     369          if (_param->_have_port_ooo_engine_id)
     370            cmp = "and (in_GPR_WRITE_"+toString(i)+"_OOO_ENGINE_ID=internal_OOO_ENGINE_ID) ";
     371          else
     372            cmp = "";
     373         
     374          vhdl->set_body("\tin_GPR_WRITE_"+toString(i)+"_DATA when ((in_GPR_WRITE_"+toString(i)+"_VAL='1') "+cmp+"and (internal_NUM_REG_RB=in_GPR_WRITE_"+toString(i)+"_NUM_REG)) else");
     375        }
     376      vhdl->set_body("\treg_DATA_RB when (internal_DATA_RB_VAL='1') else");
     377      vhdl->set_body("\tin_GPR_READ_1_DATA;");
     378    }
     379    {
     380      vhdl->set_body("");
     381      vhdl->set_body("internal_NEXT_DATA_RC <=");
     382#ifdef SYSTEMC_VHDL_COMPATIBILITY
     383      vhdl->set_body("\t"+std_logic_others(_param->_size_special_data,0)+" when internal_READ_RC='0' else");
     384#endif
     385      // bypass
     386      vhdl->set_body("\t\t-- check bypass");
     387      for (int32_t i=_param->_nb_spr_write-1; i>=0 ; i--)
     388        {
     389          string cmp;
     390       
     391          if (_param->_have_port_ooo_engine_id)
     392            cmp = "and (in_SPR_WRITE_"+toString(i)+"_OOO_ENGINE_ID=internal_OOO_ENGINE_ID) ";
     393          else
     394            cmp = "";
     395         
     396          vhdl->set_body("\tin_SPR_WRITE_"+toString(i)+"_DATA when ((in_SPR_WRITE_"+toString(i)+"_VAL='1') "+cmp+"and (in_SPR_WRITE_"+toString(i)+"_NUM_REG=internal_NUM_REG_RC)) else");
     397        }
     398      vhdl->set_body("\treg_DATA_RC when (internal_DATA_RC_VAL='1') else");
     399      vhdl->set_body("\tin_SPR_READ_0_DATA;");
     400
     401    vhdl->set_body("");
     402    vhdl->set_body("-----------------------------------");
     403    vhdl->set_body("-- transition");
     404    vhdl->set_body("-----------------------------------");
     405    vhdl->set_body("");
     406    vhdl->set_body("-- need a new head if :");
     407    vhdl->set_body("--   * queue is empty");
     408    vhdl->set_body("--   * pop with queue");
     409    vhdl->set_body ("internal_NEXT_NEED_NEW_HEAD <= not internal_QUEUE_RETIRE_VAL or (internal_QUEUE_RETIRE_VAL and internal_QUEUE_RETIRE_ACK);");
     410
     411    vhdl->set_body ("internal_READ_RA_VAL   <=     internal_READ_RA when reg_NEED_NEW_HEAD='1' else reg_READ_RA_VAL;");
     412    vhdl->set_body ("internal_READ_RB_VAL   <=     internal_READ_RB when reg_NEED_NEW_HEAD='1' else reg_READ_RB_VAL;");
     413    vhdl->set_body ("internal_READ_RC_VAL   <=     internal_READ_RC when reg_NEED_NEW_HEAD='1' else reg_READ_RC_VAL;");
     414    vhdl->set_body ("internal_DATA_RA_VAL   <= not internal_READ_RA when reg_NEED_NEW_HEAD='1' else reg_DATA_RA_VAL;");
     415    vhdl->set_body ("internal_DATA_RB_VAL   <= not internal_READ_RB when reg_NEED_NEW_HEAD='1' else reg_DATA_RB_VAL;");
     416    vhdl->set_body ("internal_DATA_RC_VAL   <= not internal_READ_RC when reg_NEED_NEW_HEAD='1' else reg_DATA_RC_VAL;");
     417
     418
     419    vhdl->set_body ("");
     420    vhdl->set_body ("transition: process (in_CLOCK)");
     421    vhdl->set_body ("begin  -- process transition");
     422    vhdl->set_body ("\tif in_CLOCK'event and in_CLOCK = '1' then");
     423    vhdl->set_body ("");
     424    vhdl->set_body ("\t\tif (in_NRESET = '0') then");   
     425    vhdl->set_body ("\t\t\treg_NEED_NEW_HEAD <= '1';");
     426    vhdl->set_body ("\t\telse");
     427    vhdl->set_body ("\t\t\treg_NEED_NEW_HEAD <= internal_NEXT_NEED_NEW_HEAD;");
     428    vhdl->set_body ("\t\t\treg_READ_RA_VAL   <= internal_NEXT_READ_RA_VAL;");
     429    vhdl->set_body ("\t\t\treg_READ_RB_VAL   <= internal_NEXT_READ_RB_VAL;");
     430    vhdl->set_body ("\t\t\treg_READ_RC_VAL   <= internal_NEXT_READ_RC_VAL;");
     431    vhdl->set_body ("\t\t\treg_DATA_RA_VAL   <= internal_NEXT_DATA_RA_VAL;");
     432    vhdl->set_body ("\t\t\treg_DATA_RB_VAL   <= internal_NEXT_DATA_RB_VAL;");
     433    vhdl->set_body ("\t\t\treg_DATA_RC_VAL   <= internal_NEXT_DATA_RC_VAL;");
     434    vhdl->set_body ("\t\t\treg_DATA_RA       <= internal_NEXT_DATA_RA    ;");
     435    vhdl->set_body ("\t\t\treg_DATA_RB       <= internal_NEXT_DATA_RB    ;");
     436    vhdl->set_body ("\t\t\treg_DATA_RC       <= internal_NEXT_DATA_RC    ;");
     437
     438    vhdl->set_body ("\t\tend if;");
     439    vhdl->set_body ("");
     440    vhdl->set_body ("\tend if;");
     441    vhdl->set_body ("end process transition;");
     442
     443    }
     444
     445
    25446    log_printf(FUNC,Read_queue,"vhdl_body","End");
    26447  };

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_vhdl_declaration.cpp

    r54 r68  
    2222  {
    2323    log_printf(FUNC,Read_queue,"vhdl_declaration","Begin");
     24
     25
     26    vhdl->set_signal ("internal_READ_QUEUE_OUT_VAL   ",1);
     27
     28    vhdl->set_signal ("reg_NEED_NEW_HEAD             ",1);
     29    vhdl->set_signal ("reg_READ_RA_VAL               ",1);
     30    vhdl->set_signal ("reg_READ_RB_VAL               ",1);
     31    vhdl->set_signal ("reg_READ_RC_VAL               ",1);
     32    vhdl->set_signal ("reg_DATA_RA_VAL               ",1);
     33    vhdl->set_signal ("reg_DATA_RB_VAL               ",1);
     34    vhdl->set_signal ("reg_DATA_RA                   ",_param->_size_general_data);
     35    vhdl->set_signal ("reg_DATA_RB                   ",_param->_size_general_data);
     36    vhdl->set_signal ("reg_DATA_RC_VAL               ",1);
     37    vhdl->set_signal ("reg_DATA_RC                   ",_param->_size_special_data);
     38
     39    vhdl->set_signal ("internal_NEXT_NEED_NEW_HEAD   ",1);
     40    vhdl->set_signal ("internal_NEXT_READ_RA_VAL     ",1);
     41    vhdl->set_signal ("internal_NEXT_READ_RB_VAL     ",1);
     42    vhdl->set_signal ("internal_NEXT_READ_RC_VAL     ",1);
     43    vhdl->set_signal ("internal_NEXT_DATA_RA_VAL     ",1);
     44    vhdl->set_signal ("internal_NEXT_DATA_RB_VAL     ",1);
     45    vhdl->set_signal ("internal_NEXT_DATA_RA         ",_param->_size_general_data);
     46    vhdl->set_signal ("internal_NEXT_DATA_RB         ",_param->_size_general_data);
     47    vhdl->set_signal ("internal_NEXT_DATA_RC_VAL     ",1);
     48    vhdl->set_signal ("internal_NEXT_DATA_RC         ",_param->_size_special_data);
     49
     50    vhdl->set_signal ("internal_READ_RA_VAL          ",1);
     51    vhdl->set_signal ("internal_READ_RB_VAL          ",1);
     52    vhdl->set_signal ("internal_READ_RC_VAL          ",1);
     53    vhdl->set_signal ("internal_DATA_RA_VAL          ",1);
     54    vhdl->set_signal ("internal_DATA_RB_VAL          ",1);
     55    vhdl->set_signal ("internal_DATA_RC_VAL          ",1);
     56 
     57
     58    vhdl->set_alias  ("internal_QUEUE_INSERT_VAL     ",std_logic(1)," in_READ_QUEUE_IN_VAL",std_logic_range(1));
     59    vhdl->set_alias  ("internal_QUEUE_INSERT_ACK     ",std_logic(1),"out_READ_QUEUE_IN_ACK",std_logic_range(1));
     60    vhdl->set_signal ("internal_QUEUE_INSERT_DATA    ",_param->_size_internal_queue);
     61    vhdl->set_signal ("internal_QUEUE_RETIRE_DATA    ",_param->_size_internal_queue);
     62    vhdl->set_signal ("internal_QUEUE_RETIRE_VAL     ",1);
     63    vhdl->set_signal ("internal_QUEUE_RETIRE_ACK     ",1);
     64   
     65    uint32_t min = 0;
     66    uint32_t max, size;
     67   
     68    if(_param->_have_port_context_id   )
     69      {
     70        size = _param->_size_context_id;
     71        max = min-1+size;
     72        vhdl->set_alias ("internal_CONTEXT_ID           ",std_logic(size),"internal_QUEUE_RETIRE_DATA",std_logic_range(_param->_size_internal_queue,max,min));
     73        min = max+1;
     74      }
     75    if(_param->_have_port_front_end_id   )
     76      {
     77        size = _param->_size_front_end_id;
     78        max = min-1+size;
     79        vhdl->set_alias ("internal_FRONT_END_ID         ",std_logic(size),"internal_QUEUE_RETIRE_DATA",std_logic_range(_param->_size_internal_queue,max,min));
     80        min = max+1;
     81      }
     82    if(_param->_have_port_ooo_engine_id   )
     83      {
     84        size = _param->_size_ooo_engine_id;
     85        max = min-1+size;
     86        vhdl->set_alias ("internal_OOO_ENGINE_ID        ",std_logic(size),"internal_QUEUE_RETIRE_DATA",std_logic_range(_param->_size_internal_queue,max,min));
     87        min = max+1;
     88      }
     89    if(_param->_have_port_rob_id   )
     90      {
     91        size = _param->_size_rob_id;
     92        max = min-1+size;
     93        vhdl->set_alias ("internal_ROB_ID               ",std_logic(size),"internal_QUEUE_RETIRE_DATA",std_logic_range(_param->_size_internal_queue,max,min));
     94        min = max+1;
     95      }
     96
     97    size = _param->_size_operation;
     98    max = min-1+size;
     99    vhdl->set_alias ("internal_OPERATION            ",std_logic(size),"internal_QUEUE_RETIRE_DATA",std_logic_range(_param->_size_internal_queue,max,min));
     100    min = max+1;
     101
     102    size = _param->_size_type;
     103    max = min-1+size;
     104    vhdl->set_alias ("internal_TYPE                 ",std_logic(size),"internal_QUEUE_RETIRE_DATA",std_logic_range(_param->_size_internal_queue,max,min));
     105    min = max+1;
     106
     107    size = 1;
     108    max = min-1+size;
     109    vhdl->set_alias ("internal_HAS_IMMEDIAT         ",std_logic(size),"internal_QUEUE_RETIRE_DATA",std_logic_range(_param->_size_internal_queue,max,min));
     110    min = max+1;
     111
     112    size = _param->_size_general_data;
     113    max = min-1+size;
     114    vhdl->set_alias ("internal_IMMEDIAT             ",std_logic(size),"internal_QUEUE_RETIRE_DATA",std_logic_range(_param->_size_internal_queue,max,min));
     115    min = max+1;
     116
     117    size = 1;
     118    max = min-1+size;
     119    vhdl->set_alias ("internal_READ_RA              ",std_logic(size),"internal_QUEUE_RETIRE_DATA",std_logic_range(_param->_size_internal_queue,max,min));
     120    min = max+1;
     121
     122    size = _param->_size_general_register;
     123    max = min-1+size;
     124    vhdl->set_alias ("internal_NUM_REG_RA           ",std_logic(size),"internal_QUEUE_RETIRE_DATA",std_logic_range(_param->_size_internal_queue,max,min));
     125    min = max+1;
     126
     127    size = 1;
     128    max = min-1+size;
     129    vhdl->set_alias ("internal_READ_RB              ",std_logic(size),"internal_QUEUE_RETIRE_DATA",std_logic_range(_param->_size_internal_queue,max,min));
     130    min = max+1;
     131
     132    size = _param->_size_general_register;
     133    max = min-1+size;
     134    vhdl->set_alias ("internal_NUM_REG_RB           ",std_logic(size),"internal_QUEUE_RETIRE_DATA",std_logic_range(_param->_size_internal_queue,max,min));
     135    min = max+1;
     136
     137    size = 1;
     138    max = min-1+size;
     139    vhdl->set_alias ("internal_READ_RC              ",std_logic(size),"internal_QUEUE_RETIRE_DATA",std_logic_range(_param->_size_internal_queue,max,min));
     140    min = max+1;
     141
     142    size = _param->_size_special_register;
     143    max = min-1+size;
     144    vhdl->set_alias ("internal_NUM_REG_RC           ",std_logic(size),"internal_QUEUE_RETIRE_DATA",std_logic_range(_param->_size_internal_queue,max,min));
     145    min = max+1;
     146
     147    size = 1;
     148    max = min-1+size;
     149    vhdl->set_alias ("internal_WRITE_RD             ",std_logic(size),"internal_QUEUE_RETIRE_DATA",std_logic_range(_param->_size_internal_queue,max,min));
     150    min = max+1;
     151
     152    size = _param->_size_general_register;
     153    max = min-1+size;
     154    vhdl->set_alias ("internal_NUM_REG_RD           ",std_logic(size),"internal_QUEUE_RETIRE_DATA",std_logic_range(_param->_size_internal_queue,max,min));
     155    min = max+1;
     156
     157    size = 1;
     158    max = min-1+size;
     159    vhdl->set_alias ("internal_WRITE_RE             ",std_logic(size),"internal_QUEUE_RETIRE_DATA",std_logic_range(_param->_size_internal_queue,max,min));
     160    min = max+1;
     161
     162    size = _param->_size_special_register;
     163    max = min-1+size;
     164    vhdl->set_alias ("internal_NUM_REG_RE           ",std_logic(size),"internal_QUEUE_RETIRE_DATA",std_logic_range(_param->_size_internal_queue,max,min));
     165    min = max+1;
     166
     167
    24168    log_printf(FUNC,Read_queue,"vhdl_declaration","End");
    25169  };

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Queue/src/Queue.cpp

    r67 r68  
    4242
    4343#ifdef STATISTICS
    44     log_printf(INFO,Queue,FUNCTION,"Allocation of statistics");
    45 
    46     // Allocation of statistics
    47     _stat = new Statistics (static_cast<string>(_name),
    48                             param_statistics          ,
    49                             param);
     44    if (_usage & USE_STATISTICS)
     45      {
     46        log_printf(INFO,Queue,FUNCTION,"Allocation of statistics");
     47       
     48        // Allocation of statistics
     49        _stat = new Statistics (static_cast<string>(_name),
     50                                param_statistics          ,
     51                                param);
     52      }
    5053#endif
    5154
    5255#ifdef VHDL
    53     // generate the vhdl
    54     log_printf(INFO,Queue,FUNCTION,"Generate the vhdl");
    55 
    56     vhdl();
     56    if (_usage & USE_VHDL)
     57      {
     58        // generate the vhdl
     59        log_printf(INFO,Queue,FUNCTION,"Generate the vhdl");
     60       
     61        vhdl();
     62      }
    5763#endif
    5864
    5965#ifdef SYSTEMC
    60 //#if defined(STATISTICS) or defined(VHDL_TESTBENCH)
    61     log_printf(INFO,Queue,FUNCTION,"Method - transition");
    62 
    63     SC_METHOD (transition);
    64     dont_initialize ();
    65     sensitive << (*(in_CLOCK)).pos();
    66 //#endif
    67 
     66    if (_usage & USE_SYSTEMC)
     67      {
     68        log_printf(INFO,Queue,FUNCTION,"Method - transition");
     69       
     70        SC_METHOD (transition);
     71        dont_initialize ();
     72        sensitive << (*(in_CLOCK)).pos();
     73       
    6874# ifdef SYSTEMCASS_SPECIFIC
    69     // List dependency information
     75        // List dependency information
    7076# endif   
    71 
    72     log_printf(INFO,Queue,FUNCTION,"Method - genMoore");
    73 
    74     SC_METHOD (genMoore);
    75     dont_initialize ();
    76     sensitive << (*(in_CLOCK)).neg();
    77 
     77       
     78        log_printf(INFO,Queue,FUNCTION,"Method - genMoore");
     79       
     80        SC_METHOD (genMoore);
     81        dont_initialize ();
     82        sensitive << (*(in_CLOCK)).neg();
     83       
    7884# ifdef SYSTEMCASS_SPECIFIC
    79     // List dependency information
     85        // List dependency information
    8086# endif   
    81 
     87       
    8288#endif
     89      }
    8390    log_printf(FUNC,Queue,FUNCTION,"End");
    8491  };
    … …  
    9198
    9299#ifdef STATISTICS
    93     log_printf(INFO,Queue,FUNCTION,"Generate Statistics file");
    94 
    95     _stat->generate_file(statistics(0));
    96     delete _stat;
     100    if (_usage & USE_STATISTICS)
     101      {
     102        log_printf(INFO,Queue,FUNCTION,"Generate Statistics file");
     103       
     104        _stat->generate_file(statistics(0));
     105        delete _stat;
     106      }
    97107#endif
    98108

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Queue/src/Queue_allocation.cpp

    r67 r68  
    2323    log_printf(FUNC,Queue,FUNCTION,"Begin");
    2424
    25     _component   = new Component ();
     25    _component   = new Component (_usage);
    2626
    2727    Entity * entity = _component->set_entity (_name       

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Queue/src/Queue_deallocation.cpp

    r67 r68  
    2020    log_printf(FUNC,Queue,FUNCTION,"Begin");
    2121
    22     delete    in_CLOCK ;
    23     delete    in_NRESET;
    24 
    25     delete    in_INSERT_VAL ;
    26     delete   out_INSERT_ACK ;
    27     delete    in_INSERT_DATA;
    28 
    29     delete   out_RETIRE_VAL ;
    30     delete    in_RETIRE_ACK ;
    31     delete   out_RETIRE_DATA;
    32 
     22    if (_usage & USE_SYSTEMC)
     23      {
     24        delete    in_CLOCK ;
     25        delete    in_NRESET;
     26       
     27        delete    in_INSERT_VAL ;
     28        delete   out_INSERT_ACK ;
     29        delete    in_INSERT_DATA;
     30       
     31        delete   out_RETIRE_VAL ;
     32        delete    in_RETIRE_ACK ;
     33        delete   out_RETIRE_DATA;
     34       
     35      }
    3336    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    3437    delete _queue_control;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Queue/src/Queue_vhdl_body.cpp

    r67 r68  
    6262        if (is_log2(_param->_size_queue) == false)
    6363          vhdl->set_body ("\tconst_PTR_INIT when reg_PTR_READ  = const_PTR_MAX else");
    64         vhdl->set_body ("\treg_PTR_READ +'1';");
     64
     65        if (_param->_size_queue > 2)
     66          vhdl->set_body ("\treg_PTR_READ +'1';");
     67        else
     68          vhdl->set_body ("\tnot reg_PTR_READ;");
    6569      }
    6670    vhdl->set_body ("");
    … …  
    7377        if (is_log2(_param->_size_queue) == false)
    7478          vhdl->set_body ("\tconst_PTR_INIT when reg_PTR_WRITE = const_PTR_MAX else");
    75         vhdl->set_body ("\treg_PTR_WRITE+'1';");
     79        if (_param->_size_queue > 2)
     80          vhdl->set_body ("\treg_PTR_WRITE+'1';");
     81        else
     82          vhdl->set_body ("\tnot reg_PTR_WRITE;");
    7683      }
    7784    vhdl->set_body ("");

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Select/Select_Priority_Fixed/src/Select_Priority_Fixed.cpp

    r58 r68  
    4040
    4141#ifdef STATISTICS
    42     log_printf(INFO,Select_Priority_Fixed,"Select_Priority_Fixed","Allocation of statistics");
    43 
    44     // Allocation of statistics
    45     _stat = new Statistics (static_cast<string>(_name),
    46                             param_statistics          ,
    47                             param);
     42    if (_usage & USE_STATISTICS)
     43      {
     44        log_printf(INFO,Select_Priority_Fixed,"Select_Priority_Fixed","Allocation of statistics");
     45       
     46        // Allocation of statistics
     47        _stat = new Statistics (static_cast<string>(_name),
     48                                param_statistics          ,
     49                                param);
     50      }
    4851#endif
    4952

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Makefile.Selftest

    r62 r68  
    115115                                @\
    116116                                $(ECHO) "Execute            : $*";\
    117                                 $(EXPORT) SYSTEMC=$(SYSTEMC_$(SIMULATOR)) ; ./$(DIR_BIN)/$(EXEC).x $(EXEC_PARAMS) $* `$(CAT) $<` &> $@
     117                                export SYSTEMC=$(SYSTEMC_$(SIMULATOR)) ; ./$(DIR_BIN)/$(EXEC).x $(EXEC_PARAMS) $* `$(CAT) $<` &> $@
    118118                                declare -i count=`$(GREP) -ch "Test OK" $@`;            \
    119119                                if $(TEST) $$count -ne 0;                               \
    … …  
    125125                                @\
    126126                                $(ECHO) "Execute            : $*";\
    127                                 $(EXPORT) SYSTEMC=$(SYSTEMC_$(SIMULATOR)) ; ./$(DIR_BIN)/$(EXEC).x $(EXEC_PARAMS) $* `$(CAT) $<` &> $@
     127                                export SYSTEMC=$(SYSTEMC_$(SIMULATOR)) ; ./$(DIR_BIN)/$(EXEC).x $(EXEC_PARAMS) $* `$(CAT) $<` &> $@
    128128                                declare -i count=`$(GREP) -ch "Test OK" $@`;            \
    129129                                if $(TEST) $$count -ne 0;                               \

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Makefile.Synthesis

    r62 r68  
    8585                                @\
    8686                                if $(TEST) -f Makefile.mkf; then $(MAKE) -f Makefile.mkf clean; fi; \
    87                                 $(RM) $(DIR_WORK) transcript Makefile.mkf;
     87                                $(RM) $(DIR_WORK) transcript Makefile.mkf $(FPGA_CFG_FILE_LOCAL) *.wlf;
    8888
    8989synthesis_help                  :

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/New_Component/src/New_Component.cpp

    r66 r68  
    22 * $Id$
    33 *
    4  * [ Description ]
     4 * [ Description ]
    55 *
    66 */
    … …  
    4040
    4141#ifdef STATISTICS
    42     log_printf(INFO,@COMPONENT,FUNCTION,"Allocation of statistics");
    43 
    44     // Allocation of statistics
    45     _stat = new Statistics (static_cast<string>(_name),
    46                             param_statistics          ,
    47                             param);
     42    if (_usage & USE_STATISTICS)
     43      {
     44        log_printf(INFO,@COMPONENT,FUNCTION,"Allocation of statistics");
     45       
     46        // Allocation of statistics
     47        _stat = new Statistics (static_cast<string>(_name),
     48                                param_statistics          ,
     49                                param);
     50      }
    4851#endif
    4952
    5053#ifdef VHDL
    51     // generate the vhdl
    52     log_printf(INFO,@COMPONENT,FUNCTION,"Generate the vhdl");
    53 
    54     vhdl();
     54    if (_usage & USE_VHDL)
     55      {
     56        // generate the vhdl
     57        log_printf(INFO,@COMPONENT,FUNCTION,"Generate the vhdl");
     58       
     59        vhdl();
     60      }
    5561#endif
    5662
    5763#ifdef SYSTEMC
    58 //#if defined(STATISTICS) or defined(VHDL_TESTBENCH)
    59     log_printf(INFO,@COMPONENT,FUNCTION,"Method - transition");
     64    if (_usage & USE_SYSTEMC)
     65      {
     66        log_printf(INFO,@COMPONENT,FUNCTION,"Method - transition");
    6067
    61     SC_METHOD (transition);
    62     dont_initialize ();
    63     sensitive << (*(in_CLOCK)).pos();
    64 //#endif
    65 
    66 #ifdef SYSTEMCASS_SPECIFIC
    67     // List dependency information
    68 #endif   
    69 
     68        SC_METHOD (transition);
     69        dont_initialize ();
     70        sensitive << (*(in_CLOCK)).pos();
     71       
     72# ifdef SYSTEMCASS_SPECIFIC
     73        // List dependency information
     74# endif   
     75       
    7076#endif
     77      }
    7178    log_printf(FUNC,@COMPONENT,FUNCTION,"End");
    7279  };
    73  
     80   
    7481#undef  FUNCTION
    7582#define FUNCTION "@COMPONENT::~@COMPONENT"
    … …  
    7986
    8087#ifdef STATISTICS
    81     log_printf(INFO,@COMPONENT,FUNCTION,"Generate Statistics file");
    82 
    83     _stat->generate_file(statistics(0));
    84     delete _stat;
     88    if (_usage & USE_STATISTICS)
     89      {
     90        log_printf(INFO,@COMPONENT,FUNCTION,"Generate Statistics file");
     91       
     92        _stat->generate_file(statistics(0));
     93        delete _stat;
     94      }
    8595#endif
    8696

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/New_Component/src/New_Component_allocation.cpp

    r57 r68  
    2121    log_printf(FUNC,@COMPONENT,FUNCTION,"Begin");
    2222
    23     _component   = new Component ();
     23    _component   = new Component (_usage);
    2424
    2525    Entity * entity = _component->set_entity (_name       

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/New_Component/src/New_Component_deallocation.cpp

    r57 r68  
    22 * $Id$
    33 *
    4  * [ Description ]
     4 * [ Description ]
    55 *
    66 */
    … …  
    1818    log_printf(FUNC,@COMPONENT,FUNCTION,"Begin");
    1919
    20 //#if defined(STATISTICS) or defined(VHDL_TESTBENCH)
    21     delete    in_CLOCK ;
    22 //#endif
    23     delete    in_NRESET;
    24 
    25     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
     20    if (_usage & USE_SYSTEMC)
     21      {
     22        delete    in_CLOCK ;
     23        delete    in_NRESET;
     24      }
     25    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    2626
    2727    delete _component;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/include/Debug_component.h

    r67 r68  
    66#define     DEBUG_Counter                                         false
    77#define     DEBUG_Group                                           false
    8 #define     DEBUG_Queue                                           true
     8#define     DEBUG_Queue                                           false
    99#define     DEBUG_Queue_Control                                   false
    1010#define     DEBUG_Shifter                                         false

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/include/Environnement.h

    r42 r68  
    1515#endif
    1616
     17#if (defined(VHDL_TESTBENCH) and defined(SYSTEMC))
     18#  define SYSTEMC_VHDL_COMPATIBILITY
     19#endif

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/mkf.info

    r67 r68  
    1919target_dep              all             Generic/RegisterFile/RegisterFile_Multi_Banked/SelfTest
    2020target_dep              all             Generic/Select/Select_Priority_Fixed/SelfTest
     21target_dep              all             Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/SelfTest
    2122target_dep              all             Core/Multi_Execute_loop/Execute_loop/Register_unit/SelfTest
    2223target_dep              all             Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/SelfTest

  • trunk/IPs/systemC/processor/Morpheo/Documentation/Source/Makefile

    r63 r68  
    3737# Directory
    3838#--------------------------------------------------------------------------------
    39 ENV_LATEX               = $(EXPORT) TEXINPUTS=$(DIR_INCLUDE):$$TEXINPUTS
     39ENV_LATEX               = export TEXINPUTS=$(DIR_INCLUDE):$$TEXINPUTS
    4040LATEX_WITH_ENV          = $(ENV_LATEX); $(LATEX)
    4141
    … …  
    148148                        then                                                                                    \
    149149                                $(ECHO) "Invalid name : string is empty, or filename is already used";          \
    150                                 $(EXIT);                                                                        \
     150                                exit;                                                                   \
    151151                        fi;                                                                                     \
    152152                                                                                                                \
    … …  
    205205                        if $(TEST) "$$NUM_FILE" -eq "0" -o "$$NUM_FILE" -ne "$$NUM_FILE_CONFIRM"; then          \
    206206                                $(ECHO) "Delete cancelled";                                                     \
    207                                 $(EXIT);                                                                        \
     207                                exit;                                                                           \
    208208                        fi;                                                                                     \
    209209                                                                                                                \
    … …  
    253253                        if $(TEST) "$$NUM_FILE" -eq "0"; then                                                   \
    254254                                $(ECHO) "Rename cancelled";                                                     \
    255                                 $(EXIT);                                                                        \
     255                                exit;                                                                           \
    256256                        fi;                                                                                     \
    257257                                                                                                                \
    … …  
    266266                        then                                                                                    \
    267267                                $(ECHO) "Invalid name : string is empty, or filename is already used";          \
    268                                 $(EXIT);                                                                        \
     268                                exit;                                                                           \
    269269                        fi;                                                                                     \
    270270                                                                                                                \
Note: See TracChangeset for help on using the changeset viewer.