Ignore:
Timestamp:
Dec 16, 2008, 5:24:26 PM (16 years ago)
Author:
rosiere
Message:

1) Update Prediction Table - New architecture (systemC) done (and tested) -> need change interface in top level
2) Change documentation on VHDL generation
3) Change VHDL constant (case std_logic and std_logic_vector)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src/Update_Prediction_Table_transition.cpp

    r94 r95  
    4444            reg_UPT_BOTTOM           [i] = 0;
    4545            reg_UPT_TOP              [i] = 0;
     46            reg_UPT_TOP_EVENT        [i] = 0;
    4647            reg_UPT_UPDATE           [i] = 0;
    4748                                                                                   
    … …  
    8788            {
    8889              uint32_t bottom = reg_UPT_BOTTOM [i];
    89              
     90              bool     end_ok = (reg_UPDATE_PREDICTION_TABLE [i][bottom]._state == UPDATE_PREDICTION_STATE_END_OK);
     91              bool     end_ko = (reg_UPDATE_PREDICTION_TABLE [i][bottom]._state == UPDATE_PREDICTION_STATE_END_KO);
     92
    9093              // Test if state is end
    91               if (reg_UPDATE_PREDICTION_TABLE [i][bottom]._state == UPDATE_PREDICTION_STATE_END)
     94              if (end_ok or end_ko)
    9295                {
    9396                  log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * UPT [%d][%d]",i,bottom);
    … …  
    9699                  // Free slot
    97100                  reg_UPDATE_PREDICTION_TABLE [i][bottom]._state = UPDATE_PREDICTION_STATE_EMPTY;
     101
    98102                  // Update pointer
    99103                  reg_UPT_BOTTOM [i] = (bottom+1)%_param->_size_upt_queue[i];
     104//                   if (bottom = reg_UPT_UPDATE [i])
     105//                     reg_UPT_UPDATE [i] = reg_UPT_BOTTOM [i];
     106                  if (end_ko) // free
     107                    {
     108                      reg_UPT_TOP    [i] = reg_UPT_TOP_EVENT [i];
     109                      reg_UPT_UPDATE [i] = reg_UPT_TOP_EVENT [i];
     110                    }
    100111                }
    101112            }
    … …  
    299310
    300311              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * BRANCH_COMPLETE[%d] - Accepted",i);
    301               log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * context : %d",context);
    302               log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * depth   : %d",depth);
    303               log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * miss    : %d",miss);
     312              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * context    : %d",context);
     313              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * depth      : %d",depth);
     314              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * miss       : %d",miss);
    304315             
    305316              if (miss)
    … …  
    312323                  uint32_t top        = reg_UPT_TOP [context];
    313324                  uint32_t new_update = ((top==0)?_param->_size_upt_queue[context]:top)-1;
     325
     326                  log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * top        : %d",top);
     327                  log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * new_update : %d",new_update);
     328
    314329                  for (uint32_t j=(depth+1)%_param->_size_upt_queue[context];
    315330                                j!=top;
    … …  
    317332                    reg_UPDATE_PREDICTION_TABLE [context][j]._state = UPDATE_PREDICTION_STATE_EVENT;
    318333                 
    319                   // TOP is next write slot : last slot is TOP-1
    320                   reg_UPT_UPDATE [context] = new_update;
    321                  
    322 //                reg_UPT_BOTTOM [context];
    323                   reg_UPT_TOP    [context] = depth;
     334                 
     335//                reg_UPT_BOTTOM    [context];
     336                  reg_UPT_TOP       [context] = depth;
     337                  reg_UPT_TOP_EVENT [context] = top;
    324338
    325339#ifdef DEBUG_TEST
    … …  
    331345                  reg_UPDATE_PREDICTION_TABLE [context][depth]._state = UPDATE_PREDICTION_STATE_KO;
    332346                 
    333 
    334                   Taddress_t          address_src = reg_UPDATE_PREDICTION_TABLE [context][depth]._address_src;
     347                  Taddress_t    address_src         = reg_UPDATE_PREDICTION_TABLE [context][depth]._address_src;
     348                  event_state_t event_state         = reg_EVENT_STATE [context];
     349                  bool          previous_update_ras = (event_state == EVENT_STATE_FLUSH_UPT);
     350                  bool          update_ras          = (new_update != depth);
     351
     352                  log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * update_ras : %d",update_ras);
    335353
    336354                  if (reg_UFPT_NB_NEED_UPDATE [context] > 0)
    … …  
    341359                  else
    342360                    {
    343                       log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * EVENT [%d] <- EVENT_STATE_FLUSH_UFPT_RAS (branch_complete - miss)",context);
    344                       // have ras prediction ?
    345                       reg_EVENT_STATE [context] = (new_update!=depth)?EVENT_STATE_FLUSH_UPT_RAS:EVENT_STATE_UPDATE_CONTEXT;
    346                     }
     361                      if (not previous_update_ras)
     362                        {
     363                          // have ras prediction ?
     364                          log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * EVENT [%d] <- EVENT_STATE_FLUSH_UPT (branch_complete - miss)",context);
     365
     366                          reg_EVENT_STATE [context] = EVENT_STATE_FLUSH_UPT;
     367             
     368                        }
     369                    }
     370
     371                  if (not previous_update_ras)
     372                    {
     373                      reg_UPT_UPDATE [context]  = new_update;
     374                    }
     375                  // else no update
    347376
    348377                  reg_EVENT_ADDRESS_SRC     [context] = address_src; // delay_slot is compute in Context_State
    … …  
    370399        // =====[ UPDATE ]====================================================
    371400        // ===================================================================
    372         for (uint32_t i=0; i<_param->_nb_inst_update; i++)
    373           if ((internal_UPDATE_VAL[i] and PORT_READ(in_UPDATE_ACK [i])) or
    374               (internal_UPDATE_VAL_WITHOUT_ACK [i]))
    375             {
    376               Tcontext_t context = internal_UPDATE_CONTEXT_ID [i];
    377               Tdepth_t   depth   = internal_UPDATE_DEPTH      [i];
    378               log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * UPDATE[%d] - Accepted",i);
    379               log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * context : %d",context);
    380               log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * depth   : %d",depth);
    381 
    382               if (internal_UPDATE_FROM_UFPT [i])
     401        {
     402          bool can_continue [_param->_nb_context];
     403          for (uint32_t i=0; i<_param->_nb_context; ++i)
     404            can_continue [i] = true;
     405
     406          for (uint32_t i=0; i<_param->_nb_inst_update; i++)
     407            {
     408              Tcontext_t context   = internal_UPDATE_CONTEXT_ID [i];
     409
     410              if ((internal_UPDATE_VAL[i] and PORT_READ(in_UPDATE_ACK [i])) or
     411                  (internal_UPDATE_VAL_WITHOUT_ACK [i] and can_continue [context]))
    383412                {
    384                 // if free a slot, also all queue is updated
    385                 // Last slot ?
    386                 if (reg_UFPT_UPDATE [context] == reg_UFPT_BOTTOM [context])
    387                   switch (reg_EVENT_STATE [context])
    388                     {
    389                     case EVENT_STATE_FLUSH_UFPT         : reg_EVENT_STATE [context] = EVENT_STATE_UPDATE_CONTEXT; break;
    390                     case EVENT_STATE_FLUSH_UFPT_AND_UPT : reg_EVENT_STATE [context] = (reg_UPT_UPDATE[context]!=reg_UPT_TOP[context])?EVENT_STATE_FLUSH_UPT_RAS:EVENT_STATE_UPDATE_CONTEXT;  break;
    391                     default : break;
    392                     }
    393                
    394                   log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * Update Fetch Prediction Table");
    395                  
    396                   // Change state
    397 #ifdef DEBUG_TEST
    398                   if (reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._state != UPDATE_FETCH_PREDICTION_STATE_EVENT)
    399                     throw ERRORMORPHEO(FUNCTION,_("Update : invalid ufpt state."));
    400 #endif
    401 
    402                   log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * UFPT [%d][%d].state <- UPDATE_FETCH_PREDICTION_STATE_END (update)",context,depth);
    403 
    404                   reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._state = UPDATE_FETCH_PREDICTION_STATE_END;
    405 
    406 
    407                   // Update pointer
    408                   log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * reg_UFPT_UPDATE (before) : %d",reg_UFPT_UPDATE [context]);
    409                   reg_UFPT_UPDATE [context] = ((depth==0)?_param->_size_ufpt_queue[context]:depth)-1;
    410                   log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * reg_UFPT_UPDATE (after ) : %d",reg_UFPT_UPDATE [context]);
    411                   // Free a register that need update ?
    412                   if (need_update(reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._condition))
    413                     reg_UFPT_NB_NEED_UPDATE [context] --;
     413                  Tdepth_t   depth     = internal_UPDATE_DEPTH      [i];
     414                 
     415                  log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * UPDATE[%d] - Accepted",i);
     416                  log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * context : %d",context);
     417                  log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * depth   : %d",depth);
     418                 
     419                  if (internal_UPDATE_FROM_UFPT [i])
     420                    {
     421                      // if free a slot, also all queue is updated
     422                      // Last slot ?
     423                      if (reg_UFPT_UPDATE [context] == reg_UFPT_BOTTOM [context])
     424                        switch (reg_EVENT_STATE [context])
     425                          {
     426                          case EVENT_STATE_FLUSH_UFPT             : reg_EVENT_STATE [context] = EVENT_STATE_UPDATE_CONTEXT; break;
     427                            // impossible to have an update on ufpt and reg_upt_update>reg_upt_top
     428                          case EVENT_STATE_FLUSH_UFPT_AND_UPT : reg_EVENT_STATE [context] = EVENT_STATE_FLUSH_UPT ; break;
     429                          default : break;
     430                          }
     431                     
     432                      log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * Update Fetch Prediction Table");
     433                     
     434                      // Change state
     435#ifdef DEBUG_TEST
     436                      if (reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._state != UPDATE_FETCH_PREDICTION_STATE_EVENT)
     437                        throw ERRORMORPHEO(FUNCTION,_("Update : invalid ufpt state."));
     438#endif
     439                     
     440                      log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * UFPT [%d][%d].state <- UPDATE_FETCH_PREDICTION_STATE_END (update)",context,depth);
     441                     
     442                      reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._state = UPDATE_FETCH_PREDICTION_STATE_END;
     443                     
     444                     
     445                      // Update pointer
     446                      log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * reg_UFPT_UPDATE (before) : %d",reg_UFPT_UPDATE [context]);
     447                      reg_UFPT_UPDATE [context] = ((depth==0)?_param->_size_ufpt_queue[context]:depth)-1;
     448                      log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * reg_UFPT_UPDATE (after ) : %d",reg_UFPT_UPDATE [context]);
     449                      // Free a register that need update ?
     450                      if (need_update(reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._condition))
     451                        reg_UFPT_NB_NEED_UPDATE [context] --;
     452                    }
     453                  else
     454                    {
     455                      log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * Update Prediction Table");
     456                     
     457                      // Change state
     458#ifdef DEBUG_TEST
     459                      if (internal_UPDATE_RAS [i])
     460                        {
     461                          if ((reg_UPDATE_PREDICTION_TABLE [context][depth]._state != UPDATE_PREDICTION_STATE_EVENT) and
     462                              (reg_UPDATE_PREDICTION_TABLE [context][depth]._state != UPDATE_PREDICTION_STATE_KO   ))
     463                            throw ERRORMORPHEO(FUNCTION,_("Update : invalid upt state."));
     464                        }
     465                      else
     466                        {
     467                          if (reg_UPDATE_PREDICTION_TABLE [context][depth]._state != UPDATE_PREDICTION_STATE_OK   )
     468                            throw ERRORMORPHEO(FUNCTION,_("Update : invalid upt state."));
     469                        }
     470#endif
     471
     472//                    bool have_event = ((reg_UPDATE_PREDICTION_TABLE [context][depth]._state == UPDATE_PREDICTION_STATE_KO) or
     473//                                       (reg_UPDATE_PREDICTION_TABLE [context][depth]._state == UPDATE_PREDICTION_STATE_EVENT));
     474                      bool ko     = (reg_UPDATE_PREDICTION_TABLE [context][depth]._state == UPDATE_PREDICTION_STATE_KO);
     475
     476                      // Have an update, test the state to transiste to the good state
     477                      if (ko)
     478                        {
     479                          log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * UPT  [%d][%d].state <- UPDATE_PREDICTION_STATE_END_KO (update)",context,depth);
     480                         
     481                          reg_UPDATE_PREDICTION_TABLE [context][depth]._state = UPDATE_PREDICTION_STATE_END_KO;
     482                        }
     483                      else
     484                        {
     485                          log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * UPT  [%d][%d].state <- UPDATE_PREDICTION_STATE_END_OK (update)",context,depth);
     486                         
     487                          reg_UPDATE_PREDICTION_TABLE [context][depth]._state = UPDATE_PREDICTION_STATE_END_OK;
     488                        }
     489                     
     490                      // Update pointer
     491                      //  * if update RAS : update pointer is decreaste until it equal at top pointer
     492                      if (internal_UPDATE_RAS [i])
     493                        {
     494                          // if end_event, restart too bottom, else decrease pointer
     495                          bool end_event  = (reg_UPT_UPDATE [context] == reg_UPT_TOP [context]);
     496                         
     497                          reg_UPT_UPDATE [context] = (end_event)?reg_UPT_BOTTOM[context]:(((depth==0)?_param->_size_upt_queue[context]:depth)-1);
     498                          if (end_event)
     499                            {
     500                              reg_UPT_UPDATE [context] = reg_UPT_BOTTOM[context];
     501                              reg_EVENT_STATE [context] = EVENT_STATE_UPDATE_CONTEXT;
     502                            }
     503                          else
     504                            {
     505                              reg_UPT_UPDATE [context] = (((depth==0)?_param->_size_upt_queue[context]:depth)-1);
     506                            }
     507                        }
     508                      else
     509                        {
     510                          // increase pointer
     511                          reg_UPT_UPDATE [context] = (depth+1)%_param->_size_upt_queue[context];
     512                        }
     513                     
     514                      // Free the branch with no accurate ?
     515                      if (reg_UPDATE_PREDICTION_TABLE [context][depth]._is_accurate == false)
     516                        reg_IS_ACCURATE [context] = true;
     517                    }
    414518                }
    415519              else
    416                 {
    417                   log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * Update Prediction Table");
    418                  
    419                   // Change state
    420 #ifdef DEBUG_TEST
    421                   if (internal_UPDATE_RAS [i])
    422                     {
    423                       if (reg_UPDATE_PREDICTION_TABLE [context][depth]._state != UPDATE_PREDICTION_STATE_EVENT)
    424                         throw ERRORMORPHEO(FUNCTION,_("Update : invalid upt state."));
    425                     }
    426                   else
    427                     {
    428                       if ((reg_UPDATE_PREDICTION_TABLE [context][depth]._state != UPDATE_PREDICTION_STATE_OK   ) and
    429                           (reg_UPDATE_PREDICTION_TABLE [context][depth]._state != UPDATE_PREDICTION_STATE_KO   ))
    430                         throw ERRORMORPHEO(FUNCTION,_("Update : invalid upt state."));
    431                     }
    432 #endif
    433 
    434                   log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * UPT  [%d][%d].state <- UPDATE_PREDICTION_STATE_END (update)",context,depth);
    435 
    436                   reg_UPDATE_PREDICTION_TABLE [context][depth]._state = UPDATE_PREDICTION_STATE_END;
    437 
    438                   // Update pointer
    439                   bool end_event = (reg_UPT_UPDATE [context] == reg_UPT_TOP [context]);
    440 
    441                   if (internal_UPDATE_RAS [i])
    442                     {
    443                       reg_UPT_UPDATE [context] = (end_event)?reg_UPT_BOTTOM[context]:(((depth==0)?_param->_size_upt_queue[context]:depth)-1);
    444                     }
    445                   else
    446                     {
    447                       reg_UPT_UPDATE [context] = (depth+1)%_param->_size_upt_queue[context];
    448                     }
    449                  
    450                   // End and event ?
    451                   if (end_event and
    452                       (reg_EVENT_STATE [context] != EVENT_STATE_OK))
    453                     {
    454                       reg_EVENT_STATE [context] = EVENT_STATE_UPDATE_CONTEXT;
    455                     }
    456 
    457                   // Free the branch with no accurate ?
    458                   if (reg_UPDATE_PREDICTION_TABLE [context][depth]._is_accurate == false)
    459                     reg_IS_ACCURATE [context] = true;
    460                 }
    461             }
     520                can_continue [context] = false;
     521            }
    462522       
    463         // Round robin
    464         reg_UPDATE_PRIORITY = (reg_UPDATE_PRIORITY+1)%_param->_nb_context;
     523          // Round robin
     524          reg_UPDATE_PRIORITY = (reg_UPDATE_PRIORITY+1)%_param->_nb_context;
     525        }
    465526
    466527        // ===================================================================
    … …  
    470531          if (internal_BRANCH_EVENT_VAL [i] and PORT_READ(in_BRANCH_EVENT_ACK [i]))
    471532            {
    472               log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * UPDATE[%d] - Accepted",i);
     533              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * BRANCH_EVENT [%d] - Accepted",i);
    473534
    474535#ifdef DEBUG_TEST
    … …  
    478539             
    479540              // Change state
    480               log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * EVENT [%d] <- EVENT_STATE_OK (branch_event)",i);
     541              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * EVENT [%d] <- EVENT_STATE_WAIT_END_EVENT (branch_event)",i);
    481542             
    482               reg_EVENT_STATE [i] = EVENT_STATE_OK;
     543              reg_EVENT_STATE [i] = EVENT_STATE_WAIT_END_EVENT;
    483544            }
     545
     546        // ===================================================================
     547        // =====[ EVENT ]=====================================================
     548        // ===================================================================
     549        for (uint32_t i=0; i<_param->_nb_context; ++i)
     550          {
     551            //----------------------------------------------------------------
     552            // Cases
     553            //----------------------------------------------------------------
     554            //   * EVENT_TYPE_NONE               - nothing
     555            //   * EVENT_TYPE_MISS_SPECULATION   
     556            //     * EVENT_STATE_END             - Change state, reset pointer
     557            //   * EVENT_TYPE_EXCEPTION          -
     558            //     * EVENT_STATE_EVENT           - Flush upft and upt
     559            //     * EVENT_STATE_END             - Change state, reset pointer
     560            //   * EVENT_TYPE_BRANCH_NO_ACCURATE - nothing : manage in decod and update
     561            //   * EVENT_TYPE_SPR_ACCESS         - nothing
     562            //   * EVENT_TYPE_MSYNC              - nothing
     563            //   * EVENT_TYPE_PSYNC              - nothing
     564            //   * EVENT_TYPE_CSYNC              - nothing
     565
     566            Tevent_state_t event_state = PORT_READ(in_EVENT_STATE [i]);
     567            Tevent_type_t  event_type  = PORT_READ(in_EVENT_TYPE  [i]);
     568//             Tdepth_t       depth       = PORT_READ(in_EVENT_DEPTH [i]);
     569           
     570            // Test if end of miss
     571            if ((event_state == EVENT_STATE_END) and
     572                (event_type  == EVENT_TYPE_MISS_SPECULATION))
     573              {
     574                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * EVENT");
     575                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * state : EVENT_STATE_END");
     576                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * type  : EVENT_TYPE_MISS_SPECULATION");
     577
     578#ifdef DEBUG_TEST
     579                if (reg_EVENT_STATE [i] != EVENT_STATE_WAIT_END_EVENT)
     580                  throw ERRORMORPHEO(FUNCTION,_("Event : invalid event state."));
     581#endif
     582               
     583                // Change state
     584                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * EVENT [%d] <- EVENT_STATE_OK (event)",i);
     585               
     586                reg_EVENT_STATE [i] = EVENT_STATE_OK;
     587
     588//                 uint32_t bottom = reg_UPT_BOTTOM [i];
     589
     590//                 reg_UPT_TOP    [i] = bottom;
     591//                 reg_UPT_UPDATE [i] = bottom;
     592              }
     593          }
    484594
    485595        // ===================================================================
    … …  
    561671        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"      * reg_UPT_BOTTOM          : %d",reg_UPT_BOTTOM         [i]);
    562672        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"      * reg_UPT_TOP             : %d",reg_UPT_TOP            [i]);
     673        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"      * reg_UPT_TOP_EVENT       : %d",reg_UPT_TOP_EVENT      [i]);
    563674        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"      * reg_UPT_UPDATE          : %d",reg_UPT_UPDATE         [i]);
    564675        for (uint32_t j=0; j<_param->_size_upt_queue[i]; j++)
Note: See TracChangeset for help on using the changeset viewer.