Prozessor-Architektur, DLX-Befehlssatz und Assembler. Entwurfsprinzipien beim Prozessor-Design

Transkript

1 Prozessor-Architektr, DLX-Befehlssatz nd Assembler Entwrfsprinzipien beim Prozessor-Design Klein ist schnell: Kleinere Hardwareeinheiten können schneller sein, weil Leitngen kürzer sind, Transistoren kleiner sw. ake the common case fast: Wenn eine Entwrfsentscheidng z treffen ist, ist z nterschen, wie häfig eine Verbesserng ggf. bentzt wird. 1 Die CPU-Performance-Gleichng Jeder Compter hat einen Takt mit einer festen Taktfreqenz, z.b. 4 GHz. Der Takt teilt die Zeit in later kleine Abschnitte, so genannte Taktzyklen. Die Länge der Taktzyklen ist gena der reziproke Wert der Taktfreqenz: Beispiel: f= 4GHz => Zyklszeit = 1/(4 *10 9 * 1/s) = 1/4 * 10-9 s = 0, s =0,25 ns Die CPU-Zeit eines Programms kann daher af drei Arten angegeben werden: a) CPU-Zeit = Anzahl der Taktzyklen für das Programm * Zyklszeit oder b) CPU-Zeit = Anzahl der Taktzyklen für das Programm / Taktfreqenz c) Andererseits können wir ach die Anzahl der Instrktionen (IC=instrction cont) zählen, die in dem Programm asgeführt werden. 2

2 Wenn wir die Gesamtanzahl der Taktzyklen des Programms kennen, dann können wir den Drchschnittswert für die Anzahl der Taktzyklen pro Befehl CPI, clocks per instrction ermitteln CPI = Anzahl der Taktzyklen des Programms / IC Der CPI Wert ist für die qantitative Analyse ein asgesprochen wichtiger Parameter, der Einsicht in die Effizienz nterschiedlicher Instrktionssätze gibt. Wir werden ihn häfig bentzen. Drch Einsetzen dieser letzten Gleichng in die CPU-Zeit Gleichng erhalten wir CPU-Zeit = IC * CPI * Zyklszeit = IC * CPI / Taktfreqenz Asführlicher hingeschreiben bedetet diese erste Formel: CPU Zeit Anzahl Instrktionen für ogramm Taktzyklen Seknden Pr Instrktion Taktzykls Seknden für Pr ogramm Die CPU-Zeit hängt von diesen drei Parametern gleichermaßen ab. Eine Verbesserng in einem von ihnen m 10% verbessert die Performance m 10%. 3 Die RISC Idee RISC (redced instrction set compter): Philosophie des Prozessor- Designs, welches die Hardware vereinfacht (nd damit schneller macht). Drch Vereinfachng des Befehlformats, der Speicheradressierng, des Befehlssatzes nd des Registerzgriffs wird die Leistng eines Rechners signifikant gesteigert. Die RISC Idee zeichnet sich drch vier Charakteristika as: 1. Einfacher Instrktionssatz 2. Feste Befehlswortlänge, wenige Befehlsformate 3. Wenige Adressierngsarten, einfache Adressierngsarten 4. Registermaschine mit Load-Store Architektr Diese Pnkte werden im folgenden näher erlätert.

3 Die Register-Architektr: Akkmlator Die Akkmlator-Architektr hat ein asgezeichnetes Register: den Akkmlator. Dieser ist in jeder Operation als ein (impliziter) Operand beteiligt. Load nd Store wirken nr af den Akkmlator. Alle arithmetischen nd logischen Operationen bentzen den Akkmlator sowohl als einen Operanden als ach als Zielregister. Somit kommen alle Operationen mit nr einer Adresse as. Dies ist ein Vorteil, wenn das Befehlsformat klein ist, so dass nicht genügend Bits für die Adressen mehrerer Operanden zr Verfügng stehen. Daher ist die Akkmlator- Architektr (insbesondere im 8-Bit Bereich, z.b. ikrocontroller) ach hete noch gebrächlich. Eine typische Befehlsfolge zr Addition zweier Zahlen in der Akkmlator-Architektr sieht folgendermaßen as: Load A Add B Store C Nachteil ist, dass immer af den Haptspeicher zgegriffen werden mss. Die Register-Architektr: General Prpose Register General prpose Register sind innerhalb eines Taktzykls zgreifbare Speicher im Prozessor, die als Qell nd Zieladresse zgreifbar sind. Sie sind nicht für bestimmte aschinenbefehle reserviert. GPR-Architektren sind hete die gebrächlichsten. Fast jeder nach 1980 entwickelte Prozessor ist ein GPR-Prozessor. Warm? 1.Register sind schneller als Haptspeicher. 2.Register sind einfacher nd effektiver für einen Compiler z ntzen. Beispiel: Operation G = (A*B)+(C*D)+(E*F) die ltiplikationen können in beliebiger Reihenfolge asgeführt werden. Dies hat Vorteile in Sinne von Pipelining. Af einer Akkmlator Architektr würde drch Umladen des Akkmlators gebremst. 3. Register können Variablen enthalten. Das verringert den Speicherverkehr nd beschlenigt das Programm (da Register schneller sind als Speicher). Sogar die Codierng wird kompakter, da Register mit weniger Bits adressierbar sind als Speicherstellen. Dies erlabt ein einfacheres Befehlsformat, was sich in der Compiler-Effizienz nd im Speicherverkehr positiv aswirkt. Für Compiler-Schreiber ist es optimal, wenn alle Register wirklich GPRs sind. Ältere aschinen treffen manchmal Kompromisse, indem bestimmte Register für bestimmte Befehle vorzsehen sind. Dies redziert jedoch faktisch die Anzahl der GPRs, die zr Speicherng von Variablen bentzt werden können.

4 Typen von GPR-Architektren 1. Register-Register-aschinen (load-store-architektren) Alle arithmetischen Operationen greifen nr af Register z. Die einzigen Befehle, die Speicherzgriffe machen sind load nd store. Eine typische Befehlsfolge für das obige Beispiel wäre: Load R1, A Load R2, B Add R3, R1, R2 Store C, R3 Typen von GPR-Architektren 2. Register-Speicher aschinen Bei Register-Speicher-aschinen können die Befehle ihre Operanden as dem Haptspeicher oder as den Registern wählen. Dies erlabt gegenüber den load-store-architektren einen geringeren IC. Dafür mss aber der größere Afwand eines Speicherzgriffs in jeder Operation in Kaf genommen werden, was in der Regel af Kosten der CPI geht. Bekannteste Vertreter der Klasse ist die Intel 8086-Familie nd der otorola Das obige Beispiel sieht af einer Register-Speicher-Architektr so as: Load R1, A Add R1, B Store C, R1

