Hacker News Reader

Comment by azeirah | Hacker News Reader

As a computer engineering student, I don't understand how adding more transistors to a cpu makes it faster, gpu's, sure. If I wire an 8-bit adder circuit, adding more transistors will definitely not make it process those bits faster.

View on HN

Moore's law is about circuit density.

1) Smaller circuits (used to?) have less capacitance and smaller voltages. Smaller voltages and capacitance enables higher clock-rate with same power consumption (chips don't melt)

2) Spending more transistors for pipelines and multiple execution units in the same core speeds up the processing. Single instruction takes at least five clock cycles from start to finish. With pipelines it's possible to finish one instruction per cycle. With multiple execution units it's possible to finish more than one instruction per cycle. This all from a single core.

3) Cache. Lots of it, different levels. Accessing external memory is very slow. Main cache reference takes about 1 ns. Main DDR MEMORY reference takes 100 ns. Waiting for 100 ns. wastes cycles. Adding prefetching etc. is yet another chunk of transistors.

You can build a second 8-bit adder, plus a bunch of logic to identify add instructions which don't depend on each other, then execute two adds simultaneously.

Modern CPUs can execute several instructions per clock cycle doing things like this.

There are many ways to create adders [0]. And other circuits for that matter. If you are willing to expend more transistors, you can decrease the propagation delay [1], that is, the delay until all outputs have settled to a stable value. Basically the propagation delay is the "longest path" from any input to any output and is a constraint on how fast the clock can go without messing up the calculations. Other ways to make a CPU faster, which costs transistors, is improved branch prediction and parallelism (modern CPUs execute a lot in parallel, even single cores. If there is a conditional branch and it guessed wrong, it has to flush all the wrong stuff it calculated. But there are still speed gains if the branch prediction is okay.)

[0] https://en.wikipedia.org/wiki/Adder_(electronics)

[1] https://en.wikipedia.org/wiki/Propagation_delay

Your 8-bit adder will have to wait ~225 CLKs (possibly x 2) to get the data it needs to add.

Add a ton of transistors to intelligently prefetch and cache will in some cases decrease those 225 CLKs.

A great deal of transistors are added to cache and cache intelligence to get around the terrible latency of DRAM.

If you are allowed to use many transistors, you could create a carry look-ahead adder which would be faster. ;)

There are more ways to speed up your CPU, like identifying instructions that can be executed independently and issue them in parallel, use caches to speed up loading, etc.

Sure. The core of any particular implementation of an arithmetic operation isn't going to get faster with more transistors, but: 1) There is "stuff" before and after the arithmetic operation that matter such as pipelines, cache pre-fetch and instruction branch prediction; 2) There is more than one way to implement an arithmetic function (such as an adder) if you have more/cheap/free transistors, such as the carry look-ahead adder[1].

[1] http://www.slideshare.net/dragonpradeep/carry-look-ahead-add...

More instructions, bigger caches, longer pipelines...

Yes, it will, if done right. See [1]. Then see [2], where this is extended to multiplication. Modern multipliers take a lot of transistors but only need a few gate delays before the product appears.

[1] https://en.wikipedia.org/wiki/Carry-lookahead_adder [2] https://en.wikipedia.org/wiki/Binary_multiplier

If you had more transistors, you could make a 16-bit adder circuit!

The difficulty is in getting all the features you want within the space provided while adhering to the laws of physics.

Or 8x16 or 8x32 adders which is SIMD.

Sort of for the the same reason it makes GPUs faster - parallelism. You can have multiple CPU cores. Or you can add parallelism to instruction handling by adding branch lookahead - where you basically execute a sequence of instructions in parallel. The deeper the lookahead, the more transistors (exponentially?) need to be added.

Reply on news.ycombinator.com