## Turing Processing## Turing Processor## Turing Programs |

Starting in 1985, this hypothetical model of a multitape Turing
machine has been developed by
A. Schönhage as a medium
for an efficient implementation of algorithms dealing with
multi-precision data. The TP model has seven *tapes* for storing
data, the underlying *alphabet* is the set of all 32-bit
words for a *TP32* (or 16-bit words for a *TP16*), and
the finite control is embodied in some *Turing program*
for a little *RISC* processor written in assembly language.

The very first implementation was undertaken in 1985/86, running fast
integer multiplication on a small *MC68000*-based machine.
Later on, thanks to the programming skills of my coauthors
*A.F.W. Grotefeld* and *E. Vetter*, we could then
establish advanced versions running on SUN workstations and other
platforms, with our TP-book
plus more recent Addenda as the
*main reference* - also serving as a *programmer's guide*.

Libraries of such TP routines are organized in *modules*.
Chapters 6-9 of the TP-book describe the modules
INTARI for integer arithmetic, QARI for rational
arithmetic and integer gcd's, RECARI for computing with
r-codes and c-codes (binary rationals approximating real and
complex numbers), and CREPARI with routines for complex and
real polynomials.

Meanwhile we have added many new routines. Due to increased size,
module CREPARI had to be split into separate modules
CREPAR + CREPEX, and there are now two additional modules
PORTA, PORTB containing our new routines for approximate
factorization of complex polynomials and approximate computation of
polynomial roots.

For documentation of the precise interfacing conditions of the
new routines and any updates for the old routines of
Chapters 6-9 we are now maintaining so-called
*docfiles* like `intardoc` etc. as
listed at the end of the *Addenda*. These are pure
*ASCII*-files to provide robust portability.

To resolve these problems, I decided to write a new implementation of TP32 myself - then called

After disposal of my ancient ATARI, at present there seems to be no
workable implementation of a TP16. On the other hand, one could wish
to use a TP64, in order to exploit the power of modern
64-bit processors, but that would also require substantial
modifications in many of our TP routines.

In case somebody wants to implement TP32 for some other platform,
s|he may take advantage of the fact that our assembler
*tpa02*, when applied to a TPAL source file
`XYZ.t`, performs a *first pass* translating this
into a *module file* `XYZ.m32`
being stored as a sequence of 32-bit words in a machine
independent intermediate code. We have designed that
m32 format such that
it may also serve as a basis for a TP32 in hardware.

with a brief outline of TPS02 in

docfiles

TP-book related

and

with `dry' compressed TP modules

Moreover, quite recently we had to fix a bug in routine QSUB of our Rational Arithmetic (cf. TP-book item 7.1.24). In one of its branches it returned y-x instead of x-y. So use the new module

- Assembly command
`tpa02 -?? XYZ.t`for translating TPAL source`XYZ.t`admits options ?? to output the intermediate code module`XYZ.m32`(also as hex dump`XYZ.h32`), or to retranslate it to compressed format`XYZ.dry`; under TPS04,`tpa4`replaces`tpa02`; *tpa02, tpa4*support the new directives and commands related to*table look-up,*as specified in Section 1.2 of the Addenda;- debugging at runtime is supported by a rich repertoire of tracing facilities, like stepping with source code display, setting breakpoints, display of timer accounts, of the stack, dumps of tape segments with decoding support, keyboard interrupts;
- large-scale memory supply: besides allocation of
*m*MB in main memory (with*m*·2^{17}bytes per tape), any additional disk space can be accomodated for the Turing tapes (or for the stack) via so-called*tapefiles*; - to combine some Turing program with other software, typically
with some master program written in C or C++, it can be run
as a child process; such
*TP-server*receives its input via an*INTAPE pipe*from the parent process and returns its results via another pipe written by*OUTAPE*.

Last modified: Sun Jul 1 17:11:34 CEST 2018