Slashdot Mirror
Cascading Molecules Drive IBM's Smallest Computer
Benoit Fries writes "EE Times reports that IBM researchers have created a simple computation engine that's more than 250,000 times smaller than the most advanced silicon circuitry. Called the world's smallest computer, the system relies on a 'molecular cascade' that pushes a handful of carbon monoxide molecules across a copper surface to perform digital logic functions. 'Even if CMOS density follows Moore's Law for 40 more years, molecular cascades are still going to be smaller,' they said."
I think IBM is going off the wrong direction in tackling Moore's Law.
We should be attempting massive parallelism instead of packing more logic per area.
Isn't that how our brain works?
Niiice. This means we don't have to learn new calculus to program assembly and STILL experience the computing power of single atoms. Good. My head hurts when thinking about sets AND super-sets at the same time (read, quantum computing)
I am the Barber of Seville.
I am sure they said the same thing when the Univac was invented.
I am the Alpha and the Omega-3
Somebody correct me if I am getting this whole thing wrong, but AFAIK, when you go down to molecular levels, due to the uncertainty principle, sometimes the dominos will not fall as you predict, becauese either
1) they were already fallen you just didn't know, or
2) statistically speaking there is a much higher chance for "spontaneous reverse-thermodynamics" on a molecular level.
what i mean is that while macroscopically speaking, the universe is headed toward higher entropy, molecularly speaking, it's not necessarily so; The example commonly given is that you can drop and shatter an egg, or an shattered egg can come together, absorbing the sound waves etc and rise back into your hand. the latter will not (or, has completely ignorable probability of) happening, but as you and the egg gets smaller, the chance of this ignorable probability becomes less so.
hence, a molecular computer has the probability of operating "faultily" because of the laws of thermodynamics is not followed 100%. this is currently overcome by the thousands / millions of electrons we send over gates, probabilistically speaking they still behave on a macro level, but a molecular computer has no such luxury.
i mean, even there was only a minute chance that one molecule will go backwards as what we intended -- counting up the billions of calculations per second we expect from each chip, and the number of chips out there, and then the number of seconds / days / monthes / years they are expected to operate, the chance of error is almost inevitable. some serious redundancy / self-healing hardware / software might need to be invented.
i am just blabbing, though. like i said: i am no molecular physicist, so if there are some here, please comment.
My life in the land of the rising sun.
Yes, a few billion CO molecules are really going to kill you. In this test, it was probably more in the range of hundreds. A gram of CO is about 21499952344431130617588 molecules. I think you should be more worried about the stuff in current computers...
Actually it was the other way around. Its speed was phenomenal at the time, but the size and cost were prohibitive.
In any case, it has little bearing on the validity of the original poster's point. A CPU operating at 1Hz is useless unless it is massively parallel. It is also worth noting that you would need several billion of these CPUs in parallel just to equal one of todays processors. So, until they can make it go several billion times faster (not an exageration btw) it is just an interesting experiment.
If my memory serves me right, an alternative term is "chelate" compounds. And I believe its Magnesium - not Manganese that is present in chlorophyll.
There is no such thing as luck. Luck is nothing but an absence of bad luck.
No, it is not overrated at all. The problem lies in the non-wide usage of languages like Concurrent C that are build from the ground up to support parallelisation.
//accessed by two or more threads //access to global x //indirect access to global x //thread1 //thread2 //main
//multithreaded access
//indirect access to multithreaded 'x' //this should be caught from the compiler.
A compiler should be able to find all memory accesses that are parallel and provide the appropriate locks around that memory. I don't have the time to prove it mathematically, but here is the idea:
Let's say that memory address X is to be accessed from two or more threads.
int x;
void access_x()
{
x = 5;
}
void indirect_access_x()
{
access_x();
}
void foo1()
{
access_x();
}
void foo2()
{
indirect_access_x();
}
int main()
{
begin_thread(foo1);
begin_thread(foo2);
}
What stops a compiler from understanding that both threads access the memory location 'x' ? all it needs to know is where a thread starts. Then it could certainly built a tree internally for variable access.
Even in cases that you have pointers and parameters, the multithreaded access can still be caught by the compiler:
int x;
int *p =
void pointer_access()
{
*p = x;
}