Ignore:
Timestamp:
Jun 3, 2009, 10:15:51 AM (15 years ago)
Author:
rosiere
Message:

Modif for performance :
1) Load Store Unit : store send request to valid exeception
2) Commit_unit : retire can bypass store
3) Commit_unit : add stat to manage store instruction
4) Load Store Unit and Load Store Pointer Manager : add store_queue_ptr_read
5) Fix lot of bug

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Load_store_unit_function_speculative_load_commit_transition.cpp

    r119 r122  
    275275                  // =======================
    276276                 
    277                   log_printf(TRACE,Load_store_unit,FUNCTION,"    * store_queue [%d]",reg_STORE_QUEUE_PTR_READ);
     277                  log_printf(TRACE,Load_store_unit,FUNCTION,"    * store_queue [%d]",internal_MEMORY_OUT_PTR);
    278278           
    279279                  // Entry flush and increase the read pointer
    280                   _store_queue [reg_STORE_QUEUE_PTR_READ]._state = STORE_QUEUE_EMPTY;
    281                  
    282                   reg_STORE_QUEUE_PTR_READ = (reg_STORE_QUEUE_PTR_READ+1)%_param->_size_store_queue;
     280                  if (_store_queue [internal_MEMORY_OUT_PTR]._send_commit)
     281                    {
     282                      _store_queue [internal_MEMORY_OUT_PTR]._state = STORE_QUEUE_EMPTY;
     283                      reg_STORE_QUEUE_PTR_READ = (reg_STORE_QUEUE_PTR_READ+1)%_param->_size_store_queue;
     284                    }
     285                  else
     286                    _store_queue [internal_MEMORY_OUT_PTR]._send_commit = true;
    283287
    284288                  break;
    … …  
    339343          {
    340344            // Get an index from load queue
    341             uint32_t index_load = (i + reg_LOAD_QUEUE_CHECK_PRIORITY)%_param->_size_load_queue;
     345            uint32_t index_load_queue = (i + reg_LOAD_QUEUE_CHECK_PRIORITY)%_param->_size_load_queue;
    342346
    343347            // Test if this load must ckecked store queue
    344             if (((_load_queue[index_load]._state == LOAD_QUEUE_WAIT_CHECK) or
    345                  (_load_queue[index_load]._state == LOAD_QUEUE_COMMIT_CHECK) or
    346                  (_load_queue[index_load]._state == LOAD_QUEUE_CHECK)) and
    347                 is_operation_memory_load(_load_queue[index_load]._operation))
     348            if (((_load_queue[index_load_queue]._state == LOAD_QUEUE_WAIT_CHECK) or
     349                 (_load_queue[index_load_queue]._state == LOAD_QUEUE_COMMIT_CHECK) or
     350                 (_load_queue[index_load_queue]._state == LOAD_QUEUE_CHECK)) and
     351                is_operation_memory_load(_load_queue[index_load_queue]._operation))
    348352              {
    349                 log_printf(TRACE,Load_store_unit,FUNCTION,"    * Find a load : %d",index_load);
     353                log_printf(TRACE,Load_store_unit,FUNCTION,"    * Find a load : %d",index_load_queue);
    350354
    351355                nb_check++; // use one port
    352356
    353357                // find a entry that it need a check
    354                 Tlsq_ptr_t index_store     = _load_queue[index_load]._store_queue_ptr_write;
    355 //              Tlsq_ptr_t index_store_old = index_store;
     358                Tlsq_ptr_t store_queue_ptr_write = _load_queue[index_load_queue]._store_queue_ptr_write;
     359                Tlsq_ptr_t store_queue_ptr_read  = _load_queue[index_load_queue]._store_queue_ptr_read ;
     360                Tlsq_ptr_t store_queue_empty     = _load_queue[index_load_queue]._store_queue_empty    ;
     361//              Tlsq_ptr_t store_queue_ptr_write_old = store_queue_ptr_write;
    356362
    357363                // Init variable
    … …  
    365371                //  * when a store is out of store queue, also it was in head of re order buffer. Also, they are none previous load.
    366372
    367                 log_printf(TRACE,Load_store_unit,FUNCTION,"    * index_store : %d",index_store);
    368                 log_printf(TRACE,Load_store_unit,FUNCTION,"    * ptr_read    : %d",reg_STORE_QUEUE_PTR_READ);
    369 
    370                 if (index_store == reg_STORE_QUEUE_PTR_READ)
     373                log_printf(TRACE,Load_store_unit,FUNCTION,"    * store_queue_ptr_write    : %d",store_queue_ptr_write);
     374                log_printf(TRACE,Load_store_unit,FUNCTION,"    * store_queue_ptr_read     : %d",store_queue_ptr_read );
     375//              log_printf(TRACE,Load_store_unit,FUNCTION,"    * store_queue_empty        : %d",store_queue_empty );
     376                log_printf(TRACE,Load_store_unit,FUNCTION,"    * reg_STORE_QUEUE_PTR_READ : %d",reg_STORE_QUEUE_PTR_READ);
     377
     378                if ((store_queue_ptr_write ==     store_queue_ptr_read) or
     379                    (store_queue_ptr_write == reg_STORE_QUEUE_PTR_READ))
     380//              if (store_queue_empty)
    371381                  {
    372                     log_printf(TRACE,Load_store_unit,FUNCTION,"      * index_store == reg_STORE_QUEUE_PTR_READ");
     382                    log_printf(TRACE,Load_store_unit,FUNCTION,"      * store_queue_ptr_write == store_queue_ptr_read");
    373383                    end_check    = true;
    374384                    change_state = true;
    … …  
    376386                else
    377387                  {
    378                     log_printf(TRACE,Load_store_unit,FUNCTION,"      * index_store != reg_STORE_QUEUE_PTR_READ");
    379 
    380                     index_store = (index_store-1)%(_param->_size_store_queue); // store_queue_ptr_write target the next slot to write, also the slot is not significatif when the load is renaming
    381 
    382                     log_printf(TRACE,Load_store_unit,FUNCTION,"      * index_store : %d",index_store);
     388                    log_printf(TRACE,Load_store_unit,FUNCTION,"      * store_queue_ptr_write != store_queue_ptr_read");
     389
     390                    store_queue_ptr_write = (store_queue_ptr_write-1)%(_param->_size_store_queue); // store_queue_ptr_write target the next slot to write, also the slot is not significatif when the load is renaming
     391
     392                    log_printf(TRACE,Load_store_unit,FUNCTION,"      * store_queue_ptr_write : %d",store_queue_ptr_write);
    383393                   
    384394                    // switch on store_queue state
    385                     switch (_store_queue[index_store]._state)
     395                    switch (_store_queue[store_queue_ptr_write]._state)
    386396                      {
    387397                      case STORE_QUEUE_VALID_NO_SPECULATIVE :
    … …  
    397407                          // Test thread id
    398408                          if (_param->_have_port_context_id)
    399                             test_thread_id &= (_load_queue[index_load]._context_id    == _store_queue[index_store]._context_id);
     409                            test_thread_id &= (_load_queue[index_load_queue]._context_id    == _store_queue[store_queue_ptr_write]._context_id);
    400410                          if (_param->_have_port_front_end_id)
    401                             test_thread_id &= (_load_queue[index_load]._front_end_id  == _store_queue[index_store]._front_end_id);
     411                            test_thread_id &= (_load_queue[index_load_queue]._front_end_id  == _store_queue[store_queue_ptr_write]._front_end_id);
    402412                          if (_param->_have_port_ooo_engine_id)
    403                             test_thread_id &= (_load_queue[index_load]._ooo_engine_id == _store_queue[index_store]._ooo_engine_id);
     413                            test_thread_id &= (_load_queue[index_load_queue]._ooo_engine_id == _store_queue[store_queue_ptr_write]._ooo_engine_id);
    404414                         
    405415                          if (test_thread_id)
    … …  
    408418
    409419                              log_printf(TRACE,Load_store_unit,FUNCTION,"        * load and store is the same thread.");
    410                               Tdcache_address_t load_addr  = _load_queue [index_load ]._address;
    411                               Tdcache_address_t store_addr = _store_queue[index_store]._address;
     420                              Tdcache_address_t load_addr  = _load_queue [index_load_queue ]._address;
     421                              Tdcache_address_t store_addr = _store_queue[store_queue_ptr_write]._address;
    412422                             
    413423                              log_printf(TRACE,Load_store_unit,FUNCTION,"          * load_addr                     : %.8x.",load_addr );
    … …  
    435445                                  bool is_big_endian = true;
    436446
    437                                   Tgeneral_data_t   load_data      = _load_queue [index_load ]._rdata  ;
    438                                   Tgeneral_data_t   store_data     = _store_queue[index_store]._wdata  ;
    439                                   Tdcache_address_t check_hit_byte = _load_queue [index_load ]._check_hit_byte;
    440                                   Tcontrol_t        check_hit      = _load_queue [index_load ]._check_hit;
    441                                   uint32_t          load_size_access  = memory_size(_load_queue [index_load ]._operation)>>3;
    442                                   uint32_t          store_size_access = memory_size(_store_queue[index_store]._operation)>>3;
     447                                  Tgeneral_data_t   load_data      = _load_queue [index_load_queue ]._rdata  ;
     448                                  Tgeneral_data_t   store_data     = _store_queue[store_queue_ptr_write]._wdata  ;
     449                                  Tdcache_address_t check_hit_byte = _load_queue [index_load_queue ]._check_hit_byte;
     450                                  Tcontrol_t        check_hit      = _load_queue [index_load_queue ]._check_hit;
     451                                  uint32_t          load_size_access  = memory_size(_load_queue [index_load_queue ]._operation)>>3;
     452                                  uint32_t          store_size_access = memory_size(_store_queue[store_queue_ptr_write]._operation)>>3;
    443453
    444454                                  log_printf(TRACE,Load_store_unit,FUNCTION,"            * is_big_endian           : %d",is_big_endian);
    … …  
    464474                                    }
    465475
    466                                   uint32_t store_nb_byte     = (1<<memory_access(_store_queue[index_store]._operation));
     476                                  uint32_t store_nb_byte     = (1<<memory_access(_store_queue[store_queue_ptr_write]._operation));
    467477
    468478                                  // Take interval to the store
    … …  
    473483                                  log_printf(TRACE,Load_store_unit,FUNCTION,"            * store_num_byte_max      : %d",store_num_byte_max);
    474484
    475 //                                   uint32_t load_nb_byte      = (1<<memory_access(_load_queue[index_load]._operation));
     485//                                   uint32_t load_nb_byte      = (1<<memory_access(_load_queue[index_load_queue]._operation));
    476486
    477487//                                uint32_t load_num_byte_min = (load_addr & _param->_mask_address_lsb);
    … …  
    517527
    518528//                                           // store duplicate = all store access can be see as full size_data store
    519 // //                                           uint32_t load_nb_byte = (1<<memory_access(_load_queue [index_load ]._operation));
     529// //                                           uint32_t load_nb_byte = (1<<memory_access(_load_queue [index_load_queue ]._operation));
    520530
    521531// //                                           int32_t diff = ((_param->_size_general_data>>3)+load_nb_byte-2*load_nb_byte*((num_store_byte/load_nb_byte)+1));
    … …  
    597607                                    }
    598608
    599                                   _load_queue[index_load]._rdata          = load_data;
    600                                   _load_queue[index_load]._check_hit_byte = check_hit_byte;
    601                                   _load_queue[index_load]._check_hit      = check_hit;
     609                                  _load_queue[index_load_queue]._rdata          = load_data;
     610                                  _load_queue[index_load_queue]._check_hit_byte = check_hit_byte;
     611                                  _load_queue[index_load_queue]._check_hit      = check_hit;
    602612
    603613                                  log_printf(TRACE,Load_store_unit,FUNCTION,"            * load_data  (after) : 0x%.8x",load_data);
    … …  
    609619                                  log_printf(TRACE,Load_store_unit,FUNCTION,"            * mask_check_hit_byte: %x",_param->_mask_check_hit_byte);
    610620                                  // The check is finish if all bit is set
    611                                   end_check = (_load_queue[index_load]._check_hit_byte == _param->_mask_check_hit_byte);
     621                                  end_check = (_load_queue[index_load_queue]._check_hit_byte == _param->_mask_check_hit_byte);
    612622
    613623                                }
    … …  
    629639                  {
    630640                    log_printf(TRACE,Load_store_unit,FUNCTION,"              * next");
    631                     log_printf(TRACE,Load_store_unit,FUNCTION,"                * new store_queue_ptr_write : %d",index_store);
     641                    log_printf(TRACE,Load_store_unit,FUNCTION,"                * new store_queue_ptr_write : %d",store_queue_ptr_write);
    632642
    633643                    log_printf(TRACE,Load_store_unit,FUNCTION,"              * update reg_STORE_QUEUE_NB_CHECK");
    634644#ifdef DEBUG
    635                     if (reg_STORE_QUEUE_NB_CHECK [index_store] == 0)
     645                    if (reg_STORE_QUEUE_NB_CHECK [store_queue_ptr_write] == 0)
    636646                      throw ERRORMORPHEO(FUNCTION,_("reg_STORE_QUEUE_NB_CHECK must be > 0\n"));
    637647#endif
    638                     reg_STORE_QUEUE_NB_CHECK [index_store] --;
    639 
    640 //                  if (_load_queue[index_load]._store_queue_ptr_write == 0)
    641 //                    _load_queue[index_load]._store_queue_ptr_write = _param->_size_store_queue-1;
     648
     649                    reg_STORE_QUEUE_NB_CHECK [store_queue_ptr_write] --;
     650
     651                    log_printf(TRACE,Load_store_unit,FUNCTION,"              * reg_STORE_QUEUE_NB_CHECK 1 [%d] <- %d", store_queue_ptr_write,reg_STORE_QUEUE_NB_CHECK [store_queue_ptr_write]);
     652
     653                    if ((store_queue_ptr_write ==     store_queue_ptr_read) or
     654                        (store_queue_ptr_write == reg_STORE_QUEUE_PTR_READ))
     655                      {
     656//                      store_queue_empty = true;
     657                        end_check         = true;
     658                        change_state      = true;
     659                      }
     660
     661//                  if (_load_queue[index_load_queue]._store_queue_ptr_write == 0)
     662//                    _load_queue[index_load_queue]._store_queue_ptr_write = _param->_size_store_queue-1;
    642663//                  else
    643 //                    _load_queue[index_load]._store_queue_ptr_write --;
    644                     _load_queue[index_load]._store_queue_ptr_write = index_store; // because the index store have be decrease
    645 
    646                     // FIXME : peut n'est pas obliger de faire cette comparaison. Au prochain cycle on le détectera que les pointeur sont égaux. Ceci évitera d'avoir deux comparateurs avec le registre "reg_STORE_QUEUE_PTR_READ"
    647                     if (index_store == reg_STORE_QUEUE_PTR_READ)
    648                       {
    649                         end_check    = true;
    650                         change_state = true;
    651                       }
     664//                    _load_queue[index_load_queue]._store_queue_ptr_write --;
     665                    _load_queue[index_load_queue]._store_queue_ptr_write = store_queue_ptr_write; // because the index store have be decrease
     666                    _load_queue[index_load_queue]._store_queue_empty     = store_queue_empty; // because the index store have be decrease
     667
     668                    // FIXME : peut n'est pas obliger de faire cette comparaison. Au prochain cycle on le détectera que les pointeur sont égaux. Ceci évitera d'avoir deux comparateurs avec le registre "store_queue_ptr_read"
    652669                  }
    653670
    … …  
    657674                    log_printf(TRACE,Load_store_unit,FUNCTION,"              * end_check : %d",end_check);
    658675
    659                     log_printf(TRACE,Load_store_unit,FUNCTION,"                * state old : %s",toString(_load_queue[index_load]._state).c_str());
    660 
    661                     switch (_load_queue[index_load]._state)
     676                    log_printf(TRACE,Load_store_unit,FUNCTION,"                * state old : %s",toString(_load_queue[index_load_queue]._state).c_str());
     677
     678                    switch (_load_queue[index_load_queue]._state)
    662679                      {
    663680                      case LOAD_QUEUE_WAIT_CHECK   :
    664681                        {
    665682                          if (end_check)
    666                             _load_queue[index_load]._state = LOAD_QUEUE_WAIT  ;
     683                            _load_queue[index_load_queue]._state = LOAD_QUEUE_WAIT  ;
    667684                          break;
    668685                        }
    … …  
    670687                        {
    671688                          if (end_check)
    672                             _load_queue[index_load]._state = LOAD_QUEUE_COMMIT;
     689                            _load_queue[index_load_queue]._state = LOAD_QUEUE_COMMIT;
    673690                          else
    674                             _load_queue[index_load]._state = LOAD_QUEUE_CHECK; // No commit : check hit and no end
     691                            _load_queue[index_load_queue]._state = LOAD_QUEUE_CHECK; // No commit : check hit and no end
    675692                          break;
    676693                        }
    … …  
    678695                        {
    679696                          if (end_check)
    680                             _load_queue[index_load]._state     = LOAD_QUEUE_COMMIT;
     697                            _load_queue[index_load_queue]._state     = LOAD_QUEUE_COMMIT;
    681698
    682699                          // check find a bypass. A speculative load have been committed : report a speculation miss.
    683                           if ((_load_queue[index_load]._check_hit != 0) and
    684                               (_load_queue[index_load]._write_rd  == 0) // is commit
     700                          if ((_load_queue[index_load_queue]._check_hit != 0) and
     701                              (_load_queue[index_load_queue]._write_rd  == 0) // is commit
    685702                              )
    686703                            {
    687                               _load_queue[index_load]._exception = EXCEPTION_MEMORY_MISS_SPECULATION;
    688                               _load_queue[index_load]._write_rd  = 1; // write the good result
     704                              _load_queue[index_load_queue]._exception = EXCEPTION_MEMORY_MISS_SPECULATION;
     705                              _load_queue[index_load_queue]._write_rd  = 1; // write the good result
    689706
    690707#ifdef STATISTICS
    … …  
    698715                      default : break;
    699716                      }
    700                     log_printf(TRACE,Load_store_unit,FUNCTION,"                * state new : %s",toString(_load_queue[index_load]._state).c_str());
    701                     log_printf(TRACE,Load_store_unit,FUNCTION,"                * exception : %d",_load_queue[index_load]._exception);
    702 
    703                     if (end_check)
     717                    log_printf(TRACE,Load_store_unit,FUNCTION,"                * state new : %s",toString(_load_queue[index_load_queue]._state).c_str());
     718                    log_printf(TRACE,Load_store_unit,FUNCTION,"                * exception : %d",_load_queue[index_load_queue]._exception);
     719
     720                    if (end_check//  and not store_queue_empty
     721                        )
    704722                      {
    705723                        log_printf(TRACE,Load_store_unit,FUNCTION,"                * end check, decrease all nb_check");
    706724                       
    707                         uint32_t i=index_store;
    708                         while (i!=reg_STORE_QUEUE_PTR_READ)
     725                        uint32_t i=store_queue_ptr_write;
     726                        while (i!=store_queue_ptr_read)
    709727                          {
    710728                            i=((i==0)?_param->_size_store_queue:i)-1;
    … …  
    714732                              throw ERRORMORPHEO(FUNCTION,_("reg_STORE_QUEUE_NB_CHECK must be > 0\n"));
    715733#endif
    716                            
     734                           
    717735                            reg_STORE_QUEUE_NB_CHECK [i] --;
     736
     737                            log_printf(TRACE,Load_store_unit,FUNCTION,"              * reg_STORE_QUEUE_NB_CHECK 2 [%d] <- %d", i,reg_STORE_QUEUE_NB_CHECK [i]);
     738
    718739                            //i=(i+1)%_param->_size_store_queue;
    719740                          }
     741                       
     742                        _load_queue[index_load_queue]._store_queue_empty = true; // end of check
    720743                      }
    721744                  }
    … …  
    856879                    _store_queue [index]._load_queue_ptr_write = (not _param->_have_port_load_queue_ptr)?0:PORT_READ(in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE[internal_MEMORY_IN_PORT]);
    857880                    _store_queue [index]._address              = address;
     881                    _store_queue [index]._send_commit          = false;
    858882
    859883                    // reordering data
    … …  
    895919                _speculative_access_queue [index]._load_queue_ptr_write = (not _param->_have_port_load_queue_ptr)?0:PORT_READ(in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE[internal_MEMORY_IN_PORT]);
    896920                _speculative_access_queue [index]._store_queue_ptr_write= PORT_READ(in_MEMORY_IN_STORE_QUEUE_PTR_WRITE[internal_MEMORY_IN_PORT]);
     921                _speculative_access_queue [index]._store_queue_ptr_read = PORT_READ(in_MEMORY_IN_STORE_QUEUE_PTR_READ [internal_MEMORY_IN_PORT]);
     922                _speculative_access_queue [index]._store_queue_empty    = PORT_READ(in_MEMORY_IN_STORE_QUEUE_EMPTY    [internal_MEMORY_IN_PORT]);
    897923                _speculative_access_queue [index]._address              = address;
    898924                // NOTE : is operation is a load, then they are a result and must write in the register file
    … …  
    954980            bool         have_exception = (exception != EXCEPTION_MEMORY_NONE);
    955981            bool         need_check= false;
     982            Tlsq_ptr_t        store_queue_ptr_write = _speculative_access_queue [internal_SPECULATIVE_ACCESS_QUEUE_PTR_READ]._store_queue_ptr_write;
     983            Tlsq_ptr_t        store_queue_ptr_read  = _speculative_access_queue [internal_SPECULATIVE_ACCESS_QUEUE_PTR_READ]._store_queue_ptr_read ;
     984            Tcontrol_t        store_queue_empty     = _speculative_access_queue [internal_SPECULATIVE_ACCESS_QUEUE_PTR_READ]._store_queue_empty    ;
    956985           
    957986            if (have_exception)
    … …  
    962991                  {
    963992                    // load and synchronisation
    964                     if (must_check(operation))
     993                    if (must_check(operation) and not store_queue_empty)
    965994                      {
    966995                        // load
    967996                        need_check = true;
     997                       
    968998                        _load_queue [ptr_write]._state = LOAD_QUEUE_WAIT_CHECK;
    969999                      }
    … …  
    9841014            Tdcache_address_t address_lsb    = (address & _param->_mask_address_lsb);
    9851015            Tdcache_address_t check_hit_byte = gen_mask_not<Tdcache_address_t>(address_lsb+(memory_size(operation)>>3)-1,address_lsb) & _param->_mask_check_hit_byte;
    986             Tlsq_ptr_t        store_queue_ptr_write = _speculative_access_queue [internal_SPECULATIVE_ACCESS_QUEUE_PTR_READ]._store_queue_ptr_write;
    9871016
    9881017            log_printf(TRACE,Load_store_unit,FUNCTION,"    * address                 : 0x%.8x", address);
    … …  
    9981027            _load_queue [ptr_write]._operation             = operation;
    9991028            _load_queue [ptr_write]._store_queue_ptr_write = store_queue_ptr_write;
     1029            _load_queue [ptr_write]._store_queue_ptr_read  = store_queue_ptr_read ;
     1030            _load_queue [ptr_write]._store_queue_empty     = store_queue_empty    ;
    10001031            _load_queue [ptr_write]._address               = address;
    10011032            _load_queue [ptr_write]._check_hit_byte        = check_hit_byte;
    … …  
    10231054
    10241055            // Only load need check
    1025             if (need_check)
     1056            if (need_check//  and not store_queue_empty
     1057                )
    10261058//             if (is_operation_memory_load(_load_queue [ptr_write]._operation))
    10271059              {
    10281060                log_printf(TRACE,Load_store_unit,FUNCTION,"    * update nb_check");
    10291061                log_printf(TRACE,Load_store_unit,FUNCTION,"      *     store_queue_ptr_write : %d",store_queue_ptr_write);
     1062                log_printf(TRACE,Load_store_unit,FUNCTION,"      *     store_queue_ptr_read  : %d",store_queue_ptr_read );
     1063                log_printf(TRACE,Load_store_unit,FUNCTION,"      *     store_queue_empty     : %d",store_queue_empty    );
    10301064                log_printf(TRACE,Load_store_unit,FUNCTION,"      * reg_STORE_QUEUE_PTR_READ  : %d",reg_STORE_QUEUE_PTR_READ);
    10311065               
    10321066                uint32_t i=store_queue_ptr_write;
    1033                 while (i!=reg_STORE_QUEUE_PTR_READ)
     1067                while (i!=store_queue_ptr_read)
    10341068                  {
    10351069                    i=((i==0)?_param->_size_store_queue:i)-1;
    … …  
    10381072                   
    10391073                    reg_STORE_QUEUE_NB_CHECK [i] ++;
     1074
     1075                    log_printf(TRACE,Load_store_unit,FUNCTION,"              * reg_STORE_QUEUE_NB_CHECK 3 [%d] <- %d", i,reg_STORE_QUEUE_NB_CHECK [i]);
    10401076                  }
    10411077              }
    … …  
    10971133
    10981134                   
    1099                     uint32_t i=_load_queue[packet_id]._store_queue_ptr_write;
    1100                     while (i!=reg_STORE_QUEUE_PTR_READ)
    1101                       {
    1102                         i=((i==0)?_param->_size_store_queue:i)-1;
    1103                        
     1135                    log_printf(TRACE,Load_store_unit,FUNCTION,"      * store_queue_ptr_write : %d", _load_queue[packet_id]._store_queue_ptr_write);
     1136                    log_printf(TRACE,Load_store_unit,FUNCTION,"      * store_queue_ptr_read  : %d", _load_queue[packet_id]._store_queue_ptr_read );
     1137                    log_printf(TRACE,Load_store_unit,FUNCTION,"      * store_queue_empty     : %d", _load_queue[packet_id]._store_queue_empty    );
     1138
     1139                    if (not _load_queue[packet_id]._store_queue_empty)
     1140                      {
     1141                        uint32_t i=_load_queue[packet_id]._store_queue_ptr_write;
     1142                       
     1143                        while (i!=_load_queue[packet_id]._store_queue_ptr_read)
     1144                          {
     1145                            i=((i==0)?_param->_size_store_queue:i)-1;
     1146                           
    11041147#ifdef DEBUG
    1105                         if (reg_STORE_QUEUE_NB_CHECK [i] == 0)
    1106                           throw ERRORMORPHEO(FUNCTION,_("reg_STORE_QUEUE_NB_CHECK must be > 0\n"));
     1148                            if (reg_STORE_QUEUE_NB_CHECK [i] == 0)
     1149                              throw ERRORMORPHEO(FUNCTION,_("reg_STORE_QUEUE_NB_CHECK must be > 0\n"));
    11071150#endif
    1108                        
    1109                         reg_STORE_QUEUE_NB_CHECK [i] --;
    1110                         //i=(i+1)%_param->_size_store_queue;
    1111                       }
     1151                           
     1152                            reg_STORE_QUEUE_NB_CHECK [i] --;
     1153
     1154                            log_printf(TRACE,Load_store_unit,FUNCTION,"              * reg_STORE_QUEUE_NB_CHECK 4 [%d] <- %d", i,reg_STORE_QUEUE_NB_CHECK [i]);
     1155
     1156                            //i=(i+1)%_param->_size_store_queue;
     1157                          }
     1158                        _load_queue[packet_id]._store_queue_empty = true; // end of check
     1159
     1160                      }
    11121161                  }
    11131162                else
    … …  
    11501199            uint32_t j = (reg_STORE_QUEUE_PTR_READ+i)%_param->_size_store_queue;
    11511200
    1152             log_printf(TRACE,Load_store_unit,FUNCTION,"    [%.4d] %.4d %.4d %.4d, %.4d, %.4d, %.4d, %.8x %.8x, %.2d, %.2d %s",
     1201            log_printf(TRACE,Load_store_unit,FUNCTION,"    [%.4d] %.4d %.4d %.4d, %.4d, %.4d, %.4d, %.8x %.8x, %.2d %.1d, %.2d %s",
    11531202                       j,
    11541203                       _store_queue[j]._context_id          ,
    … …  
    11631212                     //_store_queue[j]._num_reg_rd          ,
    11641213                       _store_queue[j]._exception           ,
     1214                       _store_queue[j]._send_commit         ,
    11651215                       reg_STORE_QUEUE_NB_CHECK  [j]        ,
    11661216                       toString(_store_queue[j]._state).c_str());
    … …  
    11741224            uint32_t j = (*_speculative_access_queue_control)[i];
    11751225
    1176             log_printf(TRACE,Load_store_unit,FUNCTION,"    [%.4d] %.4d %.4d %.4d, %.4d, %.4d, %.4d %.4d, %.8x, %.1d %.4d, %.2d, %s",
     1226            log_printf(TRACE,Load_store_unit,FUNCTION,"    [%.4d] %.4d %.4d %.4d, %.4d, %.4d, %.4d %.4d %.4d %.1d, %.8x, %.1d %.4d, %.2d, %s",
    11771227                       j,
    11781228                       _speculative_access_queue[j]._context_id          ,
    … …  
    11831233                       _speculative_access_queue[j]._load_queue_ptr_write,
    11841234                       _speculative_access_queue[j]._store_queue_ptr_write,
     1235                       _speculative_access_queue[j]._store_queue_ptr_read ,
     1236                       _speculative_access_queue[j]._store_queue_empty    ,
    11851237                       _speculative_access_queue[j]._address             ,
    11861238                       _speculative_access_queue[j]._write_rd            ,
    … …  
    11981250            uint32_t j = i;
    11991251
    1200             log_printf(TRACE,Load_store_unit,FUNCTION,"    [%.4d] %.4d %.4d %.4d, %.4d, %.4d, %.4d, %.8x %.1x %.1d %.2d %.1d %.2d, %.8x, %.1d %.4d, %.2d, %s",
     1252            log_printf(TRACE,Load_store_unit,FUNCTION,"    [%.4d] %.4d %.4d %.4d, %.4d, %.4d, %.4d %.4d %.1d, %.8x %.1x %.1d %.2d %.1d %.2d, %.8x, %.1d %.4d, %.2d, %s",
    12011253                       j,
    12021254                       _load_queue[j]._context_id          ,
    … …  
    12061258                       _load_queue[j]._operation           ,
    12071259                       _load_queue[j]._store_queue_ptr_write,
     1260                       _load_queue[j]._store_queue_ptr_read ,
     1261                       _load_queue[j]._store_queue_empty    ,
    12081262                       _load_queue[j]._address             ,
    12091263                       _load_queue[j]._check_hit_byte      ,
Note: See TracChangeset for help on using the changeset viewer.