 Hello and welcome to the course on Introduction to Computer and Network Performance Analysis using queuing systems. I am Professor Varsha Apte, I am faculty in the Department of Computer Science and Engineering at IIT Bombay. And in today's lecture, we are going to talk about high and low load asymptotes of various metrics of the queuing system. So as usual, I am just recapping whatever you have learnt in the previous lectures. You had, this is the notation, arrival rate lambda, tau, mu, C, K, by now you should really know what all of these things mean, this is the arrival rate, the service time, the number of servers C, the buffer size K and the rate at which each server goes mu. Then these are the metrics, again you should start real kind of remembering what these are, the number of jobs N, Q, rho, capital lambda, W, R, P, L. You can refer to this slide when you are watching the lecture, you can separately refer to this slide. Then what we did last time was we actually derived some metrics like throughputs and utilizations we can derive to some extent. So for GG1, we had all of these derivations, again this is just given for your reference, so you can look at the slides. But what we want to do today is that for all of these, first thing if you realize this, the throughput and utilization for the finite buffer queuing systems, we do not really have, we do not really know what they are. So for example, for GG1K, the throughput is given in terms of PL and even for GGCK, the throughput is given in terms of PL. So what is PL? We do not know that actually, I have not told you yet as to what is PL, we have just given this as a formula as if we knew PL, then you would know how to calculate these things. Remember that PL is probability of loss, right, request loss. But what we can do, remember that one of the goals of this course is to try and make you think about metrics and about what you can reason about about queuing systems in a maximum in an intuitive way, ok. What we are trying to do is trying to make you think about the metrics without having to actually go into too much deep mathematics. So there is a lot of advanced mathematics called stochastic modeling that is required to actually answer these questions properly, this PL, you can actually calculate this if you can make some mathematical assumptions. But there are some questions you can ask about the system which actually needs again very little maths. This did not need getting to this point for the infinite buffer systems, did not need much maths, it was just a lot of reasoning. Similarly, there are some other things that may not need a whole lot of maths and that is asymptotes. So remember what is asymptote? Asymptote is a value that is taken in some limit in our case we are going to basically talk about low load which will basically be the limit of these metrics as lambda goes to 0 and the other asymptote will be high load which is again the values these metrics take when lambda goes to infinity. The minimum and maximum values of metrics that your system takes is actually very important because it allows you to quickly if you are doing an experiment for example, if you are doing a measurement experiment on your system, at least if you can reason about what the maximum value of something should have been, what the minimum value of something should have been, it can help you sanity check the experiment, it can make you verify that the experiment is giving you some sensible results. Otherwise anything that comes on the screen anything that it comes into your excel sheet you will just accept. So asymptotes are very important in actually verifying experimental results in doing some planning sizing and we will actually after this lecture in the next lecture after asymptotes are done we will actually see how asymptotes can be used to verify experiments or do some simple capacity planning. So let us talk about asymptotes. So gg1 infinite buffer single server. So let us basically talk about what happens to first throughput then utilization we will actually also talk about number in system, number in queue and response time and waiting time all these we will talk about. So let us talk about throughput first and what we will do here is actually we will fill the table here one is lambda going to 0, one is lambda going to infinity. So this is the low load, this is the high load. So what happens to a queuing system if the arrival rate goes to 0 what happens to the throughput? Obviously nothing can be done this is our queuing system, this is lambda and the throughput if this is itself going to 0 this will also go to 0 because that is actually also what the definition of throughput is like. So capital lambda the throughput is just going to be equal to the arrival rate small lambda. So if arrival rate is going to 0 so throughput will also go to 0 anyway if there is no work coming into the system then there is no work that the system can produce. As arrival rate goes to infinity as this goes keeps on increasing remember the service rate here is mu so what will happen to the throughput as lambda goes to infinity we know that it has to go to mu that is the maximum the server can do. Same thing with utilization as lambda goes to 0 of course server will be idle so it goes to 0. As lambda goes to infinity it should go to 1 it will become completely busy or in percent it is 100 percent. What about number in system queue number in the queue response time and waiting time these are very important. So when there is very little coming into the system all of these will actually most of these will go to 0 there will be hardly anybody in the system there will be hardly anybody in the queue as a limiting value if nothing is coming to the system if lambda is really 0 then these two should be 0. Response time is on a very important one. If there is less and less very little load into the system there is one request comes in like hundreds of years still it has to spend time in the server to get its service right. The service it is not going to go to 0 only the load is going to 0 the amount of work coming to the server is going to 0 the request still needs its service. So even if lambda is going to 0 so response time will go to service time right it still needs a service. So this will become tau but as load goes to 0 you can expect that there will be nobody in the queue. You know your queue is 0 basically you can expect that there is nobody in the queue. So waiting time of course we expect that it will be 0. Now what happens to all of these as lambda goes to infinity because it is infinite buffer system as lambda goes to infinity we expect these queues to actually just go to infinity. And response time also because it includes waiting time waiting time will go to infinity buffer is going to infinity. So time to wait also goes to infinity and response time also goes to infinity ok. So this is what happens to a GG1 queue. So let us now go to GG1 k. Now what do we have? We have a finite buffer of size k and we have a single server and we have lambda we have we still have the service rate here is mu and this is equal to 1 by tau. And there is some throughput that is coming going to come out of this. Now we will do the same thing here ok we will again make a table starting from throughput this is lambda utilization number in number in system number in queue response time waiting time lambda going to 0 this is low load lambda going to infinity this is high load ok. So lambda going to 0 I think a little bit of thinking you can conclude that it is not going to be very different finite or infinite buffer actually makes no difference for lambda going to 0. So throughput will be 0 utilization will be 0 number in system 0 number in queue 0 response time again does not matter of finite buffer infinite buffer if the request comes into the system it has to spend tau amount of time in service. So this is tau and waiting time again is 0 it is more interesting for finite buffer system as to what happens when lambda goes to infinity throughput ok what will happen to throughput again now what is happening here is that we have actually we have some drop rate here because it is a finite buffer system we have some probability that there is a loss here and with 1 minus P L probability requests are actually able to come into the system. But that is ok as lambda goes to infinity the buffer will be full always no matter even if one space becomes empty in the buffer a new request will come and occupy that. So we expect that the buffer will actually be always full so the server will always be busy if the server is always be busy it can always go do work at the rate mu ok. So in fact we can write both throughput and utilization together so utilization will go to 1 because even though some requests are getting lost the if lambda keeps going so high that even though one request got lost for a moment if the buffer got empty there will be another request that is able to fill that buffer and then it will get processed. So finite buffer does not matter it is a little it is intuitive to think that the server will be busy anyway and if it is busy it is going to produce mu request per second. Number in the system now it is very interesting ok. So we can actually start with Q that is a little more intuitive. How many do you think as lambda keeps going to infinity lots of request coming into the system what will be the asymptotic value for the number of customers in the Q. Obviously the Q is just going to be full all the time it is just going to be full so this will go to K right K is the size of the buffer this will go to K and so since this goes to K there are K here and there is 1 here so we will have K plus 1 in the system now this is interesting first let us do waiting time what is the waiting time in a finite buffer Q ok. So I am going to give an example here of what happens in a system if there are let us say we have 3 let us say K is equal to 3 and lambda is going to infinity K is equal to 3. So pretty much one thing is easy to intuitively agree that when lambda is so high arrival rate is so high and arriving request will pretty much be the last one ok the probability that it will find 2 spaces free is almost 0 ok. So an arriving request will always be here there will be somebody here and there will be somebody here and a new request arrives here ok. So the new request is here ok. So now how long does it take until the request basically goes start service right that is the waiting time how long till the request starts service. So it has to move 1 and 1 more place until it starts service remember from it will go from position 3 to 2 and then it has to go from 2 to 1 and here it is still in the Q and then from 1 into the server right. So just take an example here ok suppose tau is 5 suppose I am standing in a real Q and suppose tau is 5 minutes ok. Just when one request has left this Q if it is a Q of persons one person has left this Q just at that time I will get a place here and the service first service will start right. So now for me to move from 3 to 2 it will take 5 minutes to similarly to go from position 2 to 1 it will take me 5 minutes similarly to move from position 1 to starting my service it will take 5 minutes right. So to generalize this waiting time what is the what is happened here is going to take total 15 minutes. So it is actually 3 multiplied by 5. So to generalize this the time spent in the wait in waiting for service is going to be k tau as lambda tends to infinity right. Again think about it if the request arrival rate is so high I will only be able to join the Q any request that is coming in will only able to join the Q when some request has just left and the last position is basically empty. So you come in here and now you have to move 1, 2, 3 positions until you can start service ok. So this will take 5 minutes, this will take 5 minutes, this will take 5 minutes ok and that is how you get 3 into 5 and that is k tau. So now that we know the limiting value high load asymptote of the waiting time response time is kind of trivial right it will be I will take I will need 5 minutes of my own time to finish my work. So it will be plus 5. So this is actually going to be 20. So similarly is going to be k tau plus tau ok. So these were the high and low load asymptotes for gg1k and we will actually continue the high and low load asymptotes for ggc and ggck in the next lecture. Thank you.