Algorithm Design

800 Epilogue: Algorithms That Run Forever Epilogue: Algorithms That Run Forever
example in the previous paragraph, it’s okay that we don’t move all n arriving
packets to a common output buffer in one time step; we can afford more time
for this, since their departures on this common output link will be spread out
over a long period of time anyway.)
/-~ Designing the Algorithm
Just to be precise, here’s our model for a speed-up of 2.
One step under sped-up input/output queueing:
Packets ~rrive on input links and ~re placed in input buffers
A set of packets whose types form a matching are moved to their
associated output buffers
At most one packet departs from each output buffer
A set of packets whose types form a matching are moved to their
associated output buffers
In order to prove that this model can simulate pure output queueing; we ,
need to resolve the crucial underspecified point in the model above: Which
matchings should be moved in each step? The answer to this question will form
the core of the result, and we build up to it through a sequence of intermediate.
steps. To begin with, we make one simple observation right away: If a packet
of type (I, O) is part of a matching selected by the switch, then the switch wil!
move the packet of this type that has the earliest time to leave.
Maintaining Input and Output Buffers To decide which two matchings the
switch should move in a given time step, we define some quantifies that track
the current state of the switch relative to pure output queueing. To begin with,
for a packet p, we define its time to leave, TL(p), to be the time step in which
it would depart on its output link from a switch that was running pure output
queueing. The goal is to make sure that each packet p departs from our switch
(running sped-up input/output queueing) in precisq!y the time step TL(p).
Conceptually, each input buffer is maintained as an ordered list; however,
we retain the freedom to insert an arriving packet into the middle of this
order, and to move a packet to its output buffer even when it is not yet at
the front of the line. Despite this, the linear ordering of the buffer will form
a useful progress measure. Each output buffer, by contrast, does not need to
be ordered; when a packer’s time to leave comes up, we simply let it depart.
We can think of the whole setup as resembling a busy airport terminal, with
the input buffers corresponding to check-in counters, the output buffers to
the departure lounge, and the internals of the switch to a congested security
checkpoint. The input buffers are stressful places: If you don’t make it to the
head of the line by the time your departure is announced, you could miss your
time to leave; to mitigate this, there are airport personnel who are allowed
to helpfully extract you from the middle of the line and hustle you through
security. The output buffers, by way of contrast, are relaxing places: You sit
around until your time to leave is announced, and then you just go. The goal
is to get everyone through the congestion in the middle so that they depart on
time.
One consequence of these observations is that we don’t need to worry
about packets that are already in output buffers; they’ll just depart at the
fight time. Hence we refer to a packet p as unprocessed if it is still in its
input buffer, and we define some further useful quantities for such packets.
The input cushion IC(p) is the number of packets ordered in front of p in its
input buffer. The output cushion OC(p) is the number of packets already in
p’s output buffer that have an earlier time to leave. Things are going well for
an unprocessed packet p if OC(p) is significantly greater than IC(p); in this
case, p is near the front of the line in its input buffer, and there are still a lot of
packets before it in the output buffer. To capture this relationship, we define
Slack(p) --= OC(p) - IC(p), observing that large values of Slack(p) are good.
Here is our plan: We will move matchings through the switch so as to
maintain the following two properties at all times.
(i) Slack(p) >_ 0 for all unprocessed packets p.
(ii) In any step that begins with IC(p) = OC(p) = 0, packet p will be moved
to its output buffer in the first matching.
We first claim that it is sufficient to maintain these two properties.
(E.1) I[properties (i) and (ii) are maintained [or all unprocessed packets at
all times, then every packet p will depart at its time to leave TL(p).
Proof. Ifp is in its output buffer at the start of step TL(p), then it can clearly
depart. Otherwise it must be in its input buffer. In this case, we have OC(p) = 0
at the start of the step. By property (i), we have Slack(p) = OC(p) - IC(p) >_ O,
and hence IC(p) = 0. It then follows from property (ii) that p will be moved to
the output buffer in the first matching of this step, and hence will depart in
this step as well. ~,
It turns out that property (ii) is easy to guarantee (and i~ will arise naturally
from the solution below), so we focus on the tricky task of choosing matchings
so as to maintain property (i).
Moving a Matching through a Switch When a packet p first arrives on an
input link, we insert it as far back in the input buffer as possible (potentially
somewhere in the middle) consistent with the requirement Slack(p) > O. This
makes sure property (i) is satisfied initially for p.
801