static
ulint
af_get_pct_for_lsn(
/*===============*/
       lsn_t  age)   /*!< in: current age of LSN. */
{
       lsn_t  max_async_age;
       lsn_t  lsn_age_factor;
       lsn_t  af_lwm=(srv_adaptive_flushing_lwm
                       *log_get_capacity())/100;
 
       if(age<af_lwm){
              /* No adaptive flushing. */
              return(0);
       }
 
       max_async_age=log_get_max_modified_age_async();
 
       if(age<max_async_age&&!srv_adaptive_flushing){
              /* We have still not reached the max_async point and
              the user has disabled adaptive flushing. */
              return(0);
       }
 
       /* If we are here then we know that either:
       1) User has enabled adaptive flushing
       2) User may have disabled adaptive flushing but we have reached
       max_async_age. */
       lsn_age_factor=(age*100)/max_async_age;
 
       ut_ad(srv_max_io_capacity>=srv_io_capacity);
       return(static_cast<ulint>(
              ((srv_max_io_capacity/srv_io_capacity)
              *(lsn_age_factor*sqrt((double)lsn_age_factor)))
              /7.5));
}

static
ulint
af_get_pct_for_dirty()
/*==================*/
{
       ulintdirty_pct=buf_get_modified_ratio_pct();
 
       if(dirty_pct>0&&srv_max_buf_pool_modified_pct==0){
              return(100);
       }
 
       ut_a(srv_max_dirty_pages_pct_lwm
            <=srv_max_buf_pool_modified_pct);
 
       if(srv_max_dirty_pages_pct_lwm==0){
              /* The user has not set the option to preflush dirty
              pages as we approach the high water mark. */
              if(dirty_pct>srv_max_buf_pool_modified_pct){
                     /* We have crossed the high water mark of dirty
                     pages In this case we start flushing at 100% of
                     innodb_io_capacity. */
                     return(100);
              }
       }elseif(dirty_pct>srv_max_dirty_pages_pct_lwm){
              /* We should start flushing pages gradually. */
              return((dirty_pct*100)
                     /(srv_max_buf_pool_modified_pct+1));
       }
 
       return(0);
}

static
ulint
page_cleaner_flush_pages_if_needed(void)
/*====================================*/
{
       staticlsn_t         lsn_avg_rate=0;
       staticlsn_t         prev_lsn=0;
       staticlsn_t         last_lsn=0;
       staticulint         sum_pages=0;
       staticulint         last_pages=0;
       staticulint         prev_pages=0;
       staticulint         avg_page_rate=0;
       staticulint         n_iterations=0;
       ……
       cur_lsn=log_get_lsn();
 
       if(prev_lsn==0){
              /* First time around. */
              prev_lsn=cur_lsn;
              return(0);
       }
 
       if(prev_lsn==cur_lsn){
              return(0);
       }
 
       /* We update our variables every srv_flushing_avg_loops
       iterations to smooth out transition in workload. */
       if(++n_iterations>=srv_flushing_avg_loops){
 
              avg_page_rate=((sum_pages/srv_flushing_avg_loops)
                            +avg_page_rate)/2;
 
              /* How much LSN we have generated since last call. */
              lsn_rate=(cur_lsn-prev_lsn)/srv_flushing_avg_loops;
 
              lsn_avg_rate=(lsn_avg_rate+lsn_rate)/2;
 
              prev_lsn=cur_lsn;
 
              n_iterations=0;
 
              sum_pages=0;
       }
 
       oldest_lsn=buf_pool_get_oldest_modification();
 
       ut_ad(oldest_lsn<=log_get_lsn());
 
       age=cur_lsn>oldest_lsn?cur_lsn-oldest_lsn:0;
 
       pct_for_dirty=af_get_pct_for_dirty();
       pct_for_lsn=af_get_pct_for_lsn(age);
 
       pct_total=ut_max(pct_for_dirty,pct_for_lsn);
 
       /* Cap the maximum IO capacity that we are going to use by
       max_io_capacity. */
       n_pages=(PCT_IO(pct_total)+avg_page_rate)/2;
 
       if(n_pages>srv_max_io_capacity){
              n_pages=srv_max_io_capacity;
       }
 
       if(last_pages&&cur_lsn-last_lsn>lsn_avg_rate/2){
              age_factor=static_cast<int>(prev_pages/last_pages);
       }
       ……
       prev_pages=n_pages;
       n_pages=page_cleaner_do_flush_batch(
              n_pages,oldest_lsn+lsn_avg_rate*(age_factor+1));
 
       last_lsn=cur_lsn;
       last_pages=n_pages+1;
 
       ……
 
       if(n_pages){
              ……
              sum_pages+=n_pages;
       }
 
       return(n_pages);
}