linux/Documentation/block/ioprio

 Chinese translated version of linux/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: 梁茜 <[e-mail]>

---------------------------------------------------------------------

linux/Documentation/block/ioprio的中文翻译

 

如果想评论或更新本文的内容，请直接联系原文档的维护者。如果你使用英文

交流有困难的话，也可以向中文版维护者求助。如果本翻译更新不及时或者翻

译存在问题，请联系中文版维护者。

 

中文版维护者：  梁茜 <[e-mail]>

中文版翻译者： 梁茜< [e-mail]>

中文版校译者：  梁茜 [e-mail]

 

以下为正文

___________________________________________________________________

 

 

 

 

 

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优先支持读取文件。这使得用户能够很好的过程或进程组IO，类似于已经有多年的CPU调度。本文档主要细节CFQ当前的可能性；其他IO调度程序不支持IO优先级为止。

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

CFQ implements three generic scheduling classes that determine how io is
served for a process.
CFQ实行三通用调度类，确定如何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.
oprio_class_rt：这是实时的IO类。该调度类提供比系统中的任何其他更高的优先级，从这类过程中给出的第一次访问的每一次磁盘。因此，需要使用一些护理，一个IO RT工艺能使整个系统。在RT级，有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：这是最好的努力调度班，这是任何过程，还没有建立一个特定的IO优先级默认。类的数据确定过程中会得到多少的IO带宽，它直接为CPU好水平，较粗的实现。0是最高的BE prio水平，7是最低的。CPU和IO之间好的水平被确定为之间的映射：io_nice =（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工具。使用：

# 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优先级设置继承叉上的，所以你可以使用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:
将在尽最大努力在最高优先级的调度运行ls。对于一个正在运行的进程，你可以给PID代替：

# ionice -c1 -n2 -p100

will change pid 100 to run at the realtime scheduling class, at priority 2.
将改变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], NULL, 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 <[e-mail]>