5 Typen von GPR-Architektren 3. Speicher-Speicher-aschinen Diese verfügen über die größte Allgemeinheit, was den Zgriff af Operanden angeht. Operanden können as Registern oder Speicherzellen geholt werden, die Zieladresse kann ebenfalls ein Register oder eine Speicherzelle sein. Unterschiedliche in der Prais übliche Befehlsformante erlaben 2 oder 3 Operanden in einem Befehl. Im Falle einer 3-Operanden aschine ist das Beispiel mit Add C,A,B abgehandelt. Dieser Vorteil wird aber mit afwendigem CPU- Speicher-Verkehr bezahlt. Typen von GPR-Architektren Typ Vorteile Nachteile Register-Register Einfaches Befehlsformat fester Höherer IC als die beiden Länge. Einfaches odell zr anderen. Code Generierng. Instrktionen brachen alle etwa gleichviel Takte. Register-Speicher Daten können zgegriffen Jeweils ein Operand in werden, ohne sie erst z laden. einer zweistelligen Instrktions-Format einfach. Operation wird zerstört. CPI variiert je nachdem von wo die Operanden geholt werden. Speicher-Speicher Sehr kompakt. Bracht keine Register für Zwischenergebnisse. Hoher CPI. Viele Speicherzgriffe. Speicher- CPU-Flaschenhals.

6 Speicher-Adressierng Unabhängig davon, welche Art von aschine man gewählt hat, mss festgelegt werden, wie ein Operand im Haptspeicher adressiert werden kann. Was können Operanden sein? Bytes (8 Bit), Half Words 16 Bit), Words (32 Bit), Doble Words (64 Bit). Es gibt nterschiedliche Konventionen, wie die Bytes innerhalb eines Wortes anzordnen sind: Little Endian bedetet: Das Byte mit Adresse...00 ist das Least Significant Byte (Hersteller: 8086, VAX, Alpha). Big Endian bedetet: Das Byte mit Adresse...00 ist das ost Significant Byte (Hersteller: IPS, otorola, Sparc). In Big Endian ist die Adresse eines Wortes die des SByte, in Little Endian die des LSByte. In vielen aschinen müssen Daten entsprechend ihrem Format asgerichtet (aligned) sein. Das heißt, dass ein Datm, das s Bytes lang ist, an einer Speicheradresse steht, die kongrent 0 mod s ist. Beispiele für asgerichtete nd nicht asgerichtete Daten sind in der folgenden Tabelle: Asrichtng an Wortgrenzen Adressiertes Objekt Asgerichtet af Byte Nicht asgerichtet af Byte Byte 0,1,2,3,4,5,6,7 Nie Half word 0,2,4,6 1,3,5,7 Word 0,4 1,2,3,5,6,7 Doble word 0 1,2,3,4,5,6,7 Speicher sind von der Hardware der DRA- oder hete ach SDRA- Basteine her af die Asrichtng af Wortgrenzen hin optimiert. Deshalb ist bei den aschinen, die keine Asrichtng fordern, der Zgriff af nicht asgerichtete Daten langsamer als af asgerichtete Daten. Zm Beispiel müssen bei einem 32-Bit Zgriff zwei 32-Bit Daten über den Datenbs gelesen werden, nd von diesen müssen per askierng die richtigen 32 Bit ermittelt werden, die dann den geschten Operanden asmachen. Um diesen Nachteil dem Programmierer z ersparen, erzwingen moderne Prozessoren die Asrichtng af Wortgrenzen.

7 Adressierngsarten Adressierngsart Beispiel Bedetng Anwendng Register Add R4, R3 Regs[R4]:=Regs[R4] Wert ist im Register. +Regs[R3] Immediate Add R4, #3 Regs [R4] :=Regs [R4]+3 Operand ist eine Konstante Displacement Add R4, 100(R1) Regs [R4] :=Regs [R4]+em Lokale Variable [100+Regs[R1]] Register deferred Add R4, (R1) Regs [R4] :=Regs [R4]+em Register dient als Pointer. or indirect [Regs[R1]] Direct or absolte Add R1, (1001) Regs [R1] :=Regs [R1]+em [1001] anchmal nützlich für Zgriff af statische Daten Indeed Add R3, (R1 + R2) Regs [R3] :=Regs [R3]+em [Regs[R1]+Regs[R2]] emory indirect Add Regs[R1]:=Regs[R1]+ em[em[regs[r3]]] Atoincrement Add R1, (R2)+ Regs [R1] :=Regs [R1]+ em[regs[r2]]regs [R2] Atodecrement Add R1, -(R2) Regs [R2] :=Regs [R2]-d Regs [R1] :=Regs [R1]+ em[regs [R2] ] Scaled Add R1, 100 (R2)[R3] Regs [R1] :=Regs [R1]+ em[100 + Regs [R2] + Regs Nützlich für array- Addressierng: R1=base of array; R2=inde amont Wenn R3 die Adresse eines Pointers p enthält, dann bekommen wir *p. Nützlich für arrays mit Schleifen. R2 ziegt af den array-anfang; jeder Zgriff erhöht R2 m die Größe d eines array Elements Genaso wie Atoincrement Indizierng von Feldern mit Datentypen der Länge d Befehlsformate nd Codierng Für die Länge der Befehlsworte sind die Anzahl der Register nd die Adressierngsarten entscheidend. Entscheidender als die Länge des opcodes, da sie öfter in einem Befehl aftachen können. Der Architekt mss zwischen folgenden Zielen balancieren: 1. So viele Register nd so viele Adressierngsarten wie möglich z haben. 2. Das Befehlsformat so kompakt wie möglich z machen. 3. Die Längen der Befehlsformate einfach zgreifbar z machen. Letzteres bedetet insbesondere: Vielfaches eines Bytes. oderne Architektren entscheiden sich in der Regel für ein festes Befehlsformat, wobei Einfachheit für die Implementierng gewonnen wird, aber das Optimm an drchschnittlicher Codelänge nicht erreicht wird. Ein festes Befehlsformat bedetet nr wenige Adressierngsmodi. Die Länge der 8086-Befehle können von 1 bis 5 Byte variieren. Die der IPS, Alpha, i860, PowerPC sind fest 4 Byte.

