Nachdem der Hardware-Zusammenbau recht problemlos verlief und die ersten kleinen Softwaretest sehr vielversprechend waren, musste natürlich en kleines System entwickelt werden:
Auf dem PC erfragt ein Turbopascalprogramm einen Endwert und sendet diesen an Transputer A.
Dieser startet mit dem Wert 0, addiert eins dazu und sendet diesen Wert an Transputer C
Transputer C erhöht den Wert um eins und sendet diesen Wert an Transputer D.
Transputer D erhöht den Wert um eins und sendet diesen Wert an Transputer B.
Transputer B erhöht den Wert um eins und sendet diesen Wert an Transputer C.
Transputer C erhöht den Wert um eins und sendet diesen Wert an Transputer B.
Transputer B erhöht den Wert um eins und sendet diesen Wert an Transputer A.
Transputer A erhöht den Wert um eins und sendet diesen Wert an Transputer D.
Transputer D prüft, ob der Endwert erreicht wurde und sendet die verbrauchte Zeit an das Turbopascalprogramm zurück und sagt den anderen Transputern bescheid, die Schleife zu beenden.
Wahrlich kein wirklich sinnvolles Programm, aber damit lässt sich die gesamte Hardware und ein kleiner Teil des Softwareinterfaces testen.
Das Turbopascalprogramm fällt recht kurz aus:
program ring;
uses LinkLib;
var Endwert:longint;
Zeit:single;
begin
writeln('Ringleitung:');
writeln(' Es wird ein Wert solange herumgeschickt');
writeln(' und um eins erhöht, bis der Endwert erreicht ist!');
Endwert:=0;
repeat
write('Endwert (1.000 ... 10.000.000) ?'); readln(Endwert);
until (Endwert>=1000)and(Endwert<=10000000);
writeln('+++ Es geht los +++');
Int32ToLink(Link1,Endwert);
writeln;
Int32FromLink(Link2, Endwert);
Real32FromLink(Link2, Zeit);
write('Ringlaufzeit :');
write(' Dauer:',Zeit:6:2,' Sekunden., ');
write(Endwert ,' Wörter.');
writeln(' Rate :',Endwert*4/Zeit:10:2,' Bytes pro Sekunde.')
end.
Auch die Occamprogramme sind nicht wirklich aufwändig:
PROC PlusEins(CHAN OF INT LOUT, LIN)
INT Wert:
SEQ
LIN ? Wert
LOUT ! Wert
LIN ? Wert
WHILE Wert >= 0
SEQ
LOUT ! Wert + 1
LIN ? Wert
LOUT ! Wert
:
Auf den Transputern B und C laufen jeweils zwei "+1"-Prozesse:
#USE "PlusE000.tsr"
PROC PlusEinsTwice(CHAN OF INT LOUT1, LIN1, LOUT2, LIN2)
PAR
PlusEins(LOUT1, LIN1)
PlusEins(LOUT2, LIN2)
:
Der Code für Transputer A:
#USE "PlusE000.tsr"
PROC Anfang(CHAN OF INT LOUT2, LIN2, LOUT1, LIN1)
CHAN OF ANY FromHost:
CHAN OF ANY ToHost:
PLACE FromHost AT 4:
PLACE ToHost AT 0:
INT Wert:
INT Ende:
PAR
SEQ
ToHost ! (BYTE 0)
ToHost ! (BYTE 7)
ToHost ! (BYTE 0)
ToHost ! (BYTE 0)
ToHost ! (BYTE 0)
Wert := 0
FromHost ? Ende
LOUT1 ! Ende
LIN1 ? Wert
WHILE Wert >= 0
SEQ
LOUT1 ! Wert + 1
LIN1 ? Wert
LOUT1 ! Wert
PlusEins(LOUT2, LIN2)
:
Der Code für Transputer D:
#USE "PlusE000.tsr"
PROC Ende(CHAN OF INT LOUT2, LIN2, LOUT1, LIN1)
PAR
CHAN OF ANY ToHost:
PLACE ToHost AT 0:
TIMER Uhr:
INT Start:
INT Stop:
INT Wert:
INT Ende:
SEQ
Wert := 0
LIN1 ? Ende
Uhr ? Start
Wert := 0
WHILE Wert < Ende
SEQ
LOUT1 ! Wert + 1
LIN1 ? Wert
LOUT1 ! -1 (INT)
Uhr ? Stop
ToHost ! Ende
ToHost ! (REAL32 ROUND ((Stop - Start) * 64)) / 1000000.0(REAL32)
PlusEins(LOUT2, LIN2)
:
Konfiguration der Transputerumgebung:
[8] CHAN OF INT Link:
PLACED PAR
PROCESSOR 1 T8
PLACE Link[ 0] AT 1:
PLACE Link[ 5] AT 7:
PLACE Link[ 6] AT 2:
PLACE Link[ 7] AT 6:
Anfang(Link[6],Link[5],Link[0],Link[7])
PROCESSOR 2 T8
PLACE Link[0] AT 5:
PLACE Link[1] AT 3:
PLACE Link[3] AT 4:
PLACE Link[4] AT 2:
PlusEinsTwice(Link[1],Link[0],Link[4],Link[3])
PROCESSOR 3 T8
PLACE Link[2] AT 5:
PLACE Link[3] AT 0:
PLACE Link[4] AT 6:
PLACE Link[5] AT 3:
PlusEinsTwice(Link[3],Link[2],Link[5],Link[4])
PROCESSOR 4 T8
PLACE Link[1] AT 7:
PLACE Link[2] AT 1:
PLACE Link[6] AT 6:
PLACE Link[7] AT 2:
Ende(Link[2],Link[1],Link[7],Link[6])
In Action sieht das ganze dann so aus:
Kaum zu glauben, wie kompakt man früher gearbeitet hat:
Das Transprogramm ist für alle 4 Transputer zusammen kompiliert und gelinkt ganze 2392 Byte und das Turbopascalprogramm 17280 Byte groß (Achtung Byte, nicht Megabyte).