2 ms·
So Linus noticed that the page fault on the Intel CPU became slower on the newer CPUs something like 10%. Before and after, it took roughly 1000 ticks to perfor
by acqq 13y ago
So Linus noticed that the page fault on the Intel CPU became slower on the newer CPUs something like 10%. Before and after, it took roughly 1000 ticks to perform the fault. Which just means that if the clock is the same, let's say 3 GHz, instead of 3 millions page faults per second on Core Duo you can now "just" do 2.7 millions of page faults per second. Doesn't sound like something to be much worried about. The code which spends most of its time in page faults is just something that I can't imagine to be an example of the code anybody even attempted to make faster. Linus admits that too: changing the build process would certainly eliminate significant number of page faults in his case. So, my conclusion this time is... Meh. The pig did't fly before and now it won't 10% more so. Intel guys, if you sacrificed this in order to make the instructions that matter faster, I welcome this: Linus also observes that the rest of his code practically got faster around... more than 3 times!? Before, it was around 900 ticks page fault code, the rest of the code around 50 percent of total, that is also 900 ticks. Now it's 1000 ticks PF, the rest around 20% of total (see: Linus claims 80% spent in PF), that is, around 250 ticks for his code. I say, Intel, you did a perfect job speeding up some code that matters to take just 250 instead of 900 ticks between Core Duo and new CPUs. This sounds amazing.
(I of course welcome any arguments that demonstrate that I overlooked something when claiming all this.)
- ultimape 13y agoYes, in Linus's case, it is a faster overall runtime, but such a stark difference in cycle times is a bit of an eyebrow raiser. Caching is supposed to speed things up, so it is kinda silly that the caching system has somehow gone backwards in overall performance. Pagefaults are a critical path for performance concerns in almost any software system that needs high-performance. If they are 10% slower, then its like the worst case performance of the computer is 10% slower. Anyone who needs to write high performance code (say, simulations, or game design: http://gameprogrammingpatterns.com/data-locality.html http://gameprogrammingpatterns.com/data-locality.html ), is concerned with avoiding pagefaults and cache misses, but the average code (general case?) doesn't concern itself with this as much, so the average program may end up experiencing this more than a linux compile.
- acqq 13y agoTry to count the total number of page faults per second in any task you're doing. I don't know of any "average code" that produces an order of 3 millions PF per second, which is needed for you to observe 10% slowdown. The code which does that doesn't do anything than doing the page faults. Linus claims he managed to get 5% slowdown when doing nothing but PF. It's probably something like hundreds of thousands per second at most, giving you something like a less than 0.5% slowdown. Versus the speedup of 300% for some other code (it's an extreme value actually, but still). Your newer Intel CPU certainly didn't get slower on average code compared to the Core Duo, for the same clock speed. Nothing to raise the eyebrows here. I believe it's not "in Linus case" but "in every case" that the overall time is shorter.