 So this example pretty much combines everything we've seen so far. We'll have multi-core processors and machine B has a larger cache. So it's going to spend less time waiting for disk access than machine A does. But we'll again set this problem up pretty much the same way we've done all the others. So I'll start with machine A and machine A has a quad-core processor. So I'm going to have to count for the parallelization in the CPU instructions even for machine A before I even look at machine B. So 25% of my program is dedicated to CPU processing. So 25% of my instructions are CPU instructions and machine A gets a four-time speed up thanks to its quad-core processor. So that means that the other 75% of my instructions are memory instructions. And machine A doesn't get any sort of benefit for these instructions. So I have 1 fourth times 1 fourth is 1 16 plus 12 16th gives me 13 16ths. So this is how much time it takes for machine A to run this task relative to some single-core processor that has no speed ups whatsoever. Machine B gets the same programs which has 25% of its instructions are CPU instructions. And it gets a six-time speed up for having this hex core processor. And 75% of the instructions are memory instructions. But this time machine B has an advantage on memory instructions relative to machine A. Machine B is only going to spend 80% as much time running these memory instructions as machine A did because of its 20% improvement. So I'll multiply this amount of execution time by the four-fifths and then add all of these up. So I've got a one-fourth times a one-sixth gives me one-twenty-fourth. And then I have three-fourths times four-fifths gives me 12 20ths. So my common denominator here will be one-twentieths. I'll need to multiply this side by five, this term by five, this term by six. So five plus 72 is 73. So machine B requires 73 one-twentieths as much time as that serial machine that we are not interested in. Since we're interested in the performance of machine A relative to machine B, I would set up the relative performance ratio as 73 over 120 divided by 13-sixteenths. Which is about 0.7481. So machine A is about three-fourths as fast as machine B. Or machine B is four-thirds times faster than machine A. So as we'd expect, machine B is a little bit faster, slightly faster on memory, slightly faster on the CPU. And that adds up to about a 33% speed up over machine A. Now, if we flip that around so that 75% of our program is dedicated to CPU processing and the other 25% is for memory, then we'll get some different results. But the basic algorithm is the same. So this time I have 75% of my instructions are CPU instructions. And machine A already runs those in parallel. So they take about one-fourth as much time as a single memory instruction does for machine A. And the other 25% of my instructions here are memory instructions. So I've got three-sixteenths and one-fourth, which gives me seven-sixteenths. And for machine B, still 75% of the operations are CPU operations, which take, which are parallelized. So that machine B only requires one-sixth as much time. The other 25% of the instructions are memory instructions. And again, machine B has an advantage over machine A here. So again, it's going to take four-fifths as much time to complete those instructions on machine B as it did on machine A. So now I have three-twenty-fourths and four-twentieths. And again, our common denominator will be 120. We'll get 39 over 120. So the relative performance ratio here, again, we're looking at the performance of machine A relative to machine B. So we're going to take the time for machine A on the bottom and the time for machine B on the top of our equation. So machine A gave me seven-sixteenths and I have 39, 120, which is equal to 20 times 16 over 7, which is about 0.7428. So there's a slight change between the first situation and the second. Machine B comes out slightly ahead on the second situation, where there's more time spent on the CPU than on memory. Not a whole lot. For the most part, the speed up here is pretty evenly distributed. For machine B, it gets pretty even speed up across memory and CPU. But there is some difference there.