Documentation\block\ioprio.txt

Chinese translated version of Documentation\block\ioprio.txt


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]
---------------------------------------------------------------------
Documentation_i2c_i2c-stub的中文翻译


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


中文版维护者：朱锋志 [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.




IOPRIO_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水平确定为：（cpu_nice io_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.






---> 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]>