fio是如何运行的？

本文主要介绍fio是如何运行的，并且以单线程、单job为例

fio的入口在fio.c中的main函数,下面列出了main函数，此处只出示了一些调用的关键函数

 int main(int argc, char *argv[], char *envp[])
 {
     parse_options(argc, argv);
     fio_backend();
 }

在main函数中主要调用了两个关键函数，parse_options，顾名思义，就是分析options，也就是fio的参数，而fio_backend()函数则是fio进程的入口

fio_backend()函数在backend.c文件中

 int fio_backend(void)
 {
     ......
     run_threads();
     ......
 }

在fio_backend()函数中，初始化一些数据结构之后，调用了run_threads()(backend.c)函数，该函数是fio用来创建譬如I/O, verify线程等。

 /*
  * Main function for kicking off and reaping jobs, as needed.
  */
 static void run_threads(void)
 {
     ......
     todo = thread_number;
     ......
     while (todo) {
         if (td->o.use_thread) {
             ......
             ret = pthread_create(&td->thread, NULL,thread_main, td);
             ret = pthread_detach(td->thread);
             ......
     }
     ......
 }

在这个函数中，创建了thread_main线程(backend.c)，这个线程功能是，生成I/O，发送并完成I/O，记录数据等。

 /*
  * Entry point for the thread based jobs. The process based jobs end up
  * here as well, after a little setup.
  */
 static void *thread_main(void *data)
 {
     ........
      /*
       * May alter parameters that init_io_u() will use, so we need to
       * do this first.
       * 下面两个函数的主要功能是生成读写的参数，offset，len
        */
     if (init_iolog(td))
         goto err;

     if (init_io_u(td))
         goto err;
     ......
     while (keep_running(td)) {
         do_io(td);
         do_verify(td, verify_bytes);//如果需要verification的话
     }
 }

如果不考虑verify的话，下面主要看do_io(backend.c)函数。

 /*
  * Main IO worker function. It retrieves io_u's to process and queues
  * and reaps them, checking for rate and errors along the way.
  *
  * Returns number of bytes written and trimmed.
  */
 static uint64_t do_io(struct thread_data *td)
 {
     ......
     //下面是do_io的主循环，判断条件是，io_log里有生成的pos信息，而且已经iuuse的数据小于总数据，
     while ((td->o.read_iolog_file && !flist_empty(&td->io_log_list)) ||
               (!flist_empty(&td->trim_list)) || !io_bytes_exceeded(td) ||
               td->o.time_based) {
         ......
         io_u = get_io_u(td);// io_u,是一个io unit，是根据参数生成的io unit
         ......
         ret = td_io_queue(td, io_u); //将io_u提交到队列中
         switch (ret) {
         case FIO_Q_COMPLETED: //处理错误，以及同步的操作
         ......
         case FIO_Q_QUEUED://成功入队
             bytes_issued += io_u->xfer_buflen;
         case FIO_Q_BUSY: //队伍满了，重新入队
         .......
     /*
          * See if we need to complete some commands. Note that we
          * can get BUSY even without IO queued, if the system is
          * resource starved.
          */
         full = queue_full(td) || (ret == FIO_Q_BUSY && td->cur_depth);
         if (full || !td->o.iodepth_batch_complete) {
         min_evts = min(td->o.iodepth_batch_complete,td->cur_depth);
         /*
          * if the queue is full, we MUST reap at least 1 event
          */
         if (full && !min_evts)
             min_evts = ;
         do {
             ret = io_u_queued_complete(td, min_evts, bytes_done);
         } while (full && (td->cur_depth > td->o.iodepth_low));
     }
 }

上面do_io函数的关键入队函数td_io_queue(ioengines.c)

 int td_io_queue(struct thread_data *td, struct io_u *io_u)
 {
     ......
     ret = td->io_ops->queue(td, io_u);
     ......
     else if (ret == FIO_Q_QUEUED) {
         int r;
         if (ddir_rw(io_u->ddir)) {
             td->io_u_queued++;
             td->ts.total_io_u[io_u->ddir]++;
         }
          if (td->io_u_queued >= td->o.iodepth_batch) {
              r = td_io_commit(td);
              if (r < )
                  return r;
          }
     }
 }
 int td_io_commit(struct thread_data *td)
 {
     ......
     int ret;
     if (td->io_ops->commit) {
         ret = td->io_ops->commit(td);
     }
     ......
     return ;
 }

对于td->iops，它是在各个engines中定义了，以libaio(/engines/libaio.c)为例，调用的函数就是相应engines里对应的函数

 static struct ioengine_ops ioengine = {
     .name            = "libaio",
     .version        = FIO_IOOPS_VERSION,
     .init            = fio_libaio_init,
     .prep            = fio_libaio_prep,
     .queue            = fio_libaio_queue,
     .commit            = fio_libaio_commit,
     .cancel            = fio_libaio_cancel,
     .getevents        = fio_libaio_getevents,
     .event            = fio_libaio_event,
     .cleanup        = fio_libaio_cleanup,
     .open_file        = generic_open_file,
     .close_file        = generic_close_file,
     .get_file_size        = generic_get_file_size,
     .options        = options,
     .option_struct_size    = sizeof(struct libaio_options),
 };

对于reap流程里的io_u_queued_complete(io_u.c)函数

 /*
  * Called to complete min_events number of io for the async engines.
  */
 int io_u_queued_complete(struct thread_data *td, int min_evts,
              uint64_t *bytes)
 {
     ......

     ret = td_io_getevents(td, min_evts, td->o.iodepth_batch_complete, tvp);
     ......
 }

 int td_io_getevents(struct thread_data *td, unsigned int min, unsigned int max,
             struct timespec *t)
 {
     int r = ;

     if (min >  && td->io_ops->commit) {
         r = td->io_ops->commit(td);
         if (r < )
             goto out;
     }
     if (max > td->cur_depth)
         max = td->cur_depth;
     if (min > max)
         max = min;

     r = ;
     if (max && td->io_ops->getevents)
         r = td->io_ops->getevents(td, min, max, t);
 out:
     ......
     return r;
 }    

这里调用的getevents也是各个engines里定义的函数