 For this example, we're going to look at what happens to a task as we add additional computational units. So we're starting with a baseline machine that has only a single core, and we're going to increase the number of cores in the machine that we're comparing it to. So we'll start with the dual core machine and gradually work our way up. So our machine with the single core obviously spends 25% of its time on the parallelizable code, and we'll spend the other 75% of its time on non-parallelizable code. Machine two takes that same 25% of the code that's parallelizable, and can now run that in half as much time. But it still has to spend the same amount of time to run that 75% that's non-parallelizable. So machine one takes 100% of the time, that's our baseline. Machine two takes 75% plus half of a fourth, which is an eighth. So I get seven eighths over here. So machine two with two cores is eight sevenths times faster than machine one. Next, when I increase that to run on a four core machine, here I've got 25%, and the parallelizable code will only take a quarter of the time it did on the single core machine. But again, non-parallelizable code is still unaffected. So now I have one sixteenth plus three fourths gives me 13 sixteenths. Improvement is getting smaller. Next I'm going to see this on an oct core machine. So again, I've got 25% for my parallelizable code, and it's now taking one eighth the amount of time it did on the single core machine. But I've still got this 75% that's unaffected. So I've got one thirty second plus three fourths, which gives me 25, 30 seconds. Now we'll look at this with a cluster that has a thousand processing cores. So still 25% of the code is parallelizable. This time I've got a thousand cores to run this on. So this part will take one one thousandth amount of time it did on the single core processor. But since I've got this 75% that's still unaffected, I'm not going to get a huge improvement. So I've got three fourths plus one four thousandth, which gives me three thousand and one over four thousand. So you can probably see where these are going. They're getting progressively closer to the three fourths that we can't affect. So much so that if we have an infinite number of processors, we'd still have that 25% that's parallelizable. Now we're running it on an infinite number of cores. The 75% that's non-parallelizable. Well, the one over infinity is basically zero. So I got 25% times zero. So that chunk is now zero and I'm just left with the 75%. So adding additional cores is helpful for this task, but it's not going to fix everything. If I can't complete this task in less than 75% of the time that machine one required, then I'm still going to be in trouble regardless of how many processing units I have to throw at this problem.