>> Nikhil Devanur Rangarajan: Hello everyone. It's my great pleasure to welcome back
Debmalya who is a professor at Duke University. Debmalya had a long association with
Microsoft Research being an intern here multiple times and a postdoc and now a visitor. He is
going to tell us about energy efficient scheduling in the non-clairvoyant model and most of the
work was done actually when all of the authors were here. When Debmalya was a postdoc,
Yossi was a visitor and Zhiyi was an intern. This is one of the best people awarded so far so we
had a very productive effort from all of us. And so on to Debmalya.
>> Debmalya Panigrahi: Thank you Nikhil. This is joint work with Yossi Azar and two authors
who are in the room, Zhiyi Huang and Nikhil Devanur. This talk will be about going green.
What we mean by that is we would like to compute in an energy efficient manner. There has
been growing interest in energy efficiency in computing both in the theory community, where
energy is now increasingly being treated as a first-class resource, in addition to traditional
resources like space and time. And also, in practice, because there are several applications
such as those in data centers where it's important that algorithms are aware of the energy
usage of a particular scheduling plan for a particular execution. In fact, scheduling jobs on
machines is one of the key problem domains aware energy efficiency plays an important role,
which is exactly what we'll be talking about today. There are two kinds of paradigms of energy
efficient scheduling that have been popular. These two paradigms come from the two
dominant application domains where energy is an important resource. They represent kind of
the two extremes of computing as we know it. One domain is our data centers, which is sort of
the highest order the largest scale computing that we see today. And there the dominant
technique for managing energy is what are known as power down schedules. What that means
is that at certain points of time you shut down some subset of machines in the data center and
allow them to cool and restart them after a while. There has been some growing body of
literature which talks about algorithms for power down scheduling. But what we're going to
talk about today is at the other end of the spectrum on handheld devices where, again, energy
is an important resource. There the technique for managing energy is somewhat different
because you can't quite a power down devices. Instead, what are used are known as speed
scaling processes. What does this mean? It basically means a processor that can run at various
energy levels. Either you can run it fast and it processes jobs faster, but it consumes higher
levels of energy. Or you can run at slower and then it consumes less energy but you'll take a
longer time to complete the same job. This is what we'll talk about today. In particular, we are
going to look at what is one of the most basic problems in this domain. You have a time axis
and jobs arrive over time. This is standard scheduling. What are the jobs characterized by?
Jobs have a release time. At some point of time you get to know that the job, so the job arrives
in the system and you know that the job needs to be scheduled. That's the release time of the
job. Jobs have an important score which we call density and we'll see why it's called density
soon. It also has a volume. This is the total amount of computation that the job requires, and
we will define the weight of a job to be the product of the density and the volume, the product
of the importance and the total amount of processing that you need to do. These are the
parameters that define a job for me. All of these jobs come online or, over time and they need
to be scheduled on a single machine. I just have one machine. I have a bunch of jobs arriving.
The jobs need to be scheduled on the machine. The key feature is that this machine is speed
scalable, so I can run this machine at various different speeds and depending on how fast I'm
running the machine I'll consume a certain amount of energy and I will complete the jobs at a
together time. What's the problem then? The problem is to decide two things. First, if I have a
bunch of jobs that are awaiting processing, I need to decide which of them I should process on
the machine. The machine can process only one job at a time. That is the first selection that I
need to do. Then, once I have selected the job to process on the machine, I need to specify the
speed at which I'll run the machine. Remember, the machine is speed scalable, so it can run at
various different speeds and I need to tell you what speed the machine is running at at any
given time. These are the two things that the scheduler should tell me. The way the speed
shows up is that it impacts both the energy and the processing time. In particular, the rate of
decrease of the volume of the job that's remaining, that's being currently processed and the
volume that remains decreases at the rate that is equal to the current speed. If I'm running the
machine at say speed 10, that means that for every unit of time the remaining volume
decreases by 10 units. That's the natural definition for speed. How does speed influence
energy? The influence is through what is usually called a power curve. This is just a mapping
from speeds to energies, or speeds too instantaneous powers. Typically we will assume that
this power curve is a convex curve. It's a small polynomial function of the speech. So about s
cubed or s squared or somewhere in between. This is the setup. The question is what am I
trying to optimize. At a high-level it's clear what I want to optimize. I want to optimize two
things. First jobs shouldn't wait in the system forever, so I want to optimize delay, or latency.
And second, I should not be running my machines at crazy speeds, so I want to optimize energy.
At a high-level these are the two things I want to optimize. Energy is quite easy to quantify. It's
just area under the power curve, so that every instant of time you are running your machine at
a particular speed that translates into a particular power consumption according to the power
curve and energy is simply the area under this curve. But how about the delay? How do we
quantify delay? The standard way to quantify delay is by using what is known as flow times.
For time is basically just delay but multiplied by weight, so you take the difference between the
completion time and the release time of a job. This is the total time that the job spends in the
system, and you multiply it by the weight of the job. That's the full-time of the job and use sum
it up overall jobs and that is your quantification of delay. For the purpose of this talk, though it
is not strictly required for the result, but for this talk it will be convenient to introduce a slightly
different notion of flow time that will make our life a little easier to make things geometric. We
call it the fractional flow time of a job. Here is a way to understand what this means. Take
every job, think of it being split up into very small jobs, let's say epsilon value. There are zillions
of such jobs. Now for each of them you compute the flow time according to the formula that
you had earlier. Each of these small pieces of the job get completed at a certain point of time.
You subtract the release time of the job from it. All of these jobs are released at the same time
when the entire job shows up. You take the difference and you sum it up over all these small
pieces. That's the fractional flow time of the job. In this talk I'll restrict myself to fractional flow
times rather than going to integral flow times. Here are all of the results generalized. One way
to think of the fractional flow time, as I said, is that that is the sum of the flow times of these
infinitely many parts. An alternate view is that, in fact it's integral over the total weight of all
jobs left in the system at any point of time. If you think about it, at any point of time which are
the jobs contributing to your flow time? Which of these infinitely small jobs contributing to
your fractional flow time? It's exactly those jobs that are still in the system that haven't been
processed. This is simply the integral overall of the remaining weight over the entire time axis.
Therefore, it can be drawn as, if I draw the curve of the remaining weight instantaneously, and
take the area under the curve, that's in fact the fractional flow time of the job. These are the
two things that I want to optimize. As a standard in literature, what I'll actually do is, by the
way. Sometimes the fractional flow time also increases because new jobs are released and
therefore the remaining weight increases. In order to do this the following standard
convention is that in fact, I'll optimize the sum of these two quantities. Summing these two by
the weight, all the results hold even if you scale these in whatever way you want. You can
change the scale on the two. You can take any linear combination.
>>: Can you also say that if I give you a bound?
>> Debmalya Panigrahi: No. That is stronger. That's not clear. That's not clear. The part that
we are doing is going to give you criteria like bounds, but then we will piggyback on something
that was previously known and there the bounds are not quite [indiscernible].
>>: In theory do you have the task of [indiscernible]
>>: So you won't convert apples to oranges?
>> Debmalya Panigrahi: Yeah.
>>: So are the jobs preempted?
>> Debmalya Panigrahi: Yes. If the preemption is free and allowed. That's the problem. Any
questions about the problem? So what was known for this problem? What was known is what
was known as the clairvoyant setting. In this setting when a job arrives all the parameters of
the job are revealed. When you see the job you get to know its density, its weight, it's volume
all of the parameters. For this setting there was a series of works which I won't quite go
through, but the key one that we will use this following observation. It says that if I have a
bunch of jobs arriving over time, the right thing to do is to use the following two rules.
Remember, why do I need two rules? Because there are two decisions that I am making, which
job should I process and at what speed? The job to process is given by this HDF rule, which
means highest density first. Among all the jobs that are awaiting processing, I look at the job
that has the maximum density, that's the job I should process. It's sort of intuitive, right,
because that's the one that will differentially and the most to my weight. That's the job I
process, and at what speed should I process it? For that, the first rule is that you should set the
power, the instantaneous power to be exactly equal to the total remaining weight of all jobs in
the system. That's the P equals RW rule. We'll see why this gives certain…
>>: [indiscernible] maximum? [indiscernible] power be the remaining weight?
>> Debmalya Panigrahi: Take the entire remaining weight.
>>: [indiscernible] you are making a sum, right?
>> Debmalya Panigrahi: The units are already matched in the sum. Okay? And Bansal, Chan
and Pruhs proved is that these two rules in conjunction give you a 2 competitive algorithm. So
the total value of the objective produced by the algorithm is at most twice that of an optimal
solution. But that competitive ratio is not in terms of each individual objective. If it were, then
what [indiscernible] was suggesting some kind of arbitrary approximation would have been
possible.
>>: What is epsilon?
>> Debmalya Panigrahi: Epsilon is, where is us on showing up? I think it shows up in -- where
does epsilon show up?
>>: [indiscernible]
>> Debmalya Panigrahi: I don't remember.
>>: [indiscernible] function and they need some kind of way to make a convex and then you do
a approximation of it so that it's like maybe strictly convex so it's kind of a [indiscernible]
>> Debmalya Panigrahi: Yeah, maybe the number of [indiscernible] falls into the power
function. Something like that. That's the rule that was now. So how does this algorithm work?
If you think of drawing the power curve over time, so let's say I have only one job at the
beginning. So I set my power to be equal to the weight of the job, the total remaining weight.
And then this job keeps getting processed at some point and a new job is released at time R2.
Immediately, I increased to bump up the speed of the machine because I want to maintain this
rule that the remaining weight is equal to power, instantaneous power, and also if the second
job that was released is a higher density job, I, in fact, preempted the first job. I take the red
job out of the system and I put the blue job in. As you can see, the blue job, maybe you can't
quite see it, but the blue job has a steeper slope which indicates that it is a higher density job.
That's why the weight is decreasing faster. And then once the blue job finishes, I resume the
first job. This is the kind of power curve that the clairvoyant algorithm gives us. The question is
what do we do if we don't know the remaining weights. We don't know the weight of the job,
which means that we can't quite run this algorithm because even at times zero I need to know
the total weight. Before I go on let me mention that there are two different models in which
you can think of non-clairvoyant. You can either think of knowing the total weight of the job
when it arrives or the total density of the job when it arrives. Of course, if you know both then
you know all of the parameters. The one that we will consider is the one where we know the
density, so we know the importance of the job but we don't know the total weight of the job,
and therefore, we don't know the volume either. There has been a little bit of work in the
other setting where you know the weights but you don't know the densities and there are some
results. But we won't concern ourselves with this. This is the algorithm in the clairvoyant
setting. One thing to note here is that the area under the curve represents both the
parameters that we are trying to optimize. If you remember, I drew these two curves. One was
the instantaneous power curve and the other was the remaining weight curve and I did the two
objectives were in fact the areas under the two curves. Here the two curves, the algorithm has
been chosen in a way such that these two curves are exactly the same because power equals
remaining weight. Therefore, the two objectives are in fact the same area under this curve.
What these guys really showed is that the area under such a curve is at most the optimal value,
whatever is the optimal objective. Therefore, they got their two approximations. There's one
property of this curve that we will use a lot and let me just give this property at this point. It
won't be clear why this property is important, but we will slowly see how it can be used. A
property of this curve is that it will simply take one of these curves. If we just take the red
curve, for instance, what does the curve depend on? It only depends on the density. If I tell
you the density, then you can draw the red curve. Or if I tell you the density for the blue curve,
you can draw the blue curve. If I draw such a curve and look at the two areas, the area under
the curve and area above the curve, then just simple math shows that the ratio of these two
areas is between two and three and crucially independent of the weight or the densities. This
curve, of course, depends on the density. If the density is higher than the curve is steeper
because the remaining weight drops faster. But irrespective of what the density is and
therefore irrespective of what the actual slope of the curve is, the ratio of these two areas turn
out to be identical. It's about two or three. In fact, what this means is that this also holds
differentially which means that if I start the curve not from zero but from some other point and
draw a little bit of the curve, then again, if I take the two, horizontal and vertical segments and
compare these areas, so that ratio is also exactly 2+1 over alpha -1. We will call it the
differential universality property. This is a property that we will need in the rest of the talk. At
this point this is just a property of a particular differential function. Let's go back to the uniform
density case. Ultimately, we will look at arbitrary density as jobs having various different
densities, but let's start off by just looking at a situation where every job has the same density.
This is how the clairvoyant algorithm looks. What do we do for the non-clairvoyant algorithm?
Let me simplify even more. Let me say that there is just one job in the system. There is nothing
else. At times I get one job and then I don't get anything more. This is what the clairvoyant
algorithm does. It's just this is good. It's not clear what I should be doing in the non-clairvoyant
case, because note that I do not really know w1 at time zero, so I can't quite simulate this curve
in the non-clairvoyant scenario. Instead, what we do is we flip the curve around. What I can do
is I can simulate this curve in reverse by simply setting my power to be the processed weight
rather than the remaining weight. This is just a mirror image of the curve on the left. But why
is this any good? What was happening in the clairvoyant case. The flow time and the energy
were both equal to the area under the curve. For us we have flipped the curve around, so the
energy still remains the area under the power curve. The energy by definition is the area under
the power curve, and therefore, the energy consumption is the same in the two algorithms.
The problem is with the flow time. But then if I look at any time instant, the process to weight
is the height of the curve, so the remaining weight is the remaining, it's the part above the
curve. Therefore, if I integrate over time, then the flow time, in fact, is the entire area above
the curve rather than under the curve. But our universality property says that these two areas
are not very different. That's exactly what the universality property was saying. If I simply use
the property as is I'll get a comparative ratio for both too. For the single job case, the very
simple single job scenario. Any questions about this one? Sorry. This is not even single density,
single job. No job is being released in the interim. Okay? Let's make the next baby step. Let's
have two jobs. Again, uniform density, the second job is released at time R2. Now life is not so
easy. Ideally, what we would like to do is to flip these curves around and run and algorithm
which basically flips the power curves around. But can we do this? Not quite because we don't
know where to break on the right. In particular, we don't know the remaining weight of the
first job when the second job was released. To know this, I have to process the entire first job,
otherwise, I don't know the weight of the first job, and therefore, I don't know where I should
break that curve and start again. This doesn't quite work. Instead of that, let me try to play
around with these segments on the curve. So what I do is I take out the blue segment. Firstly, I
think of this clairvoyant algorithm as a last in, first out algorithm. Note that all the densities are
equal, so it doesn't really matter which job we are processing. However, for the sake of an
easier explanation, let me just think of this as a last in first out algorithm, which means that the
blue job once it arrives at R2 preempts the red job and that is the one which is being processed,
and then the red job resumes. Let me take the blue job and move its curve to the end. There's
no semantics here. I'm just taking a part of the curve and moving it somewhere. This is the
curve on the left and we'll try to simulate this curve in reverse rather than the original curve.
What do I do? I keep running the first job until it completes, and at this point I want to start my
blue job at this height W1 prime. But what is W1 prime? It only depends on the value of W1.
That's the remaining weight when the second job was released in the clairvoyant algorithm. It
does not depend on the actual weight of the second job. It just depends on the weight of the
first job, so that's something I do know in the non-clairvoyant setting since I have completely
process my first job, the red job. Therefore, I can simulate the blue curve in reverse at the end
of processing the first job. But why is this any good? I did around but I changed things, change
the order and maybe that's messing up with my proof. To see why it's good, let's do a simple
analysis. What are the remaining weights at any point of time in the algorithm in the nonclairvoyant algorithm? Until time R2 the remaining weight is just given by W1 minus the
process weight. At R2 the second job is released and so the remaining weight goes up by W2
and that's how it remains until the end of the first job. Is that clear? Now let me split up the
clairvoyant areas into A and B. This is sort of a natural split. And the non-clairvoyant areas into
A prime which is for the first job, so remember for non-clairvoyant of the clairvoyant area under
the curve as well as above the curve. So that's A prime. And then B prime are the remaining
weights due to the second job and the energy to do the second job. Those two, the vertical and
horizontal segments are B prime. So A prime I can charge to A by just using my universality
property. That was what I was doing for a single job. So charging A prime to A is the same as a
single job. I simply do that. So A prime and A are gone. I somehow need to be able to charge B
primes, the two segments that I've drawn as B prime to B. Let me move the B prime up and
join it with the other segment. And move the B back to its original location. What is B prime?
What is the horizontal segment in B prime? It's in fact this segment, the segment that I call B
extended to the end of the algorithm. These two lengths are exactly equal. It's the total time
minus R2, the release time of the second job. And now what should I be using? I'll just use my
differential universality property now. I want to charge the two segments, the horizontal and
vertical segments to the area under the curve, which is exactly what the differential property
was doing for me. I simply use my differential universality property and charge B prime the B. I
can infer that for two jobs I still have the same ratio, 2+1 over alpha -1. Where is all of this
going? Somehow we have to turn this into a general analysis. Until this point between playing
around with pictures. I can't do that in general. This geometry has to somehow be converted
into an algebraic definition. Let's try to do that. For that we will introduce a new idea that we
call incremental analysis. The idea is that instead of trying to predict what opt is or even what
the final clairvoyant algorithm is doing, we will try to compare ourselves to non-clairvoyant
algorithm with the clairvoyant algorithm on what we call the current instance. And what is the
current instance? It's simply for every job I simply take the weight of the job that I have already
processed. That's all I know in the non-clairvoyant setting. I don't know whether the job has
more weight. I define my current instance with the processed weight of every job. And now
with the current instance there is some optimal clairvoyant algorithm. That's what I want to
compare my non-clairvoyant algorithm to. I want to compare the objectives of the nonclairvoyant and the clairvoyant algorithm for this instance. What does this mean inductively?
How do I maintain this property, this invariant that the non-clairvoyant algorithm can be
charged to clairvoyant for the current instance? When I go from time T to T plus dt my current
instance changes. Since the current instance changes, my clairvoyant algorithm might
completely change from some curve it changes to a very different curve. Somehow I need to
account for that. I need to be able to lower bound that objective, the change in the objective in
the clairvoyant setting, and charge the additional objective that I incur in the non-clairvoyant
setting to that increase in the clairvoyant case. That's the general plan. Is the general plan
okay? Okay. Let's see if this is able to solve our single job case first. What happens when I
change from an instance with weight W to an instance with weight W plus DW in the single job
case is basically, what happens is the T equals zero axis shifts to the left. I had weight W1. I
was tracking my algorithm with power W1 and running on this curve. Now my new weight is
W1 plus DW. Start with W1 plus DW and again I'll follow the same curve. Remember this curve
is only defined by density. It's not dependent on what the actual weights are. It's really just
where you start that is defined by the actual weight that's the extra parts that I'm getting on
the left in the clairvoyant objective. What about the non-clairvoyant objective? I'm getting
exactly the same shape, but on the right now because I flipped the curve. Now I can use my
differential universality property to claim that the two rectangles there, the horizontal and
vertical segments can, in fact, the bounded by just the vertical segment. That's exactly how
differential universality property. You can use differential universality to claim that, in fact, you
are maintaining this invariant that you can charge the non-clairvoyant solution to the
clairvoyant solution. How about two jobs from time zeros to R2 when the second job is
released it is just exactly like a single job. It does nothing different. But at R2 the second job is
released, but nothing really happens to our analysis. Why? Because the non-clairvoyant
algorithm continues to process the first job. Therefore, the current instance has zero wait for
the second job. That hasn't even started processing. It doesn't know any weight. So really,
until the end of processing of the first job in this analysis it's the single job scenario. Now once
I've finished the first job, the second job start getting processed and then you get back to the
section that you had earlier. Basically, this red curve in the clairvoyant algorithm gets shifted to
the right and this blue curve shows up in the middle. And the blue curve also shows up at the
union there, and again, the differential universality property exactly says that the B primes can
be charged often B. This is what we did earlier as well. And this keeps happening. The red
curve keeps getting shifted and the blue curve keeps getting bigger. Then what is the general
algorithm? This is the kind of analysis that we want to do, so what should be our general
algorithm? Firstly, we want to process jobs in first in first out order. If you look at this picture
the red job is completely processed before I even touch the blue job. Clearly I am processing in
the FIFO order in the non-clairvoyant offered. I want to process jobs in FIFO order and how do I
set my instantaneous speed? One way to think of setting the instantaneous speed is that I
want both of these algorithms to end at the same time. I don't want my non-clairvoyant
algorithms to lag behind. Otherwise my analysis will not work. I simply set my speed in a way
such that the non-clairvoyant algorithm doesn't lag behind. It finishes the same volume of job
that the clairvoyant algorithm would have finished and that gives me a unique speed. That's
how I set it and therefore my analysis works. That takes care of the uniform density case and
that's pretty much what I want to talk about today. I'll tell little bit about the arbitrary density
scenario. The difficulty with arbitrary density is that it becomes messy and these figures don't
work anymore, but I'll give you a little bit of intuition as to what goes wrong and how we are
able to fix it. What goes wrong?
>>: [indiscernible]
>> Debmalya Panigrahi: [indiscernible]. What goes wrong? Again, imagine there are two jobs
and the second job is at a much higher density than the first job. The blue job has a higher
density than the red job. When the blue job is released it preempts the red job in the
clairvoyant algorithm. It has the highest density first rule. And then once the blue job
completes you resume the red job. What option does the non-clairvoyant algorithm have?
One option is, again, try to mirror these two red and blue curves as I was doing earlier. What's
wrong with this?
>>: [indiscernible] is larger and it should be [indiscernible]
>> Debmalya Panigrahi: The blue guy has high density and that guy is made to wait from R2
until the end of the first day, the red guy. Okay? This clearly is suboptimal. I won't be able to
charge this additional time that it is waiting. That is bad. It seems like I should we really move
the blue guy up front because it should be processed immediately on release. This is what I
should be doing, but there's a problem with this as well. At this point I don't know enough
about the red guy, about the red job to be running my machine at high speed. I'll end up
running the blue job over a slow part of its curve because I haven't even seen the rest of the red
job. There are these two conflicting pools. One requires the analysis regarding that we should
go in first in first out order, but as [indiscernible] said intuition suggests that really the highest
density job should be processed earlier. The way we resolve it and this is not very unique. This
is sort of the first thing you would think of, is to take the jobs and groups them in densities,
some kind of geometric buffering. Within the same bucket you process jobs in FIFO order, first
in first out order. These are jobs with roughly the same density and across buckets you use the
highest density first rule, so if some job has a much higher density than the current job being
processed it will preempt the current job, but if the densities are close it won't. It's kind of the
natural thing to do. However, this sort of messes up the entire analysis and in fact, it messes up
the definition of instantaneous feed as well. So ideally what we should want to do for setting
instantaneous feed, remember what we were doing earlier? We wanted our non-clairvoyant
algorithm to finish as soon as the clairvoyant algorithm finishes, so we don't want a nonclairvoyant algorithm to lag behind. It turns out here we need a little more because we fear
exactly finishing at the same time is the clairvoyant algorithm there are instances that you can
construct where the diversity will force you to lag behind at some point. In fact, the clairvoyant
needs to have an advantage over the non-clairvoyant algorithm in this case. In particular, we
want the completion time of the clairvoyant algorithm to a constant times more than the
current time which is the completion time of the non-clairvoyant algorithm on the current
instance. By definition, non-clairvoyant algorithm completes the current instance at the
current time, but clairvoyant we wanted to be slower, so we want to run our machines at faster
speed. One way of ensuring this is to say that I'll make sure that at the current time, if I
simulated the clairvoyant algorithm, for every job it would have had a constant fraction of the
job still left to process. That would have ensured that the clairvoyant algorithm let's say would
run for double the time. As it turns out this is not an invariant we can win for every job, but we
can sort of maintain this on average, so we can do some kind of amortized analysis and while
this is not true for every job we can show that if this is true for most jobs or if this is true on
average, even that is sufficient for the final ratio that we want. I don't want to go into details of
this. Let me just state that the competitive ratio that you get for non-uniform density is is a sub
constant where the dependence is not good on alpha. Remember, alpha was somewhere
around two or three so this is not too bad but from a technical perspective we are not sure the
dependence should be exponential or whether you can probably get better dependence. Let
me and by mentioning a few open questions. The first one is not really an open question, but
while the analysis for the uniform density case we saw can get pictorially represented. It's
pretty easy. You can do it in a page or two, the proof of the non-uniform density case actually
takes about 40 pages, 30 or 40 pages. There is something we are not doing right there. There
is probably a much simpler proof there or maybe a different algorithm. Our dependence on
alpha is not great in the non-uniform case. It's about 2 to the alpha which might be improved.
It might be possible to improve. And what's probably the most interesting thing here is can we
use this notion of incremental analysis somehow? Is there something new in terms of the
available techniques in online algorithms? Typically, online algorithms don't work with
changing instances. It's just one instance that they think about. Maybe this is useful as well.
Thank you. [applause]. Questions?
>>: If you can go back to, the next one. What is the dependence on alpha?
>> Debmalya Panigrahi: What is the dependence on alpha? 2 to the alpha?
>>: I think the basis [indiscernible]
>>: [indiscernible]
>>: [indiscernible]
>>: It could be [indiscernible]
>> Debmalya Panigrahi: It's possible that you could get a alpha squared or something. In fact
with a clairvoyant setting even some more general scenarios get polynomial alpha.
>>: With a single machine?
>> Debmalya Panigrahi: A single machine is two, but for more general settings [indiscernible]
>>: [indiscernible]
>>: Do you know any lower bounds?
>> Debmalya Panigrahi: Not that I'm aware of, no. Some are suggesting that it's harder than
clairvoyant. I think the clairvoyant case might have…
>>: As alpha changes [indiscernible] to alpha?
>> Debmalya Panigrahi: For the clairvoyant, yes.
>>: Clairvoyant is 2 [indiscernible] alpha?
>> Debmalya Panigrahi: Yes.
>>: But for the non-clairvoyant case, it's alpha [indiscernible]?
>> Debmalya Panigrahi: Yeah, we are not sure.
>>: In fact, the ratio for uniform density improves as alpha increases. It actually approaches
two if you have a large alpha.
>> Debmalya Panigrahi: The improvement is not significant. It goes from three to two.
>>: [multiple speakers] [indiscernible]
>>: For the…
>>: [indiscernible] for alpha -1.
>>: [indiscernible]
>>: Only for the non-clairvoyant [indiscernible].
>> Debmalya Panigrahi: The other one does not have a dependence alpha.
>>: But having [indiscernible]
>>: It goes from 3 to 2.
>>: Yes but in this case [indiscernible] the your saying it could be. It could be three.
>>: [indiscernible] lower bounds.
>> Nikhil Devanur Rangarajan: All right. It's time to the end. [applause]