bl邪恶h全彩漫画集,石台县政府网,vagaa哇嘎搜黄网站
本文主要介绍fio是如何运行的，并且以单线程、单job为例
fio的入口在fio.c中的main函数,下面列出了main函数，此处只出示了一些调用的关键函数
我要评论1 int main(int argc, char *argv[], char *envp[])
2 {
3 parse_options(argc, argv);
4 fio_backend();
5 }
在main函数中主要调用了两个关键函数，parse_options，顾名思义，就是分析options，也就是fio的参数，而fio_backend()函数则是fio进程的入口
fio_backend()函数在backend.c文件中
1 int fio_backend(void)
2 {
3 ......
4 run_threads();
5 ......
6 }
在fio_backend()函数中，初始化一些数据结构之后，调用了run_threads()(backend.c)函数，该函数是fio用来创建譬如i/o, verify线程等。
1 /*
2 * main function for kicking off and reaping jobs, as needed.
3 */
4 static void run_threads(void)
5 {
6 ......
7 todo = thread_number;
8 ......
9 while (todo) {
10 if (td->o.use_thread) {
11 ......
12 ret = pthread_create(&td->thread, null,thread_main, td);
13 ret = pthread_detach(td->thread);
14 ......
15 }
16 ......
17 }
在这个函数中，创建了thread_main线程(backend.c)，这个线程功能是，生成i/o，发送并完成i/o，记录数据等。
1 /*
2 * entry point for the thread based jobs. the process based jobs end up
3 * here as well, after a little setup.
4 */
5 static void *thread_main(void *data)
6 {
7 ........
8 /*
9 * may alter parameters that init_io_u() will use, so we need to
10 * do this first.
11 * 下面两个函数的主要功能是生成读写的参数，offset，len
12 */
13 if (init_iolog(td))
14 goto err;
15
16 if (init_io_u(td))
17 goto err;
18 ......
19 while (keep_running(td)) {
20 do_io(td);
21 do_verify(td, verify_bytes);//如果需要verification的话
22 }
23 }
如果不考虑verify的话，下面主要看do_io(backend.c)函数。
1 /*
2 * main io worker function. it retrieves io_u's to process and queues
3 * and reaps them, checking for rate and errors along the way.
4 *
5 * returns number of bytes written and trimmed.
6 */
7 static uint64_t do_io(struct thread_data *td)
8 {
9 ......
10 //下面是do_io的主循环，判断条件是，io_log里有生成的pos信息，而且已经iuuse的数据小于总数据，
11 while ((td->o.read_iolog_file && !flist_empty(&td->io_log_list)) ||
12 (!flist_empty(&td->trim_list)) || !io_bytes_exceeded(td) ||
13 td->o.time_based) {
14 ......
15 io_u = get_io_u(td);// io_u,是一个io unit，是根据参数生成的io unit
16 ......
17 ret = td_io_queue(td, io_u); //将io_u提交到队列中
18 switch (ret) {
19 case fio_q_completed: //处理错误，以及同步的操作
20 ......
21 case fio_q_queued://成功入队
22 bytes_issued += io_u->xfer_buflen;
23 case fio_q_busy: //队伍满了，重新入队
24 .......
25 /*
26 * see if we need to complete some commands. note that we
27 * can get busy even without io queued, if the system is
28 * resource starved.
29 */
30 full = queue_full(td) || (ret == fio_q_busy && td->cur_depth);
31 if (full || !td->o.iodepth_batch_complete) {
32 min_evts = min(td->o.iodepth_batch_complete,td->cur_depth);
33 /*
34 * if the queue is full, we must reap at least 1 event
35 */
36 if (full && !min_evts)
37 min_evts = 1;
38 do {
39 ret = io_u_queued_complete(td, min_evts, bytes_done);
40 } while (full && (td->cur_depth > td->o.iodepth_low));
41 }
42 }
上面do_io函数的关键入队函数td_io_queue(ioengines.c)
1 int td_io_queue(struct thread_data *td, struct io_u *io_u)
2 {
3 ......
4 ret = td->io_ops->queue(td, io_u);
5 ......
6 else if (ret == fio_q_queued) {
7 int r;
8 if (ddir_rw(io_u->ddir)) {
9 td->io_u_queued++;
10 td->ts.total_io_u[io_u->ddir]++;
11 }
12 if (td->io_u_queued >= td->o.iodepth_batch) {
13 r = td_io_commit(td);
14 if (r < 0)
15 return r;
16 }
17 }
18 }
19 int td_io_commit(struct thread_data *td)
20 {
21 ......
22 int ret;
23 if (td->io_ops->commit) {
24 ret = td->io_ops->commit(td);
25 }
26 ......
27 return 0;
28 }
对于td->iops，它是在各个engines中定义了，以libaio(/engines/libaio.c)为例，调用的函数就是相应engines里对应的函数
1 static struct ioengine_ops ioengine = {
2 .name = "libaio",
3 .version = fio_ioops_version,
4 .init = fio_libaio_init,
5 .prep = fio_libaio_prep,
6 .queue = fio_libaio_queue,
7 .commit = fio_libaio_commit,
8 .cancel = fio_libaio_cancel,
9 .getevents = fio_libaio_getevents,
10 .event = fio_libaio_event,
11 .cleanup = fio_libaio_cleanup,
12 .open_file = generic_open_file,
13 .close_file = generic_close_file,
14 .get_file_size = generic_get_file_size,
15 .options = options,
16 .option_struct_size = sizeof(struct libaio_options),
17 };
对于reap流程里的io_u_queued_complete(io_u.c)函数
1 /*
2 * called to complete min_events number of io for the async engines.
3 */
4 int io_u_queued_complete(struct thread_data *td, int min_evts,
5 uint64_t *bytes)
6 {
7 ......
8
9 ret = td_io_getevents(td, min_evts, td->o.iodepth_batch_complete, tvp);
10 ......
11 }
12
13 int td_io_getevents(struct thread_data *td, unsigned int min, unsigned int max,
14 struct timespec *t)
15 {
16 int r = 0;
17
18 if (min > 0 && td->io_ops->commit) {
19 r = td->io_ops->commit(td);
20 if (r < 0)
21 goto out;
22 }
23 if (max > td->cur_depth)
24 max = td->cur_depth;
25 if (min > max)
26 max = min;
27
28 r = 0;
29 if (max && td->io_ops->getevents)
30 r = td->io_ops->getevents(td, min, max, t);
31 out:
32 ......
33 return r;
34 }
这里调用的getevents也是各个engines里定义的函数
如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复
14、Ribbon整合断路器监控Hystrix Dashboard
网友评论