8 Sprngbefehle nd Kontrollflss-Steerng Wir haben bereits die ALU nd ihre Befehle kennen gelernt. Weiterhin ist wichtig, wie der Kontrollflss des Systems vom Programmierer gesteert werden kann. Daz gibt es die Sprngbefehle. Es gibt vier prinzipiell verschiedene Sprngbefehle: Conditional branch: Bedingte Verzweigng Jmps: Unbedingter Sprng Procedre Calls: Afrf einer Prozedr, eines Unterprogramms Procedre Retrns: Rückkehr as Prozedren Die Zieladresse für Sprünge mss im Befehl codiert sein. (Asnahme Retrns, weil da das Ziel zr Compilezeit noch nicht bekannt ist). Die einfachste Art ist ein Displacement (offset), das zm PC (Program Conter) daz addiert wird. Solche Sprünge werden PC-relativ genannt. PC relative Branches nd Jmps haben den Vorteil, dass das Sprngziel meist in der Nähe des gegenwärtigen PC Inhalts ist, nd deshalb das Displacement nr wenige Bits bracht. Aßerdem hat die Technik, Sprngziele PC-relativ anzgeben, den Vorteil, dass das Programm ablaffähig ist, egal wohin es geladen wird. an nennt diese Eigenschaft position independence. Für die PC-relative Adressierng ist es sinnvoll, die Länge des erforderlichen Displacements z kennen. Für die Sprngentfernng von der aktellen Stelle sollten mindestens 8 Bit (12 Bit erreicht bereits fast 100% der Fälle) zr Verfügng stehen. Wir brachen PC-relative nd Register-indirekte Adressierng für Sprünge. Die DLX-560 Architektr DLX, asgesprochen dele - Datenformate nd Befehlssatz - Bateile nd Datenpfade - Assemblerprogrammierng Das Verständnis dieser Architektr ist wichtig, sowohl für die Entwicklng von Hardware als ach für die Entwicklng von schneller nd zverlässiger Software. As den vorangegangenen Kapiteln haben wir eine Reihe von Lehren gezogen, die wir jetzt in einer Beispielarchitektr msetzen wollen: Was sind diese Vorgaben? 16

9 Vorgaben DLX GPR-Architektr, load-store ( =Register-Register) Adressierng: Displacement, Immediate, Indirect schnelle einfache Befehle (load, store, add,...) 8-Bit, 16-Bit, 32-Bit Integer 32-Bit, 64-Bit Floating-point feste Länge des Befehlsformats, wenige Formate indestens 16 GPRs 17 Instrction fetch Instrction decode/ register fetch Eecte/ address calclation emory access Write back 4 Add NPC Zero? Branch taken Cond PC Instrction memory IR Registers A B ALU ALU otpt Data memory LD 16 Sign 32 etend Imm DLX-Steerwerk nicht eingezeichnet! DLX-Datenpfad mit Taktzyklen Alle Register, Daten- nd Adressleitngen sind 3218 Bit!

10 Afba DLX Register: Der Prozessor hat 32 GPRs. Jedes Register ist 32-Bit lang.sie werden mit R0,..,R31 bezeichnet. R0 hat den Wert 0 nd ist nicht beschreibbar (Schreiben af R0 bewirkt nichts) R31 übernimmt die Rücksprngadresse bei Jmp and Link-Sprüngen Es gibt 32 FP-Register. Jedes ist 32 Bit lang, F0,..,F31. Diese können wahlweise als einzelne Single-Register verwendet werden oder paarweise als Doble-Register F0, F2,...,F30. Zwischen den Registern nterschiedlicher Art gibt es spezielle ove-befehle 19 Afba DLX Datentypen: Integer-Typen als nsigned Integer oder im 2-er Komplement: 8-Bit Bytes (B) 16-Bit Halbworte (H) 32-Bit Worte (W) Floatingpoint Typen im IEEE Standard Bit Single Precision (F) 64-Bit Doble Precision (D) Laden von Bytes nd Halbworten wahlweise mit führenden Nllen (nsigned) oder mit Replikation der Vorzeichenstelle (2-er Komplement) 20

11 Afba DLX Adressierngsarten: Displacement nd Immediate. Drch geschickte Bentzng von R0 nd 0 können damit vier Adressierngsarten realisiert werden: Displacement: LW R1, 1000(R2); Immediate: LW R1, #1000; Indirect: LW R1, 0(R2); Direct: LW R1, 1000(R0); Displacement ist dabei die mit Abstand wichtigste Adressierngsart 21 Befehlsformat I - Befehl Opcode rs1 rd Immediate Typische Immediate-Befehle (rd rs1 op immediate) Loads nd Stores von Bytes, Worten, Halbworten (rs1 nbentzt) Bedingte Verzweigngen (rs1 : register, rd nbentzt) Jmp register, Jmp and link register (rd = 0, rs1 = destination, immediate = 0) R - Befehl 6 Opcode 5 rs1 5 rs2 5 rd 11 Fnction Register-Register ALU Operationen: rd rs1 fnc rs2 fnc (Fnction) sagt, was gemacht werden soll: Add, Sb,... Read/write af Spezialregistern nd moves J - Befehl 6 Opcode 26 Displacement (wird z PC addiert) Jmp nd Jmp and link Trap nd Retrn from eception 22

12 Befehle mit Speicherzgriff Befehl Name Bedetng LW R1,30(R2) Load word Regs [R1] 32em [30+Regs [R2] ] LW R1,1000(R0) Load word Regs [R1] 32 em [1000+0] LB R1,40(R3) Load byte Regs [R1] 32 (em [40+Regs [R3] ]0) 24 # # em[40+regs[r3] ] LBU R1,40(R3) Load byte nsigned Regs [R1] # # em[40+regs [R3] ] LH R1,40(R3) Load half word Regs [R1] 32 (em[40+regs [R3] ]0) 16 # # em [40+Regs [R3] ] # # em[41+regs [R3] ] LF F0,50(R3) Load float Regs [F0] 32 em [50+Regs [R3] ] LD F0,50(R2) Load doble Regs [F0] # #Regs [F1] 64 em[50+regs [R2] ] SW 500(R4),R3 Store word em [500+Regs [R4] ] 32 Regs [R3] SF 40(R3),F0 Store float em [40+Regs [R3] ] 32 Regs [F0] SD 40(R3),F0 Store doble em[40+regs [R3] ] 32 Regs [F0]; em[44+regs [R3] ] 32 Regs [F1] SH 502(R2),R3 Store half em[502+regs [R2] 16 Regs [R3] SB 41(R3),R2 Store byte em[41+regs [R3] ] 8 Regs [R2] Instrction fetch Instrction decode/ register fetch Eecte/ address calclation emory access Write back 4 Add + NPC Zero? Branch taken Cond PC Instrction memory IR Registers A B ALU + ALU otpt Data memory LD LW R30, 200(R2) 16 Sign 32 etend Imm lmm DLX-Datenpfad mit Taktzyklen 24

