Boffins Create Crash Proof Virtual Computer!

Current computer technology offers high performance, produces 100% accurate results and is fantastic to behold, but is very sensitive to faults as just a single tiny error (just one bit) can crash the whole system, or give an erroneous answer. Even though modern computers implement error correction in the forum of redundancy in hardware and software, it only goes so far. But what if the whole computer could be almost completely destroyed, yet heal itself and carry on as if nothing has happened? That's just what boffins at University College London have achieved with a virtual prototype in the lab.

Erwan Le Martelot, Peter J. Bentley and R. Beau Lotto have achieved this by creating something called a Systemic Computer running Genetic Algorithms, which mimicks how nature works to keep an organism alive by repairing damaged and dead cells, in a virtual machine on a conventional computer. Using this approach, the researchers have shown how GA programs running on SC hardware have native fault tolerance and easily integrated self-maintenance.

In their paper, linked to below, they show how "using a genetic algorithm (GA) implementation on this platform, that SC programs have the native property of fault-tolerance and can be easily modified to become self-maintaining, or healing. We compare several variations of the program, involving various faults and self-maintenance configurations, demonstrating that software can repair itself and survive even severe damage".

Fully understanding the way this works in detail isn't for the faint-hearted, but the basic idea can be explained. While a conventional computer actually processes one instruction at a time and switches rapidly between tasks to give the illusion of working on several tasks at once, a systemic computer actually has various different "systems" in it, all with their own bit of data, which work in parallel and interact with each other in real time to produce the correct answer.

Note that the systemic computer crucially contains multiple copies of its instructions distributed across its many systems, so if one system becomes corrupted the computer can access another clean copy to repair its own code. Also, unlike conventional operating systems that crash when they can't access a bit of memory, the systemic computer carries on regardless because each individual system carries its own memory. It's this that leads to the extreme fault tolerance and repairability achieved.

The above explanation is an oversimplification of how it all works, but the white paper, available from UCL's website below, has all the fine details for those with long attention spans and large mugs of coffee. We have linked to the white paper (581K PDF) below and also attached it to this article, in case it can't be downloaded from there.

Sources: UCL white paper via New Scientist

 LEBELOC3.pdf   581.87K   14 downloads