Documentation/block/ioprio

Chinese translated version of Documentation/block/ioprio

If you have any comment or update to the content, please contact the
original document maintainer directly.  However, if you have a problem
communicating in English you can also ask the Chinese maintainer for
help.  Contact the Chinese maintainer if this translation is outdated
or if there is a problem with the translation.

Chinese maintainer:Hu Feijun <935620544@qq.com>
---------------------------------------------------------------------
Documentation/block/ioprio 的中文翻译

如果想评论或更新本文的内容，请直接联系原文档的维护者。如果你使用英+文
交流有困难的话，也可以向中文版维护者求助。如果本翻译更新不及时或者翻
译存在问题，请联系中文版维护者。

中文版维护者： 胡飞军  Hu Feijun <935620544@qq.com>
中文版翻译者： 胡飞军  Hu Feijun <935620544@qq.com>
中文版校译者： 胡飞军  Hu Feijun <935620544@qq.com>

以下为正文
---------------------------------------------------------------------
Block io priorities
===================
块io优先权
===================

 

Intro
-----

With the introduction of cfq v3 (aka cfq-ts or time sliced cfq), basic io
priorities are supported for reads on files.  This enables users to io nice
processes or process groups, similar to what has been possible with cpu
scheduling for ages.  This document mainly details the current possibilities
with cfq; other io schedulers do not support io priorities thus far.

简介
-----
通过引入cfq v3（又名cfq-ts或时间片cfq），可以使基本io priorities读对文件。
能够实现对进程或进程组的io，这和已经实现很久的cpu调度类似。这分文档主要详细
讲述了当前cfq能够实现的功能；其它io调度器目前还不支持io priorities。

Scheduling classes
------------------
调度类
------------------

CFQ implements three generic scheduling classes that determine how io is
served for a process.
CFQ实现了3类调度类，这些调度类决定了io如何为进程服务。

IOPRIO_CLASS_RT: This is the realtime io class. This scheduling class is given
higher priority than any other in the system, processes from this class are
given first access to the disk every time. Thus it needs to be used with some
care, one io RT process can starve the entire system. Within the RT class,
there are 8 levels of class data that determine exactly how much time this
process needs the disk for on each service. In the future this might change
to be more directly mappable to performance, by passing in a wanted data
rate instead.
IOPRIO_CLASS_RT: 实时io类。这个调度类是系统中优先级最高的，来自这个调度类的
进程每次都能够第一个访问磁盘，因此必须要小心使用，因为一个io实时进程可能
导致整个系统饿死。在实时类中，一共有8个层次的类数据，这些类数据决定了每次磁盘
需要为进程服务的时间。将来这种映射关系可能会改变，通过所需的数据率直接映射到实
际任务。

IOPRIO_CLASS_BE: This is the best-effort scheduling class, which is the default
for any process that hasn't set a specific io priority. The class data
determines how much io bandwidth the process will get, it's directly mappable
to the cpu nice levels just more coarsely implemented. 0 is the highest
BE prio level, 7 is the lowest. The mapping between cpu nice level and io
nice level is determined as: io_nice = (cpu_nice + 20) / 5.
IOPRIO_CLASS_BE:best-effort调度类。所有没有设置具体的io优先权的进程都将此作为默认
的调度类。这个类数据决定了进程将会得到多少io带宽。这些数据和cpu nice层直接映射，但
较粗略。0是最高的BE优先能，7是最低的。cpu nice层与io nice层之间的映射关系可以用公式
ce = (cpu_nice + 20) / 5 计算。

IOPRIO_CLASS_IDLE: This is the idle scheduling class, processes running at this
level only get io time when no one else needs the disk. The idle class has no
class data, since it doesn't really apply here.
IOPRIO_CLASS_IDLE：闲置调度类。在这个层运行的进程只有磁盘空闲的时候才能得到io时间。
但现实中并不使用闲置调度类，因此闲置调度类没有类数据。

Tools
-----
工具
-----

See below for a sample ionice tool. Usage:
以下是一个例子ionice tool. Usage

# ionice -c<class> -n<level> -p<pid>

# ionice -c<class> -n<level> -p<pid>

If pid isn't given, the current process is assumed. IO priority settings
are inherited on fork, so you can use ionice to start the process at a given
level:

如果没有pid，那当前的进程就是假定的。IO 优先级设定是继承于fork的，因此你可以用
ionice在一个给定的层启动进程：

# ionice -c2 -n0 /bin/ls

will run ls at the best-effort scheduling class at the highest priority.
For a running process, you can give the pid instead:

# ionice -c2 -n0 /bin/ls
会使ls在best-effort调度类的最高级中运行。对于正在运行的进程，你可以使用pid。

# ionice -c1 -n2 -p100

will change pid 100 to run at the realtime scheduling class, at priority 2.
# ionice -c1 -n2 -p100
这会使pid 100在实时调度类的优先级2上运行。

以下为具体例子：
---> snip ionice.c tool <---

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <getopt.h>
#include <unistd.h>
#include <sys/ptrace.h>
#include <asm/unistd.h>

extern int sys_ioprio_set(int, int, int);
extern int sys_ioprio_get(int, int);

#if defined(__i386__)
#define __NR_ioprio_set  289
#define __NR_ioprio_get  290
#elif defined(__ppc__)
#define __NR_ioprio_set  273
#define __NR_ioprio_get  274
#elif defined(__x86_64__)
#define __NR_ioprio_set  251
#define __NR_ioprio_get  252
#elif defined(__ia64__)
#define __NR_ioprio_set  1274
#define __NR_ioprio_get  1275
#else
#error "Unsupported arch"
#endif

static inline int ioprio_set(int which, int who, int ioprio)
{
 return syscall(__NR_ioprio_set, which, who, ioprio);
}

static inline int ioprio_get(int which, int who)
{
 return syscall(__NR_ioprio_get, which, who);
}

enum {
 IOPRIO_CLASS_NONE,
 IOPRIO_CLASS_RT,
 IOPRIO_CLASS_BE,
 IOPRIO_CLASS_IDLE,
};

enum {
 IOPRIO_WHO_PROCESS = 1,
 IOPRIO_WHO_PGRP,
 IOPRIO_WHO_USER,
};

#define IOPRIO_CLASS_SHIFT 13

const char *to_prio[] = { "none", "realtime", "best-effort", "idle", };

int main(int argc, char *argv[])
{
 int ioprio = 4, set = 0, ioprio_class = IOPRIO_CLASS_BE;
 int c, pid = 0;

 while ((c = getopt(argc, argv, "+n:c:p:")) != EOF) {
  switch (c) {
  case 'n':
   ioprio = strtol(optarg, NULL, 10);
   set = 1;
   break;
  case 'c':
   ioprio_class = strtol(optarg, NULL, 10);
   set = 1;
   break;
  case 'p':
   pid = strtol(optarg, NULL, 10);
   break;
  }
 }

 switch (ioprio_class) {
  case IOPRIO_CLASS_NONE:
   ioprio_class = IOPRIO_CLASS_BE;
   break;
  case IOPRIO_CLASS_RT:
  case IOPRIO_CLASS_BE:
   break;
  case IOPRIO_CLASS_IDLE:
   ioprio = 7;
   break;
  default:
   printf("bad prio class %d\n", ioprio_class);
   return 1;
 }

 if (!set) {
  if (!pid && argv[optind])
   pid = strtol(argv[optind], N---------------------------------------------------------------------------------+ULL, 10);

  ioprio = ioprio_get(IOPRIO_WHO_PROCESS, pid);

  printf("pid=%d, %d\n", pid, ioprio);

  if (ioprio == -1)
   perror("ioprio_get");
  else {
   ioprio_class = ioprio >> IOPRIO_CLASS_SHIFT;
   ioprio = ioprio & 0xff;
   printf("%s: prio %d\n", to_prio[ioprio_class], ioprio);
  }
 } else {
  if (ioprio_set(IOPRIO_WHO_PROCESS, pid, ioprio | ioprio_class << IOPRIO_CLASS_SHIFT) == -1) {
   perror("ioprio_set");
   return 1;
  }

  if (argv[optind])
   execvp(argv[optind], &argv[optind]);
 }

 return 0;
}

---> snip ionice.c tool <---

March 11 2005, Jens Axboe <jens.axboe@oracle.com>