13 Instrction fetch Instrction decode/ register fetch Eecte/ address calclation emory access Write back 4 Add + NPC Zero? Branch taken Cond PC Instrction memory IR Registers A B ALU + ALU otpt Data memory LD SW 200(R3), R28 16 Sign 32 etend Imm lmm DLX-Datenpfad mit Taktzyklen 25 ALU-Befehle Befehl Name Bedetng SUB R1, R2, R3 Sbtract Regs [R1] Regs[R2] Regs[R3] ADDI Rl, R2, #3 Add immediate Regs [Rl] Regs [R2]+3 26

14 Instrction fetch Instrction decode/ register fetch Eecte/ address calclation emory access Write back 4 Add + NPC Zero? Branch taken Cond PC Instrction memory IR Registers A B ALU + ALU otpt Data memory LD ADD R30, R4, R18 16 Sign 32 etend lmm DLX-Datenpfad mit Taktzyklen 27 Weitere Arithmetik- / Logik-Befehle Befehl Name Bedetng SLLI R1,R2,#5 Shift left logical immediate Regs [R1] Regs [R2]<<5 SLT R1, R2, R3 Set less than if (Regs[R2]<Regs[R3]) Regs [R1] Else Regs [R1] 0 28

15 Sprngbefehle Befehl Name Bedetng J name Jmp PC name; ((PC+4) ) name < ((PC+4)+2 25 ) JAL name Jmp and link Regs[R31] PC+4; PC name; ( (PC+4) 2 25 ) name < ( (PC+4) ) JALR R2 Jmp and link register Regs [R31] PC+4; PC Regs [R2] JR R3 Jmp register PC Regs [R3] BEQZ R4,name Branch eqal zero if (Regs [R4] =0) PC name; ( (PC+4) 2 15 ) name < ( (PC+4) ) BNEZ R4,name Branch not eqal zero if (Regs [R4] 0) PC name; ( (PC+4) 2 15 ) < name < ( (PC+4) ) 29 PC-relative Sprngbefehle Die Synta der PC-relativen Sprngbefehle ist etwas irreführend, da der als Operand eingegebene Parameter als Displacement zm PC z verstehen ist. Tatsächlich müßte die erste Zeile heißen: J offset bedetet: PC <--- PC+4 + offset mit <= offset < Das würde aber heißen, daß man in Assemblerprogrammen die Displacements bei relativen Adressen eplizit angeben mß. Dies macht die Wartng eines solchen Programms nglablich schwierig. Daher erlabt man, daß man Namen für die effektiven Adressen einführt, die man wie Sprngmarken (Label) ins Assemblerprogramm schreibt. Ein Precompiler wandelt die Namen in die Offsets m, so daß anschließend die tatsächlichen Offsets verwendet werden können. Für Entwickler nd Leser ist ein solches mit arken geschriebenes Programm leichter verständlich. 30

16 Instrction fetch Instrction decode/ register fetch Eecte/ address calclation emory access Write back 4 Add + NPC Zero? Branch taken Cond PC Instrction memory IR Registers A B ALU + ALU otpt Data memory LD BEQZ R20, #68 16 Sign 32 etend Imm lmm DLX-Datenpfad mit Taktzyklen 31 Gleitkommabefehle Befehl Name Bedetng ADDS F2, F0, F1 Add single precision floating point nmbers ULTD F4, F0, F2 ltiply doble precision floating point nmbers Regs[F2] Regs[F0] + Regs[F1] Regs[F4]##Regs[F5] Regs[F0]##Regs[F1] * Regs[F2]##Regs[F3] 32

