cfq: ioprio inherit rt class
PATCH 1/1 cfq: ioprio inherit rt class
Jens, ml
I was wondering if cfq io priorities should be explicitly set to the realtime class when no io priority is specified from realtime tasks as in the following patch? (rt_task() will need to be modified to suit the PI changes in -mm)
---
Set cfq io priority class to realtime and scale the priority according to the rt priority when no io priority is explicitly set in realtime tasks.
--- block/cfq-iosched.c | 4 ++-- include/linux/ioprio.h | 12 +++++++++++- 2 files changed, 13 insertions(+), 3 deletions(-)
block/cfq-iosched.c +2 -2
@@ -1334,10 +1334,10 @@ static void cfq_init_prio_data(struct cfprintk (KERN_ERR "cfq: bad prio %x\n" , ioprio_class);case IOPRIO_CLASS_NONE :/* -* no prio set, place us in the middle of the BE classes +* Select class and ioprio according to policy and nice */ + cfqq->ioprio_class =task_policy_ioprio_class (tsk); cfqq->ioprio =task_nice_ioprio (tsk); - cfqq->ioprio_class =IOPRIO_CLASS_BE ;break ;case IOPRIO_CLASS_RT : cfqq->ioprio =task_ioprio (tsk);
include/linux/ioprio.h +11 -1
@@ -22,7 +22,7 @@* class, the default for any process. IDLE is the idle scheduling class, it * is only served when no one else is using the disk. */ -enum { +enum ioprio_class {IOPRIO_CLASS_NONE ,IOPRIO_CLASS_RT ,IOPRIO_CLASS_BE ,
@@ -51,8 +51,18 @@ static inline int task_ioprio(struct tasreturn IOPRIO_PRIO_DATA (task->ioprio); } +static inline enum ioprio_class +task_policy_ioprio_class (struct task_struct *task) +{ +if (rt_task (task)) +return IOPRIO_CLASS_RT ; +return IOPRIO_CLASS_BE ; +} +static inline int task_nice_ioprio (struct task_struct *task) { +if (rt_task (task)) +return (task->rt_priority *IOPRIO_BE_NR /MAX_RT_PRIO );return (task_nice (task) +20 ) /5 ; }
Signature · 1 line
-ck
Quoted 10 lines · Con Kolivas
Jens, ml
I was wondering if cfq io priorities should be explicitly set to the realtime class when no io priority is specified from realtime tasks as in the following patch? (
rt_task()will need to be modified to suit the PI changes in -mm)---
Set cfq io priority class to realtime and scale the priority according to the rt priority when no io priority is explicitly set in realtime tasks.
sorry, rather than this:
include/linux/ioprio.h static inline int task_ioprio(struct tas · line 65
Quoted 1 line
include/linux/ioprio.h +1
-0+return (task->rt_priority *IOPRIO_BE_NR /MAX_RT_PRIO );
it should be:
return ((MAX_RT_PRIO - task->rt_priority) * IOPRIO_BE_NR / MAX_RT_PRIO);
Signature · 1 line
-ck
Quoted 6 lines · Con Kolivas
Jens, ml
I was wondering if cfq io priorities should be explicitly set to the realtime class when no io priority is specified from realtime tasks as in the following patch? (
rt_task()will need to be modified to suit the PI changes in -mm)
Not sure. RT io needs to be considered carefully, but I guess so does RT CPU scheduling. For now I'd prefer to play it a little safer, and only inheric the priority value and not the class.
Signature · 1 line
Jens Axboe
Quoted 11 lines · Jens Axboe
Quoted 6 lines · Con Kolivas
Jens, ml
I was wondering if cfq io priorities should be explicitly set to the realtime class when no io priority is specified from realtime tasks as in the following patch? (
rt_task()will need to be modified to suit the PI changes in -mm)Not sure. RT io needs to be considered carefully, but I guess so does RT CPU scheduling. For now I'd prefer to play it a little safer, and only inheric the priority value and not the class.
The problem I envisioned with that was that realtime tasks, if they don't specify an io priority (as most current code doesn't), would basically get io priority 4 and have the same proportion as any nice 0 SCHED_NORMAL task whereas -nice tasks automatically are getting better io priority. How about givent them normal class but best priority so they are at least getting the same as nice -20?
Signature · 1 line
-ck
Quoted 5 lines · Con Kolivas
Quoted 3 lines · Jens Axboe
Not sure. RT io needs to be considered carefully, but I guess so does RT CPU scheduling. For now I'd prefer to play it a little safer, and only inheric the priority value and not the class.
Quoted 7 lines
The problem I envisioned with that was that realtime tasks, if they don't specify an io priority (as most current code doesn't), would basically get io priority 4 and have the same proportion as any nice 0
SCHED_NORMALtask whereas -nice tasks automatically are getting better io priority. How about givent them normal class but best priority so they are at least getting the same as nice -20?
Con,
Have you seen RT threads trying to disk IO 'in the wild' or is this a theoretical concern? I don't know of any such apps.
Lee
Quoted 6 lines · Lee Revell
Quoted 4 lines · Con Kolivas
Quoted 3 lines · Jens Axboe
Not sure. RT io needs to be considered carefully, but I guess so does RT CPU scheduling. For now I'd prefer to play it a little safer, and only inheric the priority value and not the class.
Quoted 8 lines
Quoted 6 lines
The problem I envisioned with that was that realtime tasks, if they don't specify an io priority (as most current code doesn't), would basically get io priority 4 and have the same proportion as any nice 0
SCHED_NORMALtask whereas -nice tasks automatically are getting better io priority. How about givent them normal class but best priority so they are at least getting the same as nice -20?Have you seen RT threads trying to disk IO 'in the wild'
I'd be surprised, to be sure.
Quoted 2 lines
or is this a
theoretical concern? I don't know of any such apps.
Is it hard to do? If not, as this isn't forbidden as such, it makes sense IMVHO.
Signature · 4 lines
Dr. Horst H. von Brand User #22616 counter.li.org Departamento de Informatica Fono: +56 32 654431 Universidad Tecnica Federico Santa Maria +56 32 654239 Casilla 110-V, Valparaiso, Chile Fax: +56 32 797513
Quoted 13 lines · Lee Revell
Quoted 11 lines · Con Kolivas
Quoted 3 lines · Jens Axboe
Not sure. RT io needs to be considered carefully, but I guess so does RT CPU scheduling. For now I'd prefer to play it a little safer, and only inheric the priority value and not the class.
The problem I envisioned with that was that realtime tasks, if they don't specify an io priority (as most current code doesn't), would basically get io priority 4 and have the same proportion as any nice 0
SCHED_NORMALtask whereas -nice tasks automatically are getting better io priority. How about givent them normal class but best priority so they are at least getting the same as nice -20?
Quoted 5 lines
Con,
Have you seen RT threads trying to disk IO 'in the wild' or is this a theoretical concern? I don't know of any such apps.
Yeah, cd burning software comes to mind.
Signature · 1 line
-ck