Features on silicon chips have continued to shrink, but they're coming close to hitting a wall where quantum effects will make controlling the flow of electrons a completely different challenge than the ones chip designers currently face. That's left many materials scientists considering other materials, such as carbon nanotubes. At 10nm in diameter, they're not much smaller than the features we're likely to be able to etch into silicon within the next few years. But the high conductivity of the nanotubes makes them relatively energy efficient.

Nanotubes are a pain to work with since they are produced as a mixture of two different forms (conducting and the semiconductors needed for chips). They also don't integrate well with existing manufacturing processes. But now a research team at Stanford has overcome those hurdles to make a processor that uses carbon nanotubes to execute the code for a multitasking operating system. The processor is incredibly simple—it only executes a single logical command, one bit at a time—but it's a huge step forward.

The paper that describes this device, published today in Nature, is a mixture of materials science and computer science.

Making a processor

When we visited IBM, their focus was on taking the mixed population of carbon nanotubes that are easy to produce and then separating out the semiconducting ones. In that way, they'd have a pure population to use to start building circuits. The challenge was then getting these tubes to settle in to the right locations on a set of wires so that they can form functional circuitry. Any errors in this process, and you'd end up with a non-functional device.

The Stanford team sacrificed feature size to get a device they were sure would work. Each transistor site was big enough to hold hundreds of carbon nanotubes, and a mixture of conducting and semiconducting tubes was placed in each of these sites. After the tubes were in place, current was sent through in a way that ensured the conducting ones were selectively ablated. The net result was that each of the features had anywhere between 10 and 200 semiconducting nanotubes forming its functional gate.

The researchers suggest that part of the problem is that they're using an on-campus foundry to make their chips, so the features of the underlying wiring aren't very small to begin with. But it's clear that the redundancy they require to get this technique to work at all is also a major contributor. In some ways, that may not matter as much, as they say a figure that measures the energy efficiency of circuitry (the energy–delay product) is more than 10 times better when the circuits are made with carbon nanotubes.

This particular demonstration also runs at only 1kHz, so it's well below any current chips. The researchers blame that in part on the fact that the chip incorporates monitoring equipment to determine exactly what's going on at each step. Regardless of the compromises made for this demonstration project, it's clear that the techniques used here are not going to be showing up in anything commercial without significant improvements.

Executing code

To keep things simple, the researchers decided to implement a single logical function, called SUBNEG. SUBNEG is a fairly complicated function in that it grabs a number from one address, subtracts it from the number in a second, and stores the result in the second's address. If the result is negative, it then shifts to executing a third memory address. The key thing about SUBNEG, however, is that it's what's called Turing complete. This means that, with the right arrangement of subneg units, it's possible to execute any function you want. In fact, the researchers have implemented 20 different instructions from the MIPS architecture using nanotubes.

That was more than enough to implement some simple programs; the authors demonstrated both a counter, which goes up each time a loop is executed, and an integer sorting program.

They also managed to create an operating system of sorts. The OS loads programs into blocks of memory and keeps track of which block is currently executing and which memory address is being executed. Each program includes the ability to cede control to another; when it does, the OS chooses the next block, and finds the memory address that was next in line. Then, when the original program determines which memory address to execute next, the OS hands it the appropriate address in a different block.

It's pretty hard to get very excited about a computer that's so limited in its capabilities. And it also seems unlikely that the large features produced by this particular fabrication technique mean that a variation on it is going to end up being the one used for the first commercial nanotube processor. Regardless of the limitations, though, the paper may help mark a key transition. It's no longer enough to simply demonstrate a single functional circuit; we're at the point where devices made from carbon nanotubes (or their cousin graphene) have to actually do something.

Nature, 2013. DOI: 10.1038/nature12502 (About DOIs).

Listing image by flickr user: Geoff Hutchinson