--8323328-1338751583-1001661497=:1569
Content-Type: TEXT/PLAIN; charset=US-ASCII
On Fri, 28 Sep 2001, Andrea Arcangeli wrote:
> some comment after reading your softirq-2.4.10-A7.
>
> > - softirq handling can now be restarted N times within do_softirq(), if a
> > softirq gets reactivated while it's being handled.
>
> is this really necessary after introducing the unwakeup logic? What do
> you get if you allow at max 1 softirq pass as before?
yes, of course it's necessery. The reason is really simple: softirqs have
a natural ordering, and if we are handling softirq #2, while softirq #1
gets reactivated, nothing will process softirq #1 if we do only a single
loop. I explained this in full detail during my previous softirq patch a
few months ago. The unwakeup logic only reverts the wakeup of ksoftirqd,
it will not magically process pending softirqs! I explained all these
effects in detail when i wrote the first softirq-looping patch, and when
you originally came up with ksoftirqd.
(Even with just a single softirq activated, if we are just on the way out
of handing softirqs (the first and last time) at the syscall level, and a
hardirq comes in that activates this softirq, then there is nothing that
will process the softirq: 1) the hardirq's own handling of softirqs is
inhibed due to the softirq-atomic section within do_softirq() 2) this loop
will not process the new work since it's on the way out.)
basically the problem is that there is a big 'gap' between the activation
of softirqs, and the time when ksoftirqd starts running. There are a
number of mechanisms within the networking stack that are quite
timing-sensitive. And generally, if there is work A and work B that are
related, and we've executed work A (the hardware interrupt), then it's
almost always the best idea to execute work B as soon as possible. Any
'delaying' of work B should only be done for non-performance reasons:
eg. fairness in this case. Now it's MAX_SOFTIRQ_RESTART that balances
performance against fairness. (in most kernel subsystems we almost always
give preference to performance over fairness - without ignoring fairness
of course.)
there is also another bad side-effect of ksoftirqd as well: if it's
relatively inactive for some time then it will 'collect' current->counter
scheduler ticks, basically boosting its performance way above that of the
intended ->nice = 19. It will then often 'suck' softirq handling to
itself, due to its more agressive scheduling position. To combat this
effect, i've modified ksoftirq to do:
if (current->counter > 1)
current->counter = 1;
(this is a tiny bit racy wrt. the timer interrupt, but it's harmless.)
the current form of softirqs were designed by Alexey and David for the
purposes high-performance networking, as part of the 'softnet' effort.
Networking remains the biggest user of softirqs - while there are a few
cases of high-frequency tasklet uses, generally it's the network stack's
TX_SOFTIRQ and RX_SOFTIRQ workload that we care about most - and tasklets.
(see the tasklet fixes in the patch.) Via TX-completion-IRQ capable cards,
there can be a constant and separate TX and RX softirq workload added.
especially under high loads, the work done in the 'later' net-softirq,
NET_RX_SOFTIRQ can mount up, and thus the amount of pending work within
NET_TX_SOFTIRQ can mount up. Furthermore, there is a mechanizm within both
the tx and rx softirq that can break out of softirq handling before all
work has been handled: if a jiffy (10 msecs) has passed, or if we have
processed more than netdev_max_backlog (default: 300) packets.
there are a number of other options i experimented with:
- handling softirqs in schedule(), before runqueue_lock is taken, in a
softirq- and irq- atomic way, unless ->need_resched is set. This was
done in earlier kernels, and might be a good idea to do again =>
especially with unwakeup(). The downside is extra cost within
schedule().
- tuning the amount of work within the tx/rx handlers, both increasing
and decreasing the amount of packets. Decreasing the amount of work has
the effect of decreasing the latency of processing RX-triggered TX
events (such as ACK), and generally handling TX/RX events more
smoothly, but it also has the effect of increasing the cache footprint.
- exchanging the order of tx and rx softirqs.
- using jiffies within do_softirq() to make sure it does not execute for
more than 10-20 msecs.
- feeding back a 'work left' integer through the ->action functions to
do_softirq() - who can then do decisions which softirq to restart.
(basically a mini softirq scheduler.)
this later one looked pretty powerful because it provides more information
ot the generic layer - but it's something i think might be too intrusive
for 2.4. For now, the simplest and most effective method of all was the
looping.
- i've done one more refinement to the current patch: do_softirq() now
checks current->need_resched and it will break out of softirq processing
if it's 1. Note that do_softirq() is a rare function which *must not* do
'!current->need_resched': poll_idle() uses need_resched == -1 as a
special value. (but normally irq-level code does not check
->need_resched so this is a special case). This prevent irqs that hit
the idle-poll task to do normal softirq processing - and not break out
after one loop.
i've attached the softirq-2.4.10-B2 that has your TASK_RUNNING suggestion,
Oleg's fixes and this change included.
Ingo
--8323328-1338751583-1001661497=:1569
Content-Type: TEXT/PLAIN; charset=US-ASCII; name="softirq-2.4.10-B2"
Content-Transfer-Encoding: BASE64
Content-ID: <Pine.LNX.4.33.0109280918170.1569@localhost.localdomain>
Content-Description:
Content-Disposition: attachment; filename="softirq-2.4.10-B2"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--8323328-1338751583-1001661497=:1569--
-
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/