17 Instrction type/opcode Instrction meaning Data transfers ove data between registers and memory, or between the integer and FP or special registers; only memory address mode is 16-bit displacement + contents of a GPR LB,LBU,SB Load byte, load byte nsigned, store byte LH, LHU, SH Load half word, load half word nsigned, store half word LW, SW Load word, siore word (to/from integer registers) LF, LD, SF, SD Load SP float, load DP float, store SP float, store DP float OVI2S, OVS2I ove from/to GPR to/from a special register OVF, OVD Copy one FP register or a DP pair to another register or pair OVFP2I,OVI2FP ove 32 bits from/to FP registers to/from integer registers Arithmetic/logical Operations on integer or logical data in GPRs; signed arithmetic trap on overflow ADD, ADDI, ADDU, ADDUI Add, add immediate (all immediates are 16 bits); signed and nsigned SUB, SUBI, SUBU, SUBUI Sbtract, sbtract immediate; signed and nsigned ULT,ULTU,DIV,DIVU ltiply and divide, signed and nsigned; operands mst be FP registers; all operations take and yield 32-bit vales AND,ANDI And, and immediate OR,ORI,XOR,XORI Or, or immediate, eclsive or, eclsive or immediate LHI Load high immediate loads pper half of register with immediate SLL, SRL, SRA, SLLI, SRLI, SRAI Shifts: both immediate (S I) and variable form (S ); shifts are shift left logical, right logical, right arithmetic S_, S_ I Set conditional: _ may be LT, GT, LE, GE, EQ, NE Control Conditional branches and jmps; PC-relative or throgh register BEQZ,BNEZ Branch GPR eqal/not eqal to zero; 16-bit offset from PC+4 BFPT,BFPF Test comparison bit in the FP stats register and branch; 16-bit offset from PC+4 J, JR Jmps: 26-bit offset from PC+4 (J) or target in register (JR) JAL, JALR Jmp and link: save PC+4 in R31, target is PC-relative (JAL) or a register (JALR) TRAP Transfer to operating system at a vectored address RFE Retrn to ser code from an eception; restore ser mode Floating point FP operations on DP and SP formats ADDD,ADDF Add DP. SP nmbers SUBD,SUBF ULTD,ULTF ltiply DP, SP floating point DIVD, DIVF Divide DP, SP floating point CVTF2D, CVTF2I, CVTD2F, CVTD2I, CVTI2F, CVTI2D Convert instrctions: CVT2y converts from type to type y, where and y are I (integer), D (doble precision), or F (single precision). Both operands are FPRs. _D,_ F DP and SP compares: _ = LT, GT, LE, GE, EQ, NE; sets bit in FP stats register 33 DLX-Assembler Befehlssatz (nr diese Befehle sind im Hüsertool implementiert nd sollen verwendet werden) Die Befehle werden in der Form Instr. / Ziel / Qelle(n) verwendet. Bsp: ADDI R3 R2 #15 R3:=R2+15 Instr. Description Format Operation (C-style coding) ADD add R Rd = Rs1 + Rs2 ADDI add immediate I Rd = Rs1 + etend(immediate) AND and R Rd = Rs1 & Rs2 ANDI and immediate I Rd = Rs1 & etend(immediate) BEQZ branch if eqal to zero I PC += (Rs1 == 0? 4 + etend(immediate)) BNEZ branch if not eqal to zero I PC += (Rs1!= 0? 4 + etend(immediate)) J jmp J PC += 4 + etend(immediate) JAL jmp and link J R31 = PC + 4 ; PC += 4 + etend(immediate) JALR jmp and link register I R31 = PC + 4 ; PC = Rs1 JR jmp register I PC = Rs1 LW load word I Rd = E[Rs1 + etend(immediate)] OR or R Rd = Rs1 Rs2 ORI or immediate I Rd = Rs1 etend(immediate) SEQ set if eqal R Rd = (Rs1 == Rs2? 1 : 0) if (Tre) then 1 else 0 SEQI set if eqal to immediate I Rd = (Rs1 == etend(immediate)? 1 : 0) if (Tre) then 1 else 0 SLE set if less than or eqal R Rd = (Rs1 <= Rs2? 1 : 0) if (Tre) then 1 else 0 SLEI set if less than or eqal to immediate I Rd = (Rs1 <= etend(immediate)? 1 : 0) if (Tre) then 1 else 0 SLL shift left logical R Rd = Rs1 << (Rs2 % 32) SLLI shift left logical immediate I Rd = Rs1 << (immediate % 32) SLT set if less than R Rd = (Rs1 < Rs2? 1 : 0) if (Tre) then 1 else 0 SLTI set if less than immediate I Rd = (Rs1 < etend(immediate)? 1 : 0) if (Tre) then 1 else 0 SNE set if not eqal R Rd = (Rs1!= Rs2? 1 : 0) if (Tre) then 1 else 0 SNEI set if not eqal to immediate I Rd = (Rs1!= etend(immediate)? 1 : 0) if (Tre) then 1 else 0 SRA shift right arithmetic R as SRL & see below SRAI shift right arithmetic immediate I as SRLI & see below SRL shift right logical R Rd = Rs1 >> (Rs2 % 32) SRLI shift right logical immediate I Rd = Rs1 >> (immediate % 32) SUB sbtract R Rd = Rs1 - Rs2 SUBI sbtract immediate I Rd = Rs1 - etend(immediate) SW store word I E[Rs1 + etend(immediate)] = Rs2 XOR eclsive or R Rd = Rs1 ^ Rs2 XORI eclsive or immediate I Rd = Rs1 ^ etend(immediate) Beachten Sie: Die Befehle SRA nd SRAI füllen die vorderen Bits des Registers mit dem aktellen Vorzeichenbit af. Ergänzng: Die Befehle HALT oder TRAP #0 beenden das Programm. 34

18 Beispiele für Assembler-Programmierng Sortiere zwei Zahlen A nd B absteigend: A steht an Adresse 1000, B an Adresse 1004 Die größere Zahl soll am Ende in 1000 stehen, die kleinere in 1004 Inpt: Natürliche Zahlen A nd B Otpt: A nd B in der Reihenfolge der Größe ethode: Tasche Inhalte A <-> B, falls A < B Start A, B einlesen A >= B? nein C = A A = B B= C ja if (A < B) Then C = A A = B B = C Otpt A Otpt B } Endif A, B asgeben Ende 35 Sortiere zwei Zahlen A nd B absteigend: Wir wollen dafür ein Assemblerprogramm schreiben. Wir setzen voras, dass die Operanden A nd B an den Adressen 1000 nd 1004 im Speicher stehen nd das Ergebnis sortiert an denselben Adressen entstehen soll: /Register: /R1, R2: A, B /R3, R4: Hilfsregister Start: LW R1, 1000(R0) /Lade A nach R1 LW R2, 1004(R0) /Lade B nach R2 SLT R3, R2, R1 /Setze R3 (ngleich 0), falls B < A BNEZ R3, Ende /Zahlen bereits in der richtigen Reihenfolge. /Sonst vertasche A nd B drch Ringtasch: ADD R4, R1, R0 /R4 := R1 => C = A ADD R1, R2, R0 /R1 := R2 => A = B ADD R2, R4, R0 /R2 := R4 => B = C SW 1000(R0), R1 /Speichern des aimms SW 1004(R0), R2 /Speichern des inimms Ende: HALT /Ende des Programms Ganz wichtig: Programmbeschreibng, Registerbelegng, Kommentare (nicht generisch) Test mit => Vermeidng syntaktischer Fehler 36

19 Beispiel: Berechnng des GGT zweier Zahlen A nd B. Inpt: Natürliche Zahlen A nd B Otpt: GGT(A,B) ethode: Eklidischer Algorithms while (A!= B) // GGT noch nicht gefnden If (A<B) B = B-A // B größer, ziehe A ab else A = A-B // A größer, ziehe B ab GGT = A // A == B, gebe GGT as Start A, B einlesen A = B? nein A < B? nein A = A-B ja GGT = A Ende ja B= B-A 37 /Programmbeschreibng GGT: /Das Programm liest 2 positive Integerwerte A nd B as den Adressen 1000 bzw. 1004, /berechnet GGT(A,B) nd speichert ihn an Adresse /Beispiel: GGT(28,12)=4 /Registerbelegng: /R1,R2: A, B /R3: Hilfsregister Start: LW R1, 1000(R0) /Lade A nach R1 LW R2, 1004(R0) /Lade B nach R2 Loop: SEQ R3, R1, R2 /while: R3 wird gesetzt, wenn (A==B) => A ist GGT BNEZ R3, Ende / => Geh zm Ende, while ist false SLT R3, R1, R2 /if: setze R3, wenn (A<B) BNEZ R3, AklB /Falls A<B gehe z AklB (then-zweig) SUB R1, R1, R2 /else-zweig: A > B => A:=A-B, J Loop /Geh zm Anfang der Schleife (while) AklB: SUB R2, R2, R1 / then-zweig: A < B => B:=B-A J Loop /Geh zm Anfang der Schleife (while) Ende: SW 1008(R0), R1 /Speichere GGT, der in A steht. Halt /Programmende 38

