Theoretical and Experimental DNA Computation (Natural ...

102 4 Complexity Issues
best attainable (where S is the total space used by the P-RAM algorithm).
One consequence of this is that the class, NC, of efficient parallel algorithms
can be realized in DNA with only a small loss of speed and increase in size.
We note some further points of interest about our simulation process. First,
the translation from CREW P-RAM to DNA algorithm is an effective and
practical one. It thus follows that, in at least one computational paradigm,
the CREW P-RAM is an architecture that can be realized. This is despite
the fact, noted by many researchers, that the technological overheads implied
by a global common memory regime, to say nothing of the Concurrent Read
facility, which means that within traditional silicon approaches the CREW
P-RAM is not a constructible, scalable machine. In other words, our DNA
realization gives a feasible, concrete implementation of what has been regarded
as a purely abstract device. The second point concerns the nature of the
translation process itself. Although no published CREW P-RAM algorithms
are actually specified at the “machine code” level we regard as the basic
processor instruction set, it is quite clear that, starting from a (sequential)
program specified in an ersatz-ALGOL formalism, such algorithms could be
compiled into a program over the basic instruction set specified in Table 4.4.
It is also clear, however, that the process of translating the “assembly level”
program to a combinational circuit specification is a mechanical one, and,
furthermore, the creation of DNA strands from a given NAND circuit can
also be performed automatically. If we combine these chains of ideas, then we
see that a high − level CREW P-RAM to DNA compiler process is readily
available. We now give a worked example of this compilation process.
4.12 A Worked Example: The List Ranking Problem
We give, in this section, a worked example of the ideas presented above on a
typical CREW P-RAM algorithm. The example we choose is the list ranking
algorithm from [64]: given a list, L, ofn =2 m elements, the problem is to
associate with each element k avaluerank(k) corresponding to its distance
from the end of the list. For each list element k alocationnext(k) givesthe
location of the next element in the list. For the last element, next(k) =k. We
describe the algorithm as described in [64]:
for all k ∈ L in parallel do
begin
P (k) :=next(k);
if P (k) �= k then
distance(k) :=1;
else
distance(k) :=0;
end
repeat log n times