Dat1E G2 - En enkelt/dobbelt-cyklus mikroarkitektur. Espen Højsgaard Rune Højsgaard Christian Iversen

Transkript

1 Dat1E G2 - En enkelt/dobbelt-cyklus mikroarkitektur Espen Højsgaard Rune Højsgaard Christian Iversen 1

2 Indhold 1 Sammenfatning 3 2 Enkelt-cyklus mikroarkitektur Tilføjelser til datastien Tilføjelser til kontrollen Enkelt/dobbelt-cyklus arkitektur Opdeling af instruktioner Opdeling Kontrol Køretider 4 5 Litteratur 4 A Diagram over enkelt-cyklus arkitektur 6 B Kildekode til enkelt-cyklus arkitektur 7 B.1 alu.k B.2 alu-control.k B.3 control.k B.4 single-cycle.k C Diagram over enkelt/dobbelt-cyklusarkitektur 11 D Kildekode til enkelt/dobbelt-cyklus arkitektur 12 D.1 alucontrol.k D.2 double-cycle.k D.3 maincontrol.k D.4 pccontrol.k E Udskrift af kørsler 16 E.1 fib E.1.1 Enkelt-cyklus E.1.2 Enkelt/dobbelt-cyklus E.2 logtst E.2.1 Enkelt-cyklus E.2.2 Enkelt/dobbelt-cyklus E.3 scatter E.3.1 Enkelt-cyklus E.3.2 Enkelt/dobbelt-cyklus E.4 slttest

3 E.4.1 Enkelt-cyklus E.4.2 Enkelt/dobbelt-cyklus E.5 sort E.5.1 sort.in E.5.2 Enkelt-cyklus E.5.3 Enkelt/dobbelt-cyklus

4 1 Sammenfatning Dette er en besvarelse af anden godkendelsesopgave på kurset Datalogi 1E 2003, Københavns Universitet [2]. Læseren forventes at have læst opgaveformuleringen samt - som minimum - at have samme forudsætninger som en elev, der har fulgt kurset. Formålet med opgaven er i kreds at implementere en enkelt- og dobbelt-cyklus mikroarkitektur, der kan udføre en lille delmængde af MIPS maskinsprog. Vores ambition var at lave en fungerende minimumsløsning af begge kredsløb, med fokus på simple overskuelige valg, frem for mere avancerede løsninger. Begge de designede kredsløb fungerer og lever op til vores ambitionsniveau. 2 Enkelt-cyklus mikroarkitektur Vores enkelt-cyklus mikroarkitektur er, som foreslået i [2], baseret på den arkitektur, der er beskrevet i [1, afs ] og vist på fig i samme bog. Denne arkitektur understøtter dog ikke alle de krævede instruktioner, hvorfor det har været nødvendigt at udvide datastien og kontrollen. Kildekoden til programmet kan ses i appendiks B. 2.1 Tilføjelser til datastien De instruktioner, der ikke kan udføres på arkitekturen fra [1], er: I-type, BNE, JAL og JR. I det følgende gennemgår vi de ændringer vi har fundet nødvendige for at understøtte disse. Appendiks A viser et diagram over kredsløbet. I-type instruktionerne forudsætter at konstanter i de 16 mindst betydende bit af instruktionen kan føres ind i ALU en. Konstanterne skal både kunne nul-forlænges og fortegnsforlænges, hvilket klares ved en simpel ændring af den fortegnsforlænger, der optræder i forlægget. BNE-instruktionen medfører ingen ændringer af datastien, da den følger BEQ-instruktionen. JAL medfører at adressen på den næste instruktion (PC+4) skal føres ned til muxen, der vælger inddata til registrene. Derudover skal konstanten 31 ($ra) føres ind i muxen, der vælger det register, der skal skrives til. JR medfører at den første uddata-linje fra registrene skal føres ind i en mux, der vælger adressen på den næste instruktion. 2.2 Tilføjelser til kontrollen Kontrol-delen af kredsløbet er ikke ændret væsentligt fra forlægget i [1]. Der er tilføjet enkelte kontrol-linjer og ALUOp-linjen fra Control til ALU control er udvidet. Dette sker da I-type ordrene ikke kan angive operationen i funct-feltet af instruktion, hvorfor det er de seks mest betydende bit, der bestemmer ALU ens operation. 3

