Homebrewed CPU Is a Beautiful Mess of Wires
wired.com
wired.com
Get a bunch of the crew together and sit around the table wire wrapping while exchanging stores from the cube.
Bob: "Steve, can you pass me a blue 16AWG strand..."
Steve: "Sure thing, your 4-bit CPU is turning out quite nice.."
Bob: "Thanks Steve, that's a pretty nice thing to say coming from someone who just finished a 8-bit dual core"
[Rest of the Crew]: "Ahhhh...."
You can design whatever piece of hardware you want and still have it execute at a decent speed (say 50 MHz, vs. 2 GHz for a Pentium). But I can put millions of gates of logic.
An 8-bit CPU is maybe 5,000 gates at most. A decent 32-bit RISC processor is below 100,000 gates.
My previous employer builds machines filled with such FPGAs (http://eve-usa.com). On those, you can map really crazy stuff like real, modern processors. It's the ultimate sandbox for the hardware designer.
The only problem is that they tend to be a little bit pricey for amateurs (but I hear you can get boxes real cheap through university programs - lucky students).
I imagine there is something very satisfying of individually wire-wrapping thousands of connections and dealing with the minutiae of a complicated electronic device that prototyping a FPGA just can't give you, especially for a pet hobby.
Incidentally, if you ever get to the Computer History Museum in San Jose, they have an original computer from the Apollo missions there...which is also a bunch of wrapped wires. Gave me quite a shiver to imagine 3 people trusting their life to that.
He and I were talking yesterday about the massive knowledge-base at Intel where they have a very tight grip on semiconductor technology. He was musing that if Intel suddenly went up in flames, our culture would take a step back about 40-50 years.
His point being that these new transistors (32nm and subsequently 28nm gate width) are so incredibly complex that few people understand exactly how they work and all the issues underlying.
Not sure where the industry is headed, but the limit is fast approaching.
Those types of statements have a short half life in the semiconductor industry.
“Why did I do all this?” he says. “I don’t know. But it has been a lot of fun.”
Same thing everyone asked me, and I gave the same answer. Glad to see I'm not the only one.
Not a very well-formed thought, but something I think about from time to time.
By your math, every dual-core 64-bit Intel CPU would actually be a 128-bit processor, a quad-core would equate to a 256-bit system, and the Cell would be a very studly 1088-bit chip (64-bit PPE + 8x128-bit SPEs).
You appear to be confusing "linear" scaling with "exponential", which makes a serious difference.
You should not fall prey to the (in other contexts appropriate) assumption that an increase of one bit inherently doubles complexity (confusing linear with exponential).
That's why the Atari Jaguar is 64-bit. DO THE MATH.
That said, I suspect there will always be a desire to make physical machines with our hands. Even decades after such a thing stopped being a practical tool, this still looks fun.
http://www.computerhistory.org/
They have an example of a computer used on board the Apollo missions that was entirely wirewrapped. The docent said that when they were done debugging they would then pot the whole thing.
Actually surface mount is not all that bad. I have some friends who use it on boards at home for fun.
And I would be surprised if there weren't vendors or other activity using surface mount at the Faire.
Better:
If I had a hand that steady I would still be a brain surgeon...
I don't have the skill or knowledge to attempt a project like this, so I guess that means I have project envy at this point and will have to be voyeur. :)
This brings back lots of late 70's and early 80's memories.
You could make up your own assembly language.
Next easy step : add a memory-mapped bitmap display to your virtual machine. Bochs watch out!
After that, write a compiler for your favourite language towards your assembler and watch it run on your CPU. Then a debugger. Then you would be more awesome than Zed Shaw.
Even better idea : write a CPU simulator! Just a while loop that reads assembler
from a file and interprets it on a virtual CPU. I did this in Java a while ago,
I reproduced a few Intel x86 ASM instructions. MOV, CMP and JMP are all you need
for Turing completeness, if I recall correctly.
This way, the undo function of office becomes trivial to implement! (minus some IO issues)
When I then made modifications I used red wire instead of blue. If it didn't work I knew which wires to replace. If it did I could either leave it and use yellow as the next red, or I could replace the wires. At a glance I could see the state of the build.
A good wire-wrapping tool, good flow with the circuit, I could put three wires every minute for an hour.
I may still have it somewhere ...
At UIUC, one of the assignments for a required course in the Computer Engineering department is to build a (simple) 4-bit processor. We only got a week to do it, so you can be damn sure we used a breadboard and had a system in place to debug the thousands of wires.
There is also 'From NAND to Tetris in 12 steps', I haven't looked closely at that but from what I've heard it gives a similar level of detail.
I'm glossing over a lot of stuff here, but a simple CPU is just that, simple.