 So, let's flip the problem around. We can also consider what would happen if we knew how much speedup we wanted, and just needed to know how many processing units were required to accomplish that. So, in this case, we have a task that's 75% parallelizable, and we're starting with the dual core machine, and we'd like to see how many processing units would be required to get a two-time speedup, four-time speedup, and really just what is the maximum amount of speedup we can get on this problem. So, we'll start by looking at our baseline machine, which is this dual core machine, and we know that 75% of our code is parallelizable. We also know that this is a dual core machine, so there's already some parallelizable speedup on this part. So, it's already taking half as much time as it really could, and the remaining 25% of the code is unparallelized. So, I have 25% plus 37.5%, which will give me 5 eighths. So, I want to find a replacement for this term that will allow me to set up a relative performance ratio where the final result is two. So, I'll have some machine A where 75% of the code is parallelizable, and it's going to be running on, say, A number of processors, and 25% is non-parallelizable, and I'll get some number, and when I take 5 eighths and divide it by this, I should expect to get two out as a result. So, I could now just start solving for A, or I can solve for this thing and then solve for A. It's probably easier to start by solving for this thing and then solve for A. So, I have 5 eighths divided by something equals two. I really want to swap the something, the two. So, I'll divide 5 eighths by two. That will give me 5 sixteenths. So, 5 sixteenths is half as much time as 5 eighths is. So, now I need to solve for A. So, I'll start by subtracting the 25%, 1 fourth, or 4 sixteenths, which leaves me with 1 sixteenth, and then I'll multiply both sides by A and divide by the 1 sixteenth. So, I'll get 75% times 16 equals A, and 3 fourths of 16 is 12. So, if I have 12 cores, then I can double my performance on this problem. So, I'll write this down and then make room for the next part. So, again our dual core machine took 5 eighths as much time as it would on a single core machine. Now, we'd like to get four times speed up over this. So, we'll have some machine B that takes 1 fourth as much time, or when I put it into this performance ratio, I'll get a result of 4 out. So, again, you'll swap this variable with 4, and that will leave me with 5 30 seconds this time. So, now I have to get machine B to run in 5 30 seconds as much time as a single core machine. So, machine B, again, have 75% of our code is parallelizable, and that's taking 1 over B amount of time to run on this machine, and another 25% that's non-parallelizable. And this should be equal to our 5 30 seconds. So, now I need to solve for B and subtract the 1 fourth 5 30 seconds. 1 fourth would be 8 30 seconds, which gives me negative 3 over 32, and then I'll want to multiply both sides by B and divide by the negative 3 over 32, which will give me 75% times 32 over negative 3 is equal to B. So, I'll reduce this 3 fourths times 32 over negative 3, which means 96 divided by negative 12. So, which is equal to negative 8. So, in order to solve this problem in 4 times faster than our original dual core machine, I need negative 8 cores. So, you're probably wondering what does this mean? Well, it's really pretty hard to have a negative number of cores. What this is really telling me is that I need to complete this portion of the task in a negative amount of time. If you notice when we got to here, we had a negative number, which means that this chunk of time has to be completed before this chunk of computation has to be completed before we even start thinking about running this program in order to complete the other 25% in that total 5 30 seconds. So, really if I'm getting a negative number out, then this is not going to be possible. I'm not going to be able to run this in reverse time. I'm not going to be able to use this to work as a time machine and run backwards in time just so I can start my process. If I had something that did this, this would be great. We'd be able to run all of our programs in zero time. We'd just front load everything with whatever this task is that takes negative time and then run our task. So, we can't get four times speed up out of this. We have this 25% chunk that is just eating up most of our computation at that point. So, we'll write down that I can't get a four times speed up. And then next we'll look at well, how much speed up can I get on this? So, in order to figure out, so in order to figure out how much speed up we can get, we're going to use the same formula. We're still just going to be looking at estimating our execution time. And we'll have some machines see that still requires, that's still doing 75% of the computation as parallelizable. And it's going to run on some arbitrary number of cores. And we'll have some portion of this code that's nonparallelizable. This time though, we're going to let the number of cores go to infinity. We're going to see what the results are. So, if I substitute infinity input here for the number of cores, then this term will go to zero. And I'll just be left with this 25%. And the top part of my relative performance equation is still the 5 eighths. So, when I've got 5 eighths divided by 1 fourth, I can reduce this to 20 over 8 or 5 halves. So, this is the most amount of speed up I can get relative to that dual core machine that I started with. It's running two and a half times faster than the original machine, which is more than two times, which we saw we could do, but not four times, which we saw we couldn't do. Good enough.