Theoretical and Experimental DNA Computation (Natural ...

and
repeat repeat-value times
instruction-sequence
4.9 P-RAM Simulation 93
There is a restriction that the variables start-value, step-value, end-value, and
repeat-value are independent of the specific input data, i.e., are constants or
functions of the number of input items, n, but not of their specific values.
We allow each processor a local register (accumulator), ACC, for conditional
testing and storage of partial results. The instruction instx instantiated
by the control program at processor x is a numbered sequence of basic operations
from the set of primitives listed in Table 4.4.
Table 4.4. Processor instruction set
Symbol Name Meaning
LDC x Load Constant Place the value x in ACC
LDA x Load (direct address) ACC := M[x]
LDI x Load (indirect address) ACC := M[M[x]]
STA x Store in memory (direct) M[x] :=ACC; ACC is set to 0.
STI x Store in memory (indirect) M[M[x]] := ACC; ACC is set to 0
JUMP k Unconditional jump Jump to instruction k
JLT x,k Conditional jump If M[x] < 0 then jump to instruction k
JLE x,k Conditional jump If M[x] ≤ 0 then jump to instruction k
JGT x,k Conditional jump If M[x] > 0 then jump to instruction k
JGE x,k Conditional jump If M[x] ≥ 0 then jump to instruction k
JEQ x,k Conditional jump If M[x] = 0 then jump to instruction k
JNE x,k Conditional jump If M[x] �= 0 then jump to instruction k
ADD x Addition ACC := ACC + M[x]
SUB x Subtraction ACC := ACC − M[x]
MULT x Multiplication ACC := ACC ∗ M[x]
DIV x Integer Division ACC := ACC/M[x]
AND x Bitwise logical conjunction ACC := ACC ∧ M[x]
NEG Bitwise logical negation ACC := ¬ACC
HALT Halt Stop execution
We now consider the parallel complexity measures used within this model. Let
A be a P-RAM algorithm to compute some function f(t1,...,tn) employing
instructions from Table 4.4. The parallel runtime of A on < t1,...,tn >,
denoted T (t1,...,tn), is the number of calls of par do multiplied by the
worst case number of basic operations executed by a single processor during
any of these calls. This is, of course, typically an overestimate of the actual
parallel runtime; however, for the specific class of parallel algorithms with
which we are concerned this is not significant.
The parallel runtime of A on inputs of size n, denoted T (n), is T (n) =
max {t1,...,tn} T (t1,...,tn). The processor requirements of A on ,