20 Weitere Beispiele für Assembler-Programmierng ergen (zsammenbringen) zweier sortierter Listen der Länge 25. Die eine ist ab Adresse 1000 im Speicher, die andere ab Adresse 1100 abgelegt. Die sortierte Gesamtliste S soll ab Adresse 1200 in den Speicher geschrieben werden. Sortiert heißt: Das kleinste Element steht in der Zelle mit der kleinsten Adresse nd von da an afsteigend. Es sind gleichgroße Elemente hintereinander erlabt. Inpt: Zwei sortierte Listen A nd B Otpt: Eine sortierte Gesamtliste S ethode: Das jeweils kleinste Element der einen Liste wird mit dem jeweils kleinsten Element der zweiten Liste verglichen. Das kleinere von beiden wird in die Gesamtliste gespeichert. Ein nees nnmehr kleinstes Element wird as der Liste geladen, as der das eben gespeicherte Element kam. Sobald eine der Listen verbracht ist, speichert man die restlichen Elemente der anderen Liste in der Reihenfolge ab, in der sie bereits sortiert sind. 39 Start i, j, k =0; A i, B j einlesen A i < B j? nein ja A i in S k speichern i = i+1, k=k+1 Nees A i einlesen B j in S k speichern j = j+1, k=k+1 Nees B j einlesen nein i = 25? j = 25? nein ja B j in S k speichern j = j+1,k=k+1 Nees B j einlesen ja A i in S k speichern i = i+1, k=k+1 Nees A i einlesen nein j = 25? ja i = 25? ja nein End 40

21 /Programmbeschreibng: /erge 2 afsteigend sortierte Listen A, B der Länge 25 in eine Gesamtliste S. /A beginnt an Adresse 1000, B an 1100, S soll ab 1200 gespeichert werden. /Registerbelegng: /R1,R2,R3: Zeiger af Listen A, B bzw. S /R4,R5: A i, B j /R6: Hilfsregister für Vergleiche START: ADD R1, R0, R0 /Initialisiere Zeiger af Listen R1=A,R2=B,R3=S mit 0 ADD R2, R0, R0 / R1=i, R2=j, R3=k: Zähler der Ergebnisliste ADD R3, R0, R0 LW R4, 1000(R1) /Lade A i LW R5, 1100(R2) /Lade B j LOOP: SLT R6, R4, R5 /Ist (A i <B j )? BNEZ R6, AkB /Spring ggf. z AkB (A kleiner B) SW 1200(R3), R5 /S k := B j ADDI R3, R3, #4 /Erhöhe Zeiger k von S ADDI R2, R2, #4 /Erhöhe Zeiger j von B LW R5, 1100(R2) /Lade nächstes B j SLTI R6, R2, #100 /Sind noch weitere Elemente in Liste B? BNEZ R6, LOOP /Springe ggf. z Loop nd vergleiche weiter. /Fortsetzng af der nächsten Folie 41 ARAUS: SW 1200(R3), R4 /Ab hier wird Rest von A herasgeschrieben ADDI R3, R3, #4 /Erhöhe Zeiger k von S ADDI R1, R1, #4 /Erhöhe Zeiger i von A LW R4, 1000(R1) /Lade nächstes A i SLTI R6, R1, #100 /Sind noch weitere Elemente in Liste A? BNEZ R6, ARAUS /Springe ggf. z ARAUS. J ENDE /Sonst springe zm Ende AkB: SW 1200(R3), R4 /S k := A i ADDI R3, R3, #4 /Erhöhe Zeiger k von S ADDI R1, R1, #4 /Erhöhe Zeiger i von A LW R4, 1000(R1) /Lade nächstes A i SLTI R6, R1, #100 /Sind noch weitere Elemente in Liste A? BNEZ R6, LOOP /Springe ggf. z Loop nd vergleiche weiter. BRAUS: SW 1200(R3), R5 /Ab hier wird Rest von B herasgeschrieben ADDI R3, R3, #4 /Erhöhe Zeiger k von S ADDI R2, R2, #4 /Erhöhe Zeiger j von B LW R5, 1100(R2) /Lade nächstes B j SLTI R6, R2, #100 /Sind noch weitere Elemente in Liste B? BNEZ R6, BRAUS /Springe ggf. z BRAUS. Ende: HALT 42

22 Leitfaden für die Bearbeitng von Programmierafgaben Nehmen Sie sich die Zeit, die Afgabe gründlich z lesen. Kleine Beispiele überlegen nd afschreiben, die nterschiedliche Fälle abdecken. Welche Zahlenformate sind geeignet? Welche Grenzfälle gibt es? Welche Probleme können aftreten (z.b. Über-, Unterlaf, Rndngsfehler, Division drch 0)? Entwerfen Sie einen Algorithms nd optimieren Sie diesen (also nicht gleich Code schreiben). Kleine Code-Stücke schreiben nd testen. Programm gt kommentieren nd beschreiben (ach dabei entdeckt man oft noch Fehler). Programm anhand der kleinen Beispiele schrittweise drchlafen lassen. Zm Schlss ach größere Beispiele testen. In der Klasr dürfen Sie das Hüser-Tool nicht verwenden. Sie sollten deshalb genügend üben, damit Sie ach ohne die Hilfen des Hüser-Tools (möglichst) fehlerfreien Code schreiben können. 43 Unterprogramme Betrachten wir znächst folgendes Programm m_mod_n : Berechne m modlo n für positive Integerwerte m nd n. Beim Programmstart sollen m in R1 nd n in R2 stehen. Am Programmende soll das Ergebnis in R1 stehen. Das Ergebnis ist 0 <= R1 < n=r2 Die eigentliche Operation beginnt bei m_mod_n: nd endet bei Fertig: Start m_mod_n: R1 = m, R2 = n m < n? nein m = m-n ja Fertig: R1 = m mod n Ende 44

