Every now and then, when I’m bored with normal work, I tend to my personal projects. For some reason, that tends to be midyear, every year. So, here we go…
Old ideas, new style
This time was an old time project, to break the parallelization barrier without the use of locks. I knew simple boolean logic on regular Turing machines wouldn’t do, as they rely on the fact that the tape is only written by one head at a time. If you have more than one head writing to the same place, the behaviour is undefined. I’ve looked into several other technologies…
Some were just variations of Turing machines, like molecular, ternary and atomtronic computers. Others were simply interesting toys, like the programmable water, but there were two promising classes: quantum computers (taking a bit too long to impress) and nondeterministic Turing machine (NTM), that could get around some concurrency problems quite well.
Quantum computers are nice, but they’re more like vector computing on steroids. You can operate on several qbits at once, maybe even use nonlocality to speed up communications, but until all that reaches the size of a small building, we need something different than yetanother ncore fryingpan Intel design. That may be nondeterministic machines…
Nondeterministic Turing machines are exactly like their deterministic counterparts, but the decision process can take different paths given the same input. So, instead of
if (a == 10) do_something;
you have
if (probability(a) > threshold) do_something; .
The problem with that is that you still can’t ignore different processes writing to the same data, since if a process happens to read it (even if by chance), the data you get from it is still being concurrently changed, therefore, still undefined. In other words, even if the state change is probabilistic, the data is still deterministic.
So, how can you make sure that, no matter how many processes are writing to a piece of data at random times, you still have meaningful data?
Well, if the reading part is not interested into one particular value of that data, but say, only in the probability of that data be a certain value, then it doesn’t matter in which order the writes are performed, as long as they’re all writing about the same thing. That can be viewed as a nondeterministic register, not a nondeterministic Turing machine. You can still have a deterministic machine reading and writing on nondeterministic registers, that you still won’t need locks for those values.
Probabilistic registers
Suppose you want to calculate an integral. You can use several very good deterministic algorithms (like the Romberg’s method), but if you create producers to get the values and consumers to reduce it to a sum, you’ll need a synchronized queue (ie. locks) to make sure the consumer is getting ALL the values. If you loose some values, you might get a completely wrong result.
If instead, you create random generators, getting the value of any (multidimensional) function from random values, and accumulate them into a nondeterministic register (say by updating the average of the last values, like recharging a capacitor that keeps discharging), when the consumer process read the value from it, it’ll get an average of the previously written values. Because the writes are all random, and if you keep only the average of the last N writes, you know how much data is being filled in and what’s the average value for that block.
In essence, you’re not storing any particular value, but information enough to recreate the original data. Since specific values are not important in this case, the order in what they appear (or if they appear at all) is completely irrelevant.
In a way, it’s similar to quantum mechanics, where you have the distribution of probabilities but not the values themselves. With a few tricks you can extract every information from those distributions. This is also similar to what Monte Carlo methods are. Taking the probabilistic side of computations in order to achieve a rough image of the problem quicker than by bruteforce, when the complexity of the problem would be nonpolynomial and the problem size would be big enough to need a few billion years to calculate.
Here are some examples of a nondet register.
A new logic
Obviously, current deterministic algorithms cannot run on such machine. All of them are based on the fact that specific data is stored in a specific place. If you compress a file and uncompress it back again, it’s just impossible to work with probable values, your original file will be completely undecipherable. Also, boolean logic cannot operate on such registers, Operating an AND between probabilities or a XOR of two averages doesn’t make any sense. You need a different logic, something that can make sense of probable inputs and analog streams. Fortunately, Bayesian logic is just the thing for such machines.
But the success of Bayesian logic in computing is not enormous. First, it’s not simple to create algorithms using a network of probabilities, and very few mundane algorithms can benefit from it to be worth the trouble. (Optimor labs is a good example). But with the advent of this new machine, a different logic has to be applied and new algorithms must be developed to make use of it.
Probably by mixing deterministic with nondeterministic hardware and creating a few instructions that would use the few nondeterministic registers (or accumulators) available. Most likely they would be used for interprocess communication in the beginning, but as you increase the number of those registers you can start building complex Bayesian networks or also neural networks in the registers themselves. That would open the door to much more complex algorithms, probably most of them unpredictable or found by trial and error (genetic approach?), but with time, people would begin to think that way and that would be the dawn of the nondeterministic computing.
Eureka moment
The probabilistic register was an Eureka moment, when I finally implemented it and saw that my simple montecarlo or my neuron model was really a threeline code, but that didn’t last long…
A few days ago I read the news that DARPA has developed a fully featured probabilistic processor, taking random computation to the masses, even using Bayesian logic in place of boolean logic! The obvious place for a “public trial” was spam filtering (though I think the US military is not that interested into filtering spam…), but according to them, the sky is the limit. I do have to agree…
Anyway, I wouldn’t have 5 spare years nor $18mi in the bank to implement that project like they did, so in a way I’m glad that it turned out to be a good idea after all. I just hope that they make good use of it (ie. not use it for Carnivore 2.0), and they realize that not only the military have uses for it, or antispam filters, for that matter. We (them?) should develop a whole new set of algorithms to work on that logic and make good use of a hardware that is not a simple progression of current technology (to keep Moore’s law going), but could be a game changing in the next decades.
I could refocus on defining the basic blocks for that processor’s new logic, but I’m sure DARPA has much better personnel to do that. So, what’s next, then? I’ll tell you next year…
