Not all of the entries to The Hackaday Prize were serious – at least we hope not – and this one is the most entertaining of the bunch. [Eduardo] wants to put a flux capacitor in a CPU pipeline. Read that last sentence again, grab a cup of coffee, mull it over, and come back. This post will still be here.
Assuming the events portrayed in BTTF could be real in some alternate history or universe, consider the properties of a DeLorean time machine: It requires 1.21 Jiggawatts (we’re assuming this is Gigawatts from now on), has a curb weight of about three thousand pounds with the nuclear reactor and/or hovercar conversion, and is able to travel in time ± 30 years. If the power required to travel time were to scale proportionally with mass, sending a CPU register back in time would only require a Watt or so. Yes, ‘ol [Doc Brown] had it wrong with wanting to send a car back in time – sending information back is much, much easier. Now, what do you do with it?
[Eduardo] is using this to speed up pipelined CPUs. In a CPU pipeline, instructions are executed in parallel, but if one instruction depends on the output of another instruction, bad things happen CPU designers have spent long, sleepless nights figuring out how to prevent this. Basically, a MEMS flux capacitor solves all outstanding problems in CPU design. It’s brilliant, crazy, and we’re glad to see it as an entry to The Hackaday Prize.
[Eduardo], though, isn’t seeing the forest for the trees. If you have a flux capacitor in your CPU, why even bother with optimizing a CPU? Just take a normal CPU, add a flux capacitor register, and have the output of a long and complex calculation write to the time traveling register. All calculations then happen instantly, your Ps and NPs are indistinguishable. All algorithms run in O(1), and the entire endeavor is a light-hearted romp for the entire family.
This project is an official entry to The Hackaday Prize that sadly didn’t make the quarterfinal selection. It’s still a great project, and worthy of a Hackaday post on its own.
Hold on to your hats, because this is a good one. It’s a tale of disregarding the laws of physics, cancelled crowdfunding campaigns, and a menagerie of blogs who take press releases at face value.
Meet Silent Power (Google translation). It’s a remarkably small and fairly powerful miniature gaming computer being put together by a team in Germany. The specs are pretty good for a completely custom computer: an i7 4785T, GTX 760, 8GB of RAM and a 500GB SSD. Not a terrible machine for something that will eventually sell for about $930 USD, but what really puts this project in the limelight is the innovative cooling system and small size. The entire machine is only 16x10x7 cm, accented with a very interesting “copper foam” heat sink on top. Sounds pretty cool, huh? It does, until you start to think about the implementation a bit. Then it’s a descent into madness and a dark pit of despair.
There are a lot of things that are completely wrong with this project, and in true Hackaday fashion, we’re going to tear this one apart, figuring out why this project will never exist.
Continue reading “Behold! The Most Insane Crowdfunding Campaign Ever”
The Hackaday tips line is always full of the coolest completed projects, but only rarely do we see people reaching out for help on their latest build. We’ll help when we can, but [Tim]‘s relay-based CPU has us stumped.
[Tim] already has the design of his relay CPU completed with a 12-bit program counter, sequencer, ALU, and a transistor-based ROM. The problem he’s having deals with the mechanics and layout of his homebuilt CPU. Right now, all the relays (PC pin, we guess) are glued top-down to a piece of cardboard. This allows him to easily solder the wires up and change out the inevitable mistakes. This comes with a drawback, though: he’s dealing with a lot of ‘cable salad’ and it’s not exactly the prettiest project ever.
The ideal solution, [Tim] says, would be a PCB with through-hole plating, but this isn’t easy or cheap for the home fab lab. We’d suggest some sort of wire wrap setup, but proper wire wrap sockets and protoboards are for some reason unreasonably expensive.
If you have an idea on how to do the mechanical layout and connections of a relay-based computer, drop a note in the comments. [Tim] has a very cool project here, and it would be a shame if he were to give up on it due to a lack of tools.
Video below, and if you’re having a problem with a project, feel free to send it in.
Continue reading “How Do You Build a Relay CPU?”
Maybe we shouldn’t say “built” since [Steve Chamberlin] hasn’t actually heated up his iron yet. From the finished schematic above that is puzzling at first, until you realize the scope of the project. His Nibbler implements a 4-bit CPU using 7400 logic chips. Because he’s come up with the architecture himself he’s taking a lot of steps to check all of his work before committing to a PCB.
We linked to his category for the project which is still in progress. Most recently he wrote a program to prove that it’ll run on the hardware. That’s a feat considering this is still just a design idea. It was made possible because he wrote a simulator based on the design. The C++ tool simulates data and control buses and features a full set of debugging tools.
Careful testing of the design before the build is the best possible way to go. The simulator and debugging tools will be useful for software development even after the hardware is built. And testing before wiring is a must as these things get out of control quickly in terms of soldering complexity.
[via Dangerous Prototypes]
There are basically two ways to compute data. The first is with a DSP, a chip that performs very specialized functions on a limited set of data. These are very cheap, have amazing performance per watt, but can’t do general computation at all. If you’d like to build a general-purpose computer, you’ll have to go with a superscalar processor – an x86, PowerPC, or any one of the other really beefy CPU architectures out there. Superscalars are great for general purpose computing, but their performance per watt dollar is abysmal in comparison to a DSP.
A lot of people have looked into this problem and have come up with nothing. This may change, though, if [Ivan Godard] of Out-of-the-Box computing is able to produce The Mill – a ground-up rethink of current CPU architectures.
Unlike DSPs, superscalar processors you’d find in your desktop have an enormous amount of registers, and most of these are rename registers, or places where the CPU stores a value temporarily. Combine this with the fact that connecting hundreds of these temporary registers to places where they’ll eventually be used eats up about half the power budget in a CPU, and you’ll see why DSPs are so much more efficient than the x86 sitting in your laptop.
[Ivan]‘s solution to this problem is replacing the registers in a CPU with something called a ‘belt’ – basically a weird combination of a stack and a shift register. The CPU can take data from any position on the belt, perform an operation, and places the result at the front of the belt. Any data that isn’t used simply falls off the belt; this isn’t a problem, as most data used in a CPU is used only once.
On paper, it’s a vastly more efficient means of general purpose computation. Unfortunately, [Ivan] doesn’t quite have all the patents in for The Mill, so his talks (two available below) are a little compartmentalized. Still, it’s one of the coolest advances in computer architecture in recent memory and something we’d love to see become a real product.
Continue reading “The Mill CPU architecture”
The two circular displays seen above are Dekatrons built into an optical drive enclosure. [Matt Sylvester] picked up a couple of different types of these tubes on eBay. He etched his own driver, and was able to control them with an Arduino. After a few months went by he decided to revisit the project to see if it would work as a CPU and RAM usage meter.
These tubes need high voltage to get the neon display glowing brightly. This raised some concerns about having those voltage levels inside of his PC, as well as the noise which may be introduced by the supply. To deal with those issues [Matt] gutted an old optical drive, using its case to physically isolate the circuitry, and some optoisolators to protect the logic connections. His driver board uses an ATmega328 running the Arduino bootloader. It connects to the PC using an FTDI USB to Serial cable. This makes it a snap to push the performance data to the display. It also has the side benefit of allowing him to reprogram the chip without opening the case.
If you can’t find one of these tubes for your own project consider faking it.
Continue reading “Drive bay form factor dual Dekatron readouts for RAM and CPU usage”
You’re going to like [Ivan's] write-up for this LED computer status monitor. Of course he didn’t just show-and-tell the final product — if he had you’d be reading this in a Links post. But he also didn’t just detail how he put the thing together. Nope, he shared pictures and details of every iteration that got him here.
It started off with a tachometer. Yeah, that analog display you put on the dashboard of your car which reads out RPM. He wanted to make it into a USB device which would read out his CPU load. But that’s an awful lot of work when it can only display one thing at a time. So he decided to add an 8×8 LED module which would display the load for each individual core of his CPU. It looks great next to the illuminated tachometer. From there he added resolution by transitioning to an RGB module, which ended up sucking him into a coding project to extend the data pushed to his embedded hardware. In the end his ReCoMonB (Real Computer Monitoring Block) displays CPU load, RAM usage, several aspects of HDD activity, as well as the network up and down traffic.
We think he’s probably squeezed all that he can from this little display. Time to upgrade to a TFT LCD.
Continue reading “LED module used to display load, traffic, and status data for your PC”