23 Unterprogramme Afgabe: Berechne e = (b mod a) + (d mod c) drch Wiederverwendng m_mod_n Einfaches Beispiel als C-Programm: #inclde <stdio.h> int Up_m_mod_n(int m, int n); // UP für modlo-berechnng int main() // Haptprogramm { int a=5, b=19, c=3, d=7, e=0,r; // initialisiere r= Up_m_mod_n(b,a); // Übergebe an UP, berechne Resltat printf("berechne %i mod %i = %i\n",b, a, r); e=r; //Speicherng erstes Resltat r= Up_m_mod_n(d,c); // Übergebe an UP, berechne Resltat printf("berechne %i mod %i = %i\n",d, c, r); } e=e+r; printf("smme = %i\n",e); retrn 0; // smmiere Ergebnis 45 Unterprogramm in C Betrachten wir znächst folgendes Programm m_mod_n : #inclde <stdio.h> // UP für modlo int Up_m_mod_n(int m, int n) { //Definition der Fnktion, C-style int r = m; // Zwischenvariable, lokal im UP while (r >= n) r=r-n; retrn r; } // wenn r echt kleiner n // ziehe n solange ab, bis r echt kleiner n // Rückgabe 46

24 Unterprogramm in C Jetzt UP in Assembler-Style: #inclde <stdio.h> // UP für modlo int Up_m_mod_n(int m, int n) { int r = m; m_mod_n: if (r < n) goto Fertig; else r=r-n; goto loop; Fertig: retrn r; } //Definition der Fnktion // Zwischenvariable, lokal im UP // wenn r echt kleiner n // dann m mod n gefnden, beende UP // ziehe n solange ab, bis r echt kleiner n // schlechte C-Prog. aber OK für Assembler //UP beenden, Ergebnis zrück geben 47 Unterprogramme Programmcode: /Berechne m modlo n für positive Integerwerte m nd n. /Beim Programmstart sollen m in R1 nd n in R2 stehen. /R3 wird als Hilfsregister für Vergleiche verwendet. /Am Programmende soll das Ergebnis in R1 stehen. m_mod_n: /Schleifenbeginn SLT R3,R1,R2 /R3 wird gena dann gesetzt, wenn R1<n. BNEZ R3,Fertig /in R1steht das Ergebnis m modlo n => Fertig SUB R1,R1,R2 /R1 soll solange m n redziert werden, bis R1<0 J m_mod_n /Springe zm Schleifenanfang Fertig: /Programmende HALT Welche Probleme treten af, wenn m_mod_n als Unterprogramm verwendet werden soll? Rücksprngadresse? Registerbelegng? Parameterübergabe? => Stacks (Kellerspeicher) verwenden! 48

25 Der Stack Ein Stack (Kellerspeicher) ist ein Speicher, af den nr af bestimmte Weise zgegriffen werden kann: Psh nd Pop. it dem psh-befehl wird ein neer Wert af den Stack gelegt (von oben in den Keller gelegt), zsätzlich z den bereits im Stack befindlichen Werten. it dem pop-befehl wird der oberste Wert vom Stack gelesen, wobei er im oment des Lesens as dem Stack gelöscht wird (von oben as dem Keller geholt). an kann sich das ach so wie eine rnde Tablettendose vorstellen, deren Qerschnitt die Form der Tabletten hat: Wenn man eine nee Tablette hinein tt, kann man zerst nr diese wieder heras holen. Erst wenn man die oberste Tablette heras genommen (gelesen) hat kann man af die nächste, darnter liegende Tablette zgreifen. 49 Der Stack Stacks werden in Comptern realisiert als Teile von physikalisch vorhandenem RA. Dabei bentzt man als Hilfsvariable einen Pointer (Zeiger) af den Top-of- Stack (ToS), also af die Speicherzelle, in die zletzt ein Element hineingeschrieben worden ist. Darüber hinas merkt man sich ggf. in einer weiteren Hilfsvariablen den Bottom-of-Stack (BoS), also die Speicherstelle des ersten Elements, das im Stack steht, damit man eine Prüfmöglichkeit hat, wann der Stack drch wiederholtes Lesen leer geworden ist. Dieser Bottom-of-Stack verändert sich nie, während der Top-of-Stack bei jeder psh-operation hoch- nd bei jeder pop-operation herntergezählt wird. In der folgenden Grafik ist die Aktivität eines Stacks dargestellt: Es sind vier Elemente im Stack gespeichert. Danach werden drei weitere Elemente in den Stack geschrieben, jeweils indem der ToS erhöht wird nd das nee Element an der Adresse des neen ToS gespeichert wird. Danach wird ein Element gelesen, indem die Speicherzelle, af die der ToS zeigt, gelesen wird nd danach der ToS verringert wird. Der Stack kann byte-, halbwort-, oder wortorientiert sein, wodrch sich ergibt, dass psh nd pop den ToS in eine byte-adressierbaren Speicher jeweils m 1, 2 oder 4 verändern. 50

26 Der Stack Speicher Speicher Speicher Nach dreimal psh Nach einmal pop ToS ToS ToS BoS BoS BoS 51 Der Stack nd Unterprogramme Stacks werden in der Informatik an vielen Stellen verwendet. Ein Beispiel dafür finden wir in der Assembler-Programmierng, wenn wir geschachtelte Unterprogramme implementieren sollen, die von nterschiedlichen Stellen afgerfen werden sollen. Wir müssen ns dann nämlich beim Afrf eines Unterprogramms die Stelle im Programm merken, von der wir weggesprngen sind, m dorthin zrück gelangen z können, wenn das Unterprogramm seine Berechnng asgeführt hat. Dies geschieht zweckmäßigerweise mit einem JAL-Befehl (JAL steht für Jmp And Link). Dieser vollzieht einen Sprng an die angegebene Adresse nd merkt sich den NPC, also die Speicherstelle des folgenden Befehls im Programmspeicher im Register R31. Am Ende des Unterprogramms kann man dann einfach mit einem JR R31 (JR steht für Jmp Register) an diese Stelle zrückspringen nd somit kann das afrfende Programm fortgesetzt werden. Wenn nn aber R31 bereits belegt ist nd ein neer Afrf eines Unterprogramms findet statt (z.b. weil ein Unterprogramm sich selbst afrft), dann müssen die Inhalte der Register, die das afrfende Programm benötigt, gerettet werden, m sie für den Rücksprng wieder herzstellen. Dies betrifft insbesondere das Register R31, das ja für den Rücksprng gebracht wird. 52

27 Lokale Variablen nd Register in Unterprogrammen Ach für andere Register kann die Rettng der Registerinhalte wichtig sein. Im bereits vorgestellten Programm m_mod_n verwenden wir R1 bis R3. Wenn wir nn as diesem Programmstück ein Unterprogramm entwickeln wollen, dass von beliebigen Stellen afgerfen werden kann, müssen wir ns Gedanken darüber machen, ob R1 bis R3 vom afrfenden Programm anders verwendet wrden nd die Registerinhalte von R1 bis R3 beim Afrf des Unterprogramms znächst gerettet nd bei der Beendigng wieder hergestellt werden müssen. Der Speicherbereich, in dem die Register gerettet werden, ist sinnvollerweise als Stack organisiert: Unmittelbar nach dem Afrf des Unterprogramms werden die Registerinhalte mit wiederholten psh-operationen af den Stack geschrieben. Unmittelbar vor dem Rücksprng as dem Unterprogramm werden die Registerinhalte drch pop-operationen vom Stack geholt nd in den Registern wieder hergestellt. Der DLX hat leider keinen speziellen psh/pop-befehl, sondern ToS wird über ein selbst gewähltes Register (z.b. R30) nd dessen Inkrementierng / Dekrementierng realisiert. R30 darf dann nr für ToS gentzt werden! 53 Parameterübergabe in Unterprogrammen mit dem Stack Des weiteren kann mit Hilfe des Stacks die Parameterübergabe erfolgen: Bei nserem Beispiel m_mod_n kann das afrfende Programm die Parameter m nd n af den Stack pshen nd zsätzlich einen Speicherplatz für das Ergebnis reservieren. Das Unterprogramm kann dann die Parameter m nd n vom Stack holen nd am Ende des Unterprogramms das Ergebnis an die reservierte Stelle des Stacks schreiben. Beispiel: /Berechne R5:=(R2 mod R1) + (R4 mod R3) mit Hilfe / des angepassten Unterprogramms Up_m_mod_n. /Vorassetzngen: / In R1 bis R4 stehen positive Integerwerte. Ergebnis < 2^31. / R5: Ergebnis / R6: Hilfsregister / R7 bis R29 werden nicht überschrieben / R30: ToS (=Top of Stack), z Beginn ToS=

28 Haptprogramm zm Unterprogramm Up_m_mod_n /Programmbeschreibng nd Registerbelegng s. vorangegangene Folie Hp_Start: /Start des Haptprogramms ADDI R30,R0,#1000 /ToS wird mit 1000 initialisiert / erster UP-Afrf, Übergabe vom HP af Stack SW 0(R30),R2 /R2, Speichern der Übergabeparameter af dem Stack SW 4(R30),R1 /R1 SW 8(R30),R0 /Reservierng für das Ergebnis nd Initialisierng ADDI R30,R30,#12 /Erhöhe ToS (3 psh, daher 34=12 Byte) JAL Up_m_mod_n /Berechne R2 mod R1 in Unterprogramm SUBI R30,R30,#12 LW /Redziere ToS (3 pop af ToS) R5, 8(R30) /Hole das Ergebnis (R2 mod R1) vom Stack nd speichere es in R5 / Zweite UP-Afrf, wieder hole Stackprozedr SW 0(R30),R4 /R4, Speichern der Übergabeparameter af dem Stack SW 4(R30),R3 /R3, für den 2. Afrf des Unterprogramms mit R4 mod R3 SW 8(R30),R0 /Reservierng für das Ergebnis nd Initialisierng ADDI R30,R30,#12 JAL Up_m_mod_n /Berechne R4 mod R3 SUBI R30,R30,#12 /Redziere ToS (3 pop af ToS) /Erhöhng ToS (3 psh, daher 34=12 Byte) LW R6, 8(R30) /Hole das Ergebnis (R4 mod R3) vom Stack nd speichere es in R6 ADD R5,R5,R6 /Berechne das Gesamtergebnis R5=(R2 mod R1) + (R4 mod55r3) HALT /Ende des Haptprogramms Angepasstes Unterprogramm Up_m_mod_n (1. Teil) Up_m_mod_n: /Start des Unterprogramms /Berechnet m modlo n für positive Integerwerte m nd n. /m nd n werden vom Stack geholt nd in R1 bzw. R2 gespeichert. /R3 wird als Hilfsregister für Vergleiche verwendet. /Am Programmende wird das Ergebnis af den Stack geschrieben. / Der Stack ist drch HP schon mit den Übergabeparametern belegt. ToS (R30) zeigt af die nächste freie Stackadresse /Alle Operationen ab hier nr Parametersicherng SW 0(R30),R1 /Retten der Registerinhalte R1 bis R3, die vom SW 4(R30),R2 /Unterprogramm überschrieben werden. SW 8(R30),R3 SW 12(R30),R31 /Rücksprngadresse sichern, falls innerhalb des Unter- /programms weitere Unterprogramme afgerfen werden LW R1,-12(R30) /Holen der HP-Übergabeparameter vom Stack LW R2,-8(R30) ADDI R30,R30,#16 /Erhöhen des Stackpointers (4 psh) /Alle Operationen bis hier nr Parametersicherng /Fortsetzng af der nächsten Folie 56

29 Angepasstes Unterprogramm Up_m_mod_n (2. Teil) m_mod_n: /ab hier beginnt eigentliche Operation des UPs SLT R3,R1,R2 /m<n? BNEZR3, Fertig /Falls m<n steht in R1 das Ergebnis m modlo n SUB R1,R1,R2 /m soll solange m n redziert werden, bis m<n J m_mod_n Fertig: / die eigentliche Operation des Ups endet hier /Alle Operationen ab hier nr Parametersicherng SUBI R30,R30,#16 /Redziere Stackpointer, 4 pop SW -4(R30),R1 /Speichere das Ergebnis af dem Stack LW R1,0(R30) /Hole gerettete Registerinhalte vom Stack LW R2,4(R30) LW R3,8(R30) LW R31,12(R30) /Hole Rücksprngadresse vom Stack /Alle Operationen bis hier nr Parametersicherng JR R31 /Rücksprng zm afrfenden Programm 57