Forum: Emulator

Forum huvudsida -> Programmering -> Emulator

Sidor: 1

Till botten

Belsebubben 21:33 - 21:a April 2007 | Post #1
Medlem
Inlägg: 76


Skicka PM 		Bara för att ha gjort det så har jag nästan designat en processor. Eftersom jag bara ska skriva en emulator och inte göra riktig hårdvara så har jag inte varit snål med nått (förutom saker som kan kräva mer än 10 rader C# att skriva.)

Men hur RISC kan man göra en processor och fortfarande vara turing-komplett (korrekt översättning?)

Har försökt minimera antalet instruktioner så min processor kan bara hantera 64-bit variabler/instruktioner etc.

Så bör man ta bort/borde lägga till några instruktioner?

Jump if zero
Jump if non-zero

Call - Skapar ett interrupt som mitt firmware/os-et läser
Return - Kommer tillbaks från ett interrupt

Load
Store

Push - Onödiga, kan ersättas i mjukvara, men är ganska schysta i en emulator
Pop

Add - Signed och Unsigned med 64-bit integers
Subtract
Multiply
Divide
Modulo

And - Bitwise
Or
Xor
Not

Nu får vi se om jag startar en trend, precis som programmeringsspråksfolket

-------------------------
Das Blinkencomp, jag väljer dig!


ozamosi 21:50 - 21:a April 2007 | Post #2
Administratör
Inlägg: 1129


Skicka PM 		Hur långt man kan gå? En instruktion räcker - vanligast verkar subtract and branch if negative vara. En dator med endast en instruktion finns här: http://bitstuff.blogspot.com/2007/02/subtract-and-branch-if-negative.html

Som du säkert ser har han skrivit ett eget assemblerspråk, som ser ut mer som vanlig assembly, eftersom det är ett helvete att tänka självmodifierande kod och liknande, dock finns det folk som är sjuka i huvudet nog att kunna det: http://mozaika.com.au/oleg/subleq/

Infon hittad en uttråkad dag på wikipedia

-------------------------
Ljusblå


Belsebubben 23:21 - 21:a April 2007 | Post #3
Medlem
Inlägg: 76


Skicka PM 		Nja, Jag försöker att inte komma till den nivån, man måste vara lite sadomasochist för att koda i assembly och SUBLEQ tar det till en helt ny nivå.

Jag hade faktiskt tänkt att skriva lite program till min dator så att ha 1 instruktion är inte acceptabelt, jag är inte nära så bra på att programmera.

Men är det någon som har några tips för hur man bäst skriver sin emulator. Har börjat lite och den kan köra lite kod.

Som den ser ut nu

while true
{
testa interrupts
hämta instruktion
dekoda instruktion
IP++
utför instruktion
}

-------------------------
Das Blinkencomp, jag väljer dig!

Senast redigerad 23:29 - 21:a April 2007


Slash 23:11 - 22:a April 2007 | Post #4
Medlem
Inlägg: 141


Skicka PM 		Tycker att det låter som ett roligt projekt. Du borde ju komma ganska långt med att ha en ALU (som kan göra beräkningar), en uppsättning register, ett minne, någon slags branchlogik och en programräknare.

Uppdatera gärna med info allteftersom du gör framsteg.

-------------------------
Ingen sigantur!


Belsebubben 21:05 - 23:e April 2007 | Post #5
Medlem
Inlägg: 76


Skicka PM 		Jo, jag ska bara tänka lite först.

,,r inte riktigt van med det i mina egna projekt. Ska försöka komma på nått smart sätt att lösa allt.

Ska försöka skriva en assembler också så att man kan göra något koolt program också

EDIT 1: Har nu skrivit en minnesmodul också, men det är inte en hel mmu än dock, för jag har ingen aning om hur man skulle skriva en. Aja, det löser sig när jag behöver den, hoppas jag.

EDIT 2: Klar med Registermodulen, den är najs. Nu blir det lite instruktioner innan läggdags

EDIT 3: Har lite mer tänk nu, alla instruktioner tror jag, kanske lägger till fler senare.

Arithmetic - Klar
    Add x, y, z    | x = y + z
    Add x, y, I | x = y + I
    Sub x, y, z | x = y - z
    Sub x, y, I | x = y - I
    Mul x, y, z | x = y*z
    Mul x, y, I | x = y*I
    Div x, y, z | x = y / z
    Div x, y, Z | x = y / I
    
Logical - Klar
    Not x, y        | x = !y
    And x, y, z | x = y & z
    And x, y, I | x = y & I
    Or    x, y, z | x = y | z
    Or    x, y, I | x = y | I
    Xor x, y, z | x = y ^ z
    Xor x, y, I | x = y ^ I
    Sll x, y, I | x = y << I
    Slr x, y, I | x = Y >> I
    
Data - Klar förutom coprocessor instruktionerna (Ska användas till FPU/MMU)
    lw    x, y, I | x = Memory[y + I]
    sw    x, y, I | Memory[y + I] = x
    mov x, y        | x = y
    mtc x, y, I    | move x to coprocessor I register y
    mfc x, y, I | move from coprocessor I register y to x
    mcd x, y     | make coprocessor y do x
    push x            | push x onto cpu stack
    pop x                | pop into x
    
Branch - Klar förutom call
    jnz    x, y, I | if (x != 0) PC += y + 100
    jnz    x, y        | if (x != 0) PC = y
    jiz    x, y, I | if (x == 0) PC += y + 100
    jiz x, y        | if (x == 0) PC = y
    
    
    Call - Jump into Software, Ring = 2
    OS Call - Interrupt for OS, Ring = 1
    Firmware Call - Jumps to firmware, Ring = 0
    
Set - Klar
    slt x, y, z | if (y < z) x = 1 else x = 0
    slt x, y, I | if (y < I) x = 1 else x = 0
    sgt x, y, z | if (y > z) x = 1 else x = 0
    sgt x, y, I | if (y > I) x = 1 else x = 0

EDIT 4: Problems in code land, ulong funkar inte som array indexer

-------------------------
Das Blinkencomp, jag väljer dig!

Senast redigerad 20:23 - 24:e April 2007


sdac 23:38 - 23:e April 2007 | Post #6
Medlem
Inlägg: 235


Skicka PM 		    Citat av Belsebubben:

    Not x, y        | x = !y


,,r det inte logisk negation du är ute efter? Isåfall ska du använda operatorn '~' i de flesta språk.

,,r du inte ute efter negation tycker jag det verkar onödigt, eftersom boolesk negation inte är användbart i andra sammanhang än branching. I det här fallet har du ändå jump if zero och jump if not zero att använda.

I övrigt, har du funderat över om flaggor skulle finnas användbart? Tänker på bl.a. sammanhang där en multiplikation eller annat passerat 2^64 och kodaren inte har en aning om det. Just den flaggan är användbar om man vill emulera 128-bitars tal också.


Belsebubben 17:59 - 24:e April 2007 | Post #7
Medlem
Inlägg: 76


Skicka PM 		Jo, det är logisk negation jag är ute efter.

I mitt pseudospråk så används ! för båda typerna. I C# får jag dock snällt använda ~.

,,r inte helt säker hur man hanterar overflows, skickar man ett interrupt eller sätter man bara en flagga?

Har faktiskt ingen aning.

-------------------------
Das Blinkencomp, jag väljer dig!


sdac 18:28 - 24:e April 2007 | Post #8
Medlem
Inlägg: 235


Skicka PM 		    Citat av Belsebubben:
Jo, det är logisk negation jag är ute efter.

I mitt pseudospråk så används ! för båda typerna. I C# får jag dock snällt använda ~.

,,r inte helt säker hur man hanterar overflows, skickar man ett interrupt eller sätter man bara en flagga?

Har faktiskt ingen aning.


Nä det har inget med interrupts att göra, utan den sätter helt enkelt en bit om processorn tycker att det blev en overflow. Eftersom du skriver emulatorn i en vanlig PC så kan du ju helt enkelt lägga en wrapper runt den riktiga flaggan. Fast i och med att du skriver det i C# finns det säkert något roligt inbyggt som tar hand om det där så du slipper bry dig.


Belsebubben 19:39 - 24:e April 2007 | Post #9
Medlem
Inlägg: 76


Skicka PM 		Ok, men kollar man i asm efter flaggan varje gång man tror det kan ha varit overflow?

EDIT: MIPS skickar ett interrupt om det är overflow, verkar ganska smart

-------------------------
Das Blinkencomp, jag väljer dig!


ozamosi 19:42 - 24:e April 2007 | Post #10
Administratör
Inlägg: 1129


Skicka PM 		MIPS är RISC. RISC har inte flaggor.

-------------------------
Ljusblå


sdac 19:44 - 24:e April 2007 | Post #11
Medlem
Inlägg: 235


Skicka PM 		    Citat av Belsebubben:
Ok, men kollar man i asm efter flaggan varje gång man tror det kan ha varit overflow?

EDIT: MIPS skickar ett interrupt om det är overflow, verkar ganska smart


Beror väl på många faktorer, om programmet struntar i overflows trögar man ju ned med flera tusendelars nanosekunder om man skickar interrupts ändå som bara orsakar en returnering.


Slash 19:52 - 24:e April 2007 | Post #12
Medlem
Inlägg: 141


Skicka PM 		    Citat av sdac:
    Citat av Belsebubben:
Ok, men kollar man i asm efter flaggan varje gång man tror det kan ha varit overflow?

EDIT: MIPS skickar ett interrupt om det är overflow, verkar ganska smart


Beror väl på många faktorer, om programmet struntar i overflows trögar man ju ned med flera tusendelars nanosekunder om man skickar interrupts ändå som bara orsakar en returnering.


Det är ju smart eftersom man kan välja om man vill trap:a overflows i MIPS genom att välja mellan add (overflow) och addu (ej overflow)Smiley


-------------------------
Ingen sigantur!


Belsebubben 19:52 - 24:e April 2007 | Post #13
Medlem
Inlägg: 76


Skicka PM 		Sant, men flaggor är inte snyggt.

Men så länge så tror jag att jag ska undvika att köra kod som skapar overflow innan jag har kommit på hur jag ska göra.

EDIT: Har implementerat alla instruktioner nu, bara att börja koda loopen nu.
Synd att jag har behövt minska address storleken till 32-bit signed från 64-bit unsigned. Aja, 16 GB är ok för mina behov ändå

-------------------------
Das Blinkencomp, jag väljer dig!

Senast redigerad 20:25 - 24:e April 2007


Slash 23:07 - 24:e April 2007 | Post #14
Medlem
Inlägg: 141


Skicka PM 		    Citat av Belsebubben:
Sant, men flaggor är inte snyggt.

Men så länge så tror jag att jag ska undvika att köra kod som skapar overflow innan jag har kommit på hur jag ska göra.

EDIT: Har implementerat alla instruktioner nu, bara att börja koda loopen nu.
Synd att jag har behövt minska address storleken till 32-bit signed från 64-bit unsigned. Aja, 16 GB är ok för mina behov ändå


32-bit borde väl rimligtvis ge 4096 megabytes minnesrymd? Eller om du bara kan använda den positiva delen, strax under 2048 mb.

-------------------------
Ingen sigantur!


Belsebubben 07:57 - 25:e April 2007 | Post #15
Medlem
Inlägg: 76


Skicka PM 		nja, det är om varje address pekar på en byte som det brukar vara, men nu så pekar varje address på en unsigned long.

2048 MB*8 är hur jag beräknade fram 16 GB, ska försöka komma på hur jag kan få till 64-bittars addressering. Men eftersom det inte fyller någon funktion för mig (Har ingen dator som har mer än 4 GB minne) så ligger det ganska långt bak i den mentala pipelinen.

Har bara dekodningen av instruktionerna kvar, sedan blir det beta^H^H^H^Halpha-dags

-------------------------
Das Blinkencomp, jag väljer dig!

Senast redigerad 08:01 - 25:e April 2007


sdac 15:00 - 26:e April 2007 | Post #16
Medlem
Inlägg: 235


Skicka PM 		    Citat av Belsebubben:
nja, det är om varje address pekar på en byte som det brukar vara, men nu så pekar varje address på en unsigned long.

2048 MB*8 är hur jag beräknade fram 16 GB, ska försöka komma på hur jag kan få till 64-bittars addressering. Men eftersom det inte fyller någon funktion för mig (Har ingen dator som har mer än 4 GB minne) så ligger det ganska långt bak i den mentala pipelinen.

Har bara dekodningen av instruktionerna kvar, sedan blir det beta^H^H^H^Halpha-dags


Men hur ska du hantera textsträngar isåfall, då måste ju varje tecken dra en unsigned long eftersom du inte kan addressera bytes. Alternativt går det ju att lagra flera tecken under varje adress och sedan behöva bitshifta och padda med null för att kunna extrahera varje tecken.

Eller du kanske inte ska ha stöd för strängar?


ozamosi 18:27 - 26:e April 2007 | Post #17
Administratör
Inlägg: 1129


Skicka PM 		Eller bygga systemet med UTF-16 som intern representation.

-------------------------
Ljusblå


Slash 18:52 - 26:e April 2007 | Post #18
Medlem
Inlägg: 141


Skicka PM 		    Citat av ozamosi:
Eller bygga systemet med UTF-16 som intern representation.


Du får nog utveckla det lite. Varför skulle det påverka det faktum att det inte går att adressera enskilda bytes?

-------------------------
Ingen sigantur!


ozamosi 18:59 - 26:e April 2007 | Post #19
Administratör
Inlägg: 1129


Skicka PM 		Vad ska du med bytes till när varje tecken är två bytes?

-------------------------
Ljusblå


Slash 19:08 - 26:e April 2007 | Post #20
Medlem
Inlägg: 141


Skicka PM 		Det går ju inte att adressera varannan byte heller.

EDIT
Att diskutera en instruktionsarkitektur utifrån ett strängperspektiv är ju fel redan där.

-------------------------
Ingen sigantur!

Senast redigerad 19:13 - 26:e April 2007


Belsebubben 19:46 - 3:e Maj 2007 | Post #21
Medlem
Inlägg: 76


Skicka PM 		Nja, det har funnits många datorer som inte kan addressera varje 'tecken' för sig, och jag tror inte det behövs. Man kan ju alltid bit-maska (nån annan än jag som skulle använda det ordet, eller finns det nått bättre?) fram tecknen.

Dock så har jag tänkt mer på vad jag ska fylla ut mina ulong instruktioner med. Men hur jag än vrider och vänder verkar det bli ca 40 bit kvar. Så det blir nog att snällt smyga ner till uint eller komma på vad jag ska ha alla onödiga bittar till.

Jag har också analyserat möjligheterna i en stack-processor, Java och .Net använder det. ,,r det på något sätt lättare att skriva en bra kompilator till det eller är det bara slump?

-------------------------
Das Blinkencomp, jag väljer dig!


Sidor: 1

Forum huvudsida -> Programmering -> Emulator
Atom feed

Du får inte posta i den här tråden | Till toppen