 So this example takes a different perspective on the topic. In this case, we've got two machines, and we know something about how Machine A has been run on this program. And we'd like to be able to estimate how Machine B will perform when giving the same task. Now, in this case, we're saying that Machine A spends 25% of its time on the CPU, 25% of its time accessing a hard drive, and 50% of its time accessing a network. And for the purposes of this problem, we'll just assume that we have a very simple machine to work with that doesn't spend its time doing both. A good machine would try to proactively load data from hard drive or from the network so that the CPU isn't sitting around waiting for those, because those end up taking the most amount of time, and the CPU will frequently either go do something else or try to load that data ahead of time. So it is stuck waiting around quite as long for that. In this case, we'll assume that our CPU doesn't do any of that. It's either going to run the CPU, the hard drive, or the network. In this case, we know something about the properties of both machines, and we're going to be looking at how that changes the expected execution time for Machine B, even though we don't really know a whole lot about what Machine A is spending its time on. So we can begin with just writing down execution time for Machine A. Obviously, Machine A spends 25% of its time on the CPU, 25% of its time accessing the hard drive, and 50% of its time accessing the network. That's of course 100% of its time to CPU, hard disk drive, and network. So Machine B will actually make us think. We will have to do something to manipulate these numbers that we've got from Machine A so that we can get an estimate from Machine B. So to begin with, we know that we still have the same amount of CPU work to run. So we'll start with that 25%, 25% of the workload is CPU instructions. Now we want to add something that tells us about how we expect the performance to differ between those two. So we're going to be interested in looking at what properties of Machine A affect the CPU performance, what properties of Machine B affect the CPU performance, and how those will combine to change how much time Machine B is spending running CPU instructions. So I know that Machine B has a 2.5 GHz processor, and Machine A also has a 2 GHz processor. So Machine B will run the CPU instructions slightly faster than Machine A did, and I'm going to want to represent that as another performance ratio. In this case, I expect that this will run faster on Machine B, so I should have a performance ratio that's less than one. If my performance ratio was greater than one, then the CPU instructions would end up taking longer on Machine B. But I know that Machine B has a 2.5 GHz processor, which is faster than Machine A's 2 GHz processor. So I'm going to put these into another relative performance ratio, and I'm going to put the 2 GHz processor on the top and the 2.5 GHz processor on the bottom. So I'm going to say that, well, Machine B takes about 80% as much time as Machine A did to run the CPU instructions. So I can reduce this to 4 5ths, which is 80%. Now I need the hard drive term. Again, that's 25% of the original computation. So this time we're looking at the memory, actually, instead of the hard drive. In this case, our memory is going to be cache in Machine B. Our memory can cache extra information, so that means we're spending less time accessing the hard drive. We're ready to return that information to the CPU more often. So in this case, it's telling us very simply that Machine B just halves the number of calls to disk. So that means I'm going to have half as many calls to the hard disk drive, and accordingly I'll spend half as much time accessing the hard drive. So I'll simply add a 1 half there. The last part here is the network. So networked is taking 50% of the original computation, and Machine A has a 100 megabit network card. Machine B has 1 gigabit per second network card. So Machine B is about 10 times faster on the network portion, so we should expect that if I do the same thing as I did with the CPU, I'm setting up a relative performance ratio. I've got 100 megabits on the top. On the bottom, I'd put 1 gigabit, which will be 1,000 megabits. So that would be one-tenth. So I'm going to solve this equation. So I've got 80% of 25%. It leaves me with 20% for the CPU. I've got 1 half of my 25%, which is 12.5%. And I've got 1-tenth of this 50%, which is 5%. Add those together, and I will get 37.5%, which is 3 eighths. So Machine A took 100% of the time. Machine B is only taking 3 eighths as much time. So Machine B is clearly faster, and how much faster is it? Well, it's 8 thirds times faster than Machine A because it runs in 3 eighths as much time.