5 3 Enkelt/dobbelt-cyklus arkitektur Vi har valgt en simpel modifikation af enkelt-cyklus-kredsløbet, hvor de fleste instruktioner kun kræver en cyklus. Vi har indsat en flip-flop før data-porten til hukommelsen og fjernet den separate adder, der beregner branch-adressen. Kredsløbet kan ses i appendiks C og kildekoden i appendiks D. 3.1 Opdeling af instruktioner Vores opdeling bygger på at både læsning og skrivning til hukommelsen tager 5 ns. Ud fra denne antagelse har vi beregnet en øvre grænse for clockfrekvensen på vores enkelt-cyklus 1 kredsløb på 2 5ns = 100MHz (beregnet ud fra den givne adgangstid samt LW og SW, der tilgår hukommelsen to gange pr. instruktion). Da den reelle clockfrekvens for enkelt-cyklus kredsløbet er ca. 85MHz har vi sluttet at hukommelsen er den mest betydende komponent, hvorfor vi har besluttet kun at tilgå hukommelsen i starten af hver cyklus Opdeling Da det kun er LW og SW-kommandoerne der tilgår hukommelsen er det de eneste instruktioner, der behøver to cykler for at bringe clockfrekvensen væsentligt op. Derudover har vi valgt at spare på transistorerne ved at lade de to branch-instruktioner bruge ALU en til både at sammenligne og beregne hop-adressen, hvorved BEQ og BNE også tager to cykler. Det er dog ikke altid nødvendigt. Hvis man undersøger betingelsen i første cyklus kan man gå direkte til næste instruktion, hvis betingelsen ikke er opfyldt og dermed spare en cyklus. Resten af instruktionerne kan udføres på en cyklus. 3.2 Kontrol Den vigtigste ændring af kontrollen er tilføjelsen af en 1-bit flip-flop, der angiver kontrollens tilstand. Derudover har vi tilføjet en kontrolenhed, der styrer hvilken adresse næste instruktion skal hentes fra og om denne adresse skal skrives til PC. Denne opdeling gør kredsløbet nemmere at overskue og PLA erne nemmere at implementere. 4 Køretider Den simulerede udførselstid for de fem testprogrammer på hver arkitektur er angivet i tabel 1. Udskrifterne af kørslerne kan ses i appendiks E. For samtlige programmer er den simulerede udførselstid bedre for enkelt/dobbelt-cyklus arkitekturen end for enkelt-cyklus do. Da hukommelsesinstruktionerne (og til dels branchinstruktionerne) er langsommere end før (138MHz/2 = 68MHz), er det ikke overraskende, at den faktor, som clockfrekvensen er forbedret med ( MHz MHz = 1.6), ikke også er forbedringen i køretiden. 4

6 Arkitektur enkelt-cyklus enkelt/dobbelt-cyklus fib µs µs logtst µs µs Program scatter µs µs slttest µs µs sort µs µs Tabel 1: Køretider Litteratur [1] David A. Patterson and John L. Hennessy. Computer organization and design : the hardware/software interface. Morgan Kaufmann Publishers, Inc., second edition, [2] Martin Zachariasen. En enkelt/dobbelt-cyklus mikroarkitektur. dat1e godkendelsesopgave 2, oktober

7 A Diagram over enkelt-cyklus arkitektur 6

8 B Kildekode til enkelt-cyklus arkitektur B.1 alu.k alu ( ina {32} inb {32} opcode {3} ) >> ( Res {32} Zero {1} ) inb >> notarray {32}; notarray inb opcode [2] >> muxadd {1 32}; opcode [1..0] >> [ select ] mux {2 32}; // ## I n g o i n g c o n n e c t i o n s ( from i n w i r e s ) // 000 And o p e r a t i o n 001 Or o p e r a t i o n ( ina inb )/2 >> andarray {32 2}, orarray {32 2}; // 010 Add o p e r a t i o n ina muxadd opcode [2] >> adder {32}; // 011 No o p e r a t i o n // 100 No o p e r a t i o n // 101 No o p e r a t i o n // 110 Subtract // a l r e a d y d e c l a r e d i n 010 // 111 Set on l e s s than // a l r e a d y d e c l a r e d i n 010 end // ## Outgoing c o n n e c t i o n s ( to o u t w i r e s ) ( adder [ cout ] >> not1 ) ina [31] inb [31] >> myxor {3}; 0{31} myxor // 111 Set on l e s s than adder [ sum ] // 010 Add/110 Sub o p e r a t i o n orarray [ out ] // 001 Or o p e r a t i o n andarray [ out ] // 000 And o p e r a t i o n >> [in]mux [ out ] >> Res ; adder [ sum ] >> or {32} >> not2 >> Zero ; B.2 alu-control.k ALUcontrol ( ALUOp {3} Func {6}) >> ( JumpReg {1} Binvert {1} Opcode {2}) // ALUOp[ 2 ] // ALUOp[ 1 ] // ALUOp[ 0 ] // Func [ 5 ] ( i n s t r u k t i o n [5 0] = Func ) // Func [ 4 ] // Func [ 3 ] // Func [ 2 ] // Func [ 1 ] // Func [ 0 ] // controlplane = " , " // addi " , " // andi " , " // o r i " , " // s l t i " , " // sub " , " //R format ( add ) " , " //R format ( sub ) " , " //R format ( and ) 7

9 end " , " //R format ( or ) " , " //R format ( s l t ) " "; //R format ( j r ) // // ALUInput [ 0 ] // ALUInput [ 1 ] // ALUInput [ 2 ] ( Binvert ) // JumpReg [ 0 ] ALUOp Func >> PLA { controlplane } >> JumpReg Binvert Opcode ; B.3 control.k control ( Opcode {6} ) >> ( ALUSrc {1} Branch {1} BranchNE {1} Jump {1} Link {1} MemRead {1} MemtoReg {1} MemWrite {1} RegDst {1} RegWrite {1} SignExt {1} ALUOp {3} ) // Op [ 5 ] // Op [ 4 ] // Op [ 3 ] // Op [ 2 ] // Op [ 1 ] // Op [ 0 ] // // controlplane = " , " // R format " , " // lw " , " // sw " , " // beq " , " // bne " , " // j " , " // j a l " , " // addi " , " // s l t i " , " // andi " "; // o r i // DCBA // // 1 ALUOp0 // 2 ALUOp1 // 3 ALUOp2 // 4 SignExt // 5 RegWrite // 6 RegDst // 7 MemWrite // 8 MemtoReg // 9 MemRead // ALink // BJump // CBranchNE // DBranch 8

10 end // ALUSrc Opcode >> PLA { controlplane } >> ALUSrc Branch BranchNE Jump Link MemRead MemtoReg MemWrite RegDst RegWrite SignExt ALUOp ; B.4 single-cycle.k // F i l e n implementerer en e n k e l t c y k l u s m i k r o a r k i t e k t u r, // der implementerer det æunderst a f MIPS, der e r // b e s k r e v e t i Dat1E G main () // Udregn PC+4 PC{ FlipFlop 32 0} 4{32} 0{1} >> add1 {32}; add1 [ cout ] >> _ {1}; // Lav hukommelsen og brug PC som a d r e s s e // (æ l s e s hver ved hver c y k l u s ) PC 1{1} >> [ iaddrin, ird ] Memory { IdealMemIOSys 5}[ idataout ]; // Stop s i m u l a t i o n e n ved i n s t r u k t i o n e n FC Memory [ idataout ] >> and1 {6} or1 {26} >> {1} not0 >> and2 {2} >> [ stop ] SimSysCtrl ; // Hovedkontrollen ( c o n t r o l. k ) å f r opkoden Memory [ idataout :31..26] >> control1 ; 31{5} Memory [ idataout :20..11] control1 [ Link ]*2 control1 [ RegDst ]*2 >> {17} not1 {1} >> {16} Xor1 {2} {1} >> FastMux1 {3 5}; // Muxen, der æ v l g e r RegWriteData add1 [ sum ] >> [in :63..32] mux1 {1 32}; control1 [ Link ] >> [ select ] mux1 ; // æopst r e g i s t r e // Antal s k r i v p o r t e : 1 // Antal æ l s p o r t e : 2 // Antal a d r e s s e r i n g s b i t s : 5 // Antal d a t a b i t s : 32 Registers { RegFile }; control1 [ RegWrite ] >> [ wrenable ] Registers ; FastMux1 [ out ] >> [ wrselect ] Registers ; mux1 [ out ] >> [ wrdata ] Registers ; Memory [ idataout :20..16] Memory [ idataout :25..21] >> [ rdselect ] Registers ; // æopst k o n t r o l l e r e n t i l ALU en ( ALUcontrol. k ) control1 [ ALUOp ] Memory [ idataout :5..0] >> alucontrol1 ; //Muxen, der æ v l g e r B i n p u t t e t t i l ALU en ( control1 [ SignExt ] Memory [ idataout :15] Memory [ idataout :15..0] >> and3 {2}*16 {16}) Registers [ rddata :63..32] control1 [ ALUSrc ] >> mux2 {1 32}; 9

11 // ALU en ( alu. k ) Registers [ rddata :31..0] mux2 [ out ] alucontrol1 [ Binvert, Opcode ] >> alu ; // Add eren, der b e r e g n e r branch a d r e s s e r add1 [ sum ] ( control1 [ SignExt ] Memory [ idataout :15] Memory [ idataout :15..0] >> and4 {2}*14 {16}) 0{3} >> add2 {32}; add2 [ cout ] >> _ {1}; // Muxen, der æ v l g e r a d r e s s e n åp æ n s t e i n s t r u k t i o n // b i t 3 : Jump // b i t 2 : Jump r e g i s t e r // b i t 1 : Branch (åbde eq og neq ) // b i t 0 : PC+4 add1 [ sum :31..28] Memory [ idataout :25..0] 0{2} Registers [ rddata :31..0] add2 [ sum ] add1 [ sum ] ( control1 [ Jump ] alucontrol1 [ JumpReg ] control1 [ Branch ] alu [ Zero ]*2 control1 [ BranchNE ] >> {4} not2 {1} >> {2} and5 {2} and6 {2} >> {2} or2 {2} >> {3}, or3 {3} >> {3} not3 ) >> FastMux2 {4 32} >> [ in] PC; // æopst data hukommelsen alu [ Res ] >> [ daddrin ] Memory ; control1 [ MemRead ] >> [ drd ] Memory ; control1 [ MemWrite ] >> [ dwr ] Memory ; Registers [ rddata :63..32] >> [ ddatain ] Memory ; end //Muxen, der æ v l g e r mellem æ l s t e l l e r b e r e g n e t data Memory [ ddataout ] alu [ Res ] control1 [ MemtoReg ] >> mux3 {1 32} >> [in :31..0] mux1 ; 10

12 C Diagram over enkelt/dobbelt-cyklusarkitektur 11

13 D Kildekode til enkelt/dobbelt-cyklus arkitektur D.1 alucontrol.k ALUcontrol ( State {1} ALUOp {3} Func {6}) >> ( Opcode {3} AluMuxA {1} AluMuxB {2}) // S t a t e [ 2 ] // ALUOp[ 2 ] // ALUOp[ 1 ] // ALUOp[ 0 ] // Func [ 5 ] ( i n s t r u k t i o n [5 0] = Func ) // Func [ 4 ] // Func [ 3 ] // Func [ 2 ] // Func [ 1 ] // Func [ 0 ] // // controlplane = " , " //Add " , " //Add " , " //And " , " //Or " , " // S l t " , " //R " , " //R " , " //R " , " //R " , " //R " "; //Sub // // // AluMuxB [ 0 ] // AluMuxB [ 1 ] // AluMuxA // ALUC[ 0 ] // ALUC[ 1 ] // ALUC[ 2 ] end State ALUOp Func >> PLA { controlplane } >> Opcode AluMuxA AluMuxB ; D.2 double-cycle.k / Implementation o f a double c y c l e MIPS s u b s e t p r o c e s s o r ( 2 003) C h r i s t i a n I v e r s e n Rune øhjsgaard Espen øhjsgaard / main () // D e c l a r a t i o n s State { FlipFlop 1 0}; Controller {}; PC{ WrEnFlipFlop 32 0}; PCAdder { Adder 32}; PCControl {}; PCMux { FastMux 4 32} ALUControl {}; 12

14 ALUMuxA { Mux 1 32}; ALUMuxB { Mux 2 32}; ALUBufferD { WrEnFlipFlop 32 0}; ALUBufferA { WrEnFlipFlop 32 0}; ALU {}; RegBank { RegFile }; RegMuxA { Mux 2 5}; RegMuxB { Mux 2 32}; Memory { IdealMemIOSys 5}; CBuffer { FlipFlop 2 0}; // S t a t e State >> [ State ] ALUControl, [ State ] PCControl, [ State ] Controller ; // C o n t r o l l e r Memory [ idataout :5..0] >> [ Func ] Controller ; Memory [ idataout :31..26] >> [ Opcode ] Controller ; Controller [ RegWrite ] >> [ RegWrite ] PCControl ; Controller [ MemWrite ] >> [ MemWrite ] PCControl ; Controller [ BranchEQ ] >> [ BranchEQ ] PCControl ; Controller [ BranchNE ] >> [ BranchNE ] PCControl ; Controller [ Jump ] >> [ Jump ] PCControl ; Controller [ JumpReg ] >> [ JumpReg ] PCControl ; Controller [ MemWrite ] Controller [ MemRead ] >> CBuffer ; CBuffer >> [ dwr ] Memory [ drd ] Memory ; Controller [ RegWrite ] >> [ wrenable ] RegBank ; Controller [ ALUOp ] >> [ ALUOp ] ALUControl ; Controller [ Link ] Controller [ RegDst ] >> [ select ] RegMuxA ; Controller [ Link ] Controller [ MemToReg ] >> [ select ] RegMuxB ; 1{1} >> [ ird ] Memory ; // PC PCControl [ WritePC ] >> [ wrenable ] PC; PCControl [ PCMux ] >> [ select ] PCMux ; PCControl [ StateOut ] >> [ in] State ; PCMux [ out ] >> [in]pc; PC[out ] >> [ ina ] PCAdder, [ iaddrin ] Memory ; 4{32} >> [ inb ] PCAdder ; 0{1} >> [ cin ] PCAdder ; PCAdder [ cout ] >> _ {1}; PCAdder [ sum :31..28] Memory [ idataout :25..0] 0{2} RegBank [ rddata :31..0] ALU [ Res ] PCAdder [ sum ] >> [in] PCMux ; // R e g i s t e r Memory [ idataout :20..16] Memory [ idataout :25..21] >> [ rdselect ] RegBank ; RegMuxA [ out ] >> [ wrselect ] RegBank ; RegMuxB [ out ] >> [ wrdata ] RegBank ; 31{5} 31{5} Memory [ idataout :15..11] Memory [ idataout :20..16] >> [ in] RegMuxA ; PCAdder [ sum ]*2 Memory [ ddataout ] ALU [ Res ] >> [in] RegMuxB ; 13

15 // ALU ALUMuxA [ out ] >> [ ina ] ALU ; ALUMuxB [ out ] >> [ inb ] ALU ; ALU [ Res ] >> [in] ALUBufferA ; ALU [ Zero ] >> [ Zero ] PCControl ; ALUBufferA [ out ] >> [ daddrin ] Memory ; ALUBufferD [ out ] >> [ ddatain ] Memory ; RegBank [ rddata :63..32] >> [ in] ALUBufferD ; State >> notstate1 >> [ wrenable ] ALUBufferA ; PCControl [ StateOut ] >> [ wrenable ] ALUBufferD ; // Func Memory [ idataout :5..0] >> [ Func ] ALUControl ; ALUControl [ Opcode ] >> [ opcode ] ALU ; ALUControl [ AluMuxA ] >> [ select ] ALUMuxA ; ALUControl [ AluMuxB ] >> [ select ] ALUMuxB ; Controller [ SignExt ] Memory [ idataout :15] Memory [ idataout :15..0] >> SignAnd { And 2}*16 {16} >> [ val ] SignExtender { NullBoundary }; PCAdder [ sum ] RegBank [ rddata :31..0] >> [ in] ALUMuxA ; RegBank [ rddata :63..32]*2 SignExtender [ val ] SignExtender [ val :29..0] 0{2} >> [in] ALUMuxB ; // Stop the s i m u l a t i o n at FC Memory [ idataout ] >> and1 {6} or1 {26} >> {1} not0 >> and2 {2} >> [ stop ] SimSysCtrl ; end D.3 maincontrol.k control ( State {1} Func {6} Opcode {6}) >> ( MemRead {1} MemWrite {1} BranchEQ {1} BranchNE {1} Jump {1} JumpReg {1} Link {1} MemToReg {1} RegDst {1} RegWrite {1} SignExt {1} ALUOp {3} ) Func >> {2} not1 {3} >> or1 {6} >> not2 >> [ value ] Func8 { NullBoundary }; // S t a t e // Func8 // Op [ 5 ] // Op [ 4 ] // Op [ 3 ] // Op [ 2 ] // Op [ 1 ] 14

16 // Op [ 0 ] // // controlplane = " , " // R format " , " // JR " , " // lw " , " // lw " , " // sw " , " // sw " , " // beq " , " // beq " , " // bne " , " // bne " , " // addi " , " // s l t i " , " // andi " , " // o r i " , " // j " "; // j a l // DCBA // // ALUOp0 // ALUOp1 // ALUOp2 // SignExt // RegWrite // RegDst // MemtoReg // Link // JumpReg // Jump // BranchNE // BranchEQ // MemWrite // MemRead State Func8 [ value ] Opcode >> PLA { controlplane } >> MemRead MemWrite BranchEQ BranchNE Jump JumpReg Link MemToReg RegDst RegWrite SignExt ALUOp ; end D.4 pccontrol.k PCcontrol ( State {1} Jump {1} JumpReg {1} BranchEQ {1} BranchNE {1} RegWrite {1} MemWrite {1} Zero {1} ) >> 15

17 ( PCMux {4} WritePC {1} StateOut {1}) // S t a t e // Jump // JumpReg // BranchEQ // BranchNE // RegWrite // MemWrite // Zero // // controlplane = " , " // J a l " , " // Jr " , " //Beq " , " //Beq " , " //Beq " , " //Bne " , " //Bne " , " //Bne " , " //LW/SW 1. c y k l u s " , " //LW 2. c y k l u s + R og I type " "; //SW 2. c y k l u s // // // StateOut // WritePC // PCMux [ 0 ] // PCMux [ 1 ] // PCMux[ 2 ] // PCMux [ 3 ] end E State Jump JumpReg BranchEQ BranchNE RegWrite MemWrite Zero >> PLA { controlplane } >> PCMux WritePC StateOut ; Udskrift af kørsler Følgende er outputtet fra kørslerne af de fem testprogrammer på de to arkitekturer. E.1 fib E.1.1 Enkelt-cyklus This is SimSys , November 24 th 2002, ( C) Finn Schiermer Andersen SimSys is open source. Share and enjoy. Please visit http ://www. opensource. org to learn more about the open source concept. SimSys : Estimating resource usage : MHz Preparations complete. Now starting functional simulation. Functional simulation completed. Shutting down SimSys : Elapsed time ( simulated ): micro - seconds. 16

18 E.1.2 Enkelt/dobbelt-cyklus This is SimSys , November 24 th 2002, ( C) Finn Schiermer Andersen SimSys is open source. Share and enjoy. Please visit http ://www. opensource. org to learn more about the open source concept. SimSys : Estimating resource usage : MHz Preparations complete. Now starting functional simulation. Functional simulation completed. Shutting down SimSys : Elapsed time ( simulated ): micro - seconds. E.2 logtst E.2.1 Enkelt-cyklus This is SimSys , November 24 th 2002, ( C) Finn Schiermer Andersen SimSys is open source. Share and enjoy. Please visit http ://www. opensource. org to learn more about the open source concept. SimSys : Estimating resource usage : MHz Preparations complete. Now starting functional simulation. 1 Functional simulation completed. Shutting down SimSys : Elapsed time ( simulated ): micro - seconds. E.2.2 Enkelt/dobbelt-cyklus This is SimSys , November 24 th 2002, ( C) Finn Schiermer Andersen SimSys is open source. Share and enjoy. Please visit http ://www. opensource. org to learn more about the open source concept. SimSys : Estimating resource usage : MHz Preparations complete. Now starting functional simulation. 1 Functional simulation completed. Shutting down SimSys : Elapsed time ( simulated ): micro - seconds. E.3 scatter E.3.1 Enkelt-cyklus This is SimSys , November 24 th 2002, ( C) Finn Schiermer Andersen SimSys is open source. Share and enjoy. 17

19 Please visit http ://www. opensource. org to learn more about the open source concept. SimSys : Estimating resource usage : MHz Preparations complete. Now starting functional simulation. Functional simulation completed. Shutting down SimSys : Elapsed time ( simulated ): micro - seconds. E.3.2 Enkelt/dobbelt-cyklus This is SimSys , November 24 th 2002, ( C) Finn Schiermer Andersen SimSys is open source. Share and enjoy. Please visit http ://www. opensource. org to learn more about the open source concept. SimSys : Estimating resource usage : MHz Preparations complete. Now starting functional simulation. Functional simulation completed. Shutting down SimSys : Elapsed time ( simulated ): micro - seconds. E.4 slttest E.4.1 Enkelt-cyklus This is SimSys , November 24 th 2002, ( C) Finn Schiermer Andersen SimSys is open source. Share and enjoy. Please visit http ://www. opensource. org to learn more about the open source concept. SimSys : Estimating resource usage : MHz Preparations complete. Now starting functional simulation. 1 Functional simulation completed. Shutting down SimSys : Elapsed time ( simulated ): micro - seconds. E.4.2 Enkelt/dobbelt-cyklus This is SimSys , November 24 th 2002, ( C) Finn Schiermer Andersen SimSys is open source. Share and enjoy. Please visit http ://www. opensource. org to learn more about the open source concept. SimSys : Estimating resource usage : MHz Preparations complete. Now starting functional simulation. 1 18

20 Functional simulation completed. Shutting down SimSys : Elapsed time ( simulated ): micro - seconds. E.5 sort Sort er kørt med den givne input-fil, sort.in. E.5.1 sort.in E.5.2 Enkelt-cyklus This is SimSys , November 24 th 2002, ( C) Finn Schiermer Andersen SimSys is open source. Share and enjoy. Please visit http ://www. opensource. org to learn more about the open source concept. SimSys : Estimating resource usage : MHz Preparations complete. Now starting functional simulation Functional simulation completed. Shutting down SimSys : Elapsed time ( simulated ): micro - seconds. E.5.3 Enkelt/dobbelt-cyklus This is SimSys , November 24 th 2002, ( C) Finn Schiermer Andersen SimSys is open source. Share and enjoy. Please visit http ://www. opensource. org to learn more about the open source concept. SimSys : Estimating resource usage : MHz Preparations complete. Now starting functional simulation Functional simulation completed. Shutting down SimSys : Elapsed time ( simulated ): micro - seconds. 19