Skip to contentSkip to conversation

Interrupt starvation points

PATCH Daniel Walker 3 participants 5 messages Feb 11, 2005 Library code

lore
Share & tools
lore
#0 lore raw

I found some points during schedule when interrupts are off for
long periods . These two patches seem to help. One enables interrupts inside schedule() , so that interrupts are enabled after each need-resched loop, then disabled again before __schedule() is called.

The other patch enabled interrupt before calling up on
kernel_sem ..This one could use some thinking over. I did this cause up() is very expensive on ARM , and combined with the looping above interrupts can stay off for a long time ..

Daniel

kernel/sched.c +2 -1
Index: linux-2.6.10/kernel/sched.c
===================================================================
@@ -3038,9 +3038,10 @@
 		send_sig(SIGUSR2, current, 1);
 	}
 	do {
+		local_irq_disable();
 		__schedule();
+		local_irq_enable(); // TODO: do sti; ret
 	} while (unlikely(test_thread_flag(TIF_NEED_RESCHED)));
-	local_irq_enable(); // TODO: do sti; ret
 }
 
 EXPORT_SYMBOL(schedule);
lib/kernel_lock.c +2 -0
Index: linux-2.6.10/lib/kernel_lock.c
===================================================================
@@ -114,7 +114,9 @@
 
 void __lockfunc __release_kernel_lock(void)
 {
+	local_irq_enable();
 	up(&kernel_sem);
+	local_irq_disable();
 }
 
 /*
#1 lore raw
Quoted 10 lines · Daniel Walker

I found some points during schedule when interrupts are off
for long periods . These two patches seem to help. One enables interrupts inside schedule() , so that interrupts are enabled after each need-resched loop, then disabled again before __schedule() is called.

The other patch enabled interrupt before calling up on
kernel_sem ..This one could use some thinking over. I did this cause up() is very expensive on ARM , and combined with the looping above interrupts can stay off for a long time ..

i'm wondering what the best approach would be. Right now if DIRECT_PREEMPT is enabled [it's disabled currently] and a higher-prio task has been woken up we switch to it without ever enabling interrupts again. Re-enabling interrupts during schedule() will reduce irq latencies but will lengthen critical sections.

Ingo

#2 lore raw
Quoted 6 lines · Ingo Molnar

i'm wondering what the best approach would be. Right now if DIRECT_PREEMPT is enabled [it's disabled currently] and a higher-prio task has been woken up we switch to it without ever enabling interrupts again. Re-enabling interrupts during schedule() will reduce irq latencies but will lengthen critical sections.

Yeah, it's a trade off .. The longest points that I observed involved
kernel threads like desched . Things that the scheduler() regularly wakes up anyways. I would imagine there is an upper bound on the number of tasks the scheduler can wake up.

Daniel

#3 lore raw
In reply to Daniel Walker
Quoted 4 lines · Daniel Walker

The other patch enabled interrupt before calling up on
kernel_sem ..This one could use some thinking over. I did this cause up() is very expensive on ARM , and combined with the looping above interrupts can stay off for a long time ..

Please substantiate your claim that up() is very expensive on ARM. I disagree:

#define __up_op(ptr,wake)                       \
        ({                                      \
        __asm__ __volatile__(                   \
        "@ up_op\n"                             \
"       mrs     ip, cpsr\n"                     \
"       orr     lr, ip, #128\n"                 \
"       msr     cpsr_c, lr\n"                   \
"       ldr     lr, [%0]\n"                     \
"       adds    lr, lr, %1\n"                   \
"       str     lr, [%0]\n"                     \
"       msr     cpsr_c, ip\n"                   \
"       movle   ip, %0\n"                       \
"       blle    " #wake                         \
        :                                       \
        : "r" (ptr), "I" (1)                    \
        : "ip", "lr", "cc", "memory");          \
        })

static inline void up(struct semaphore * sem)

{
        __up_op(sem, __up_wakeup);
}

Looks like 9 instructions for the uncontended case to me. If you're worried about 9 instructions being expensive, please work on GCC to improve its optimisation capabilities first. There's room there for improvement across the whole kernel than just the above 9 instructions.

Plus, after you've read the above code, wouldn't you think that adding the "enable interrupts + disable interrupts" around an up() operation (which itself immediately disables interrupts again) is just adding extra instructions to the kernel, which corresponds directly to lower performance?

Signature · 4 lines
Russell King
 Linux kernel    2.6 ARM Linux   - http://www.arm.linux.org.uk/
 maintainer of:  2.6 PCMCIA      - http://pcmcia.arm.linux.org.uk/
                 2.6 Serial core
#4 lore raw
Quoted 3 lines · Russell King

Please substantiate your claim that up() is very expensive on ARM. I disagree:

I should have made it clear that I was talking about the RT version of
up() . The RT version doesn't have any assembly in it, and it is expensive.

Quoted 5 lines

Plus, after you've read the above code, wouldn't you think that adding the "enable interrupts + disable interrupts" around an up() operation (which itself immediately disables interrupts again) is just adding extra instructions to the kernel, which corresponds directly to lower performance?

Not in the RT case. However, I never said that was a proper fix, I was
just producing code that helped in my tests.

Daniel