MIPS (prosessor)

Med navnet MIPS (akronym for Microprocessor without Interlocked Pipeline Stages ) er en hel familie av RISC-arkitekturmikroprosessorer utviklet av MIPS Technologies kjent .

MIPS-design brukes i SGIs linje med dataprodukter ; i mange innebygde systemer ; på Windows CE- enheter ; Cisco rutere ; og spillkonsoller som Nintendo 64 eller Sony PlayStation , PlayStation 2 og PlayStation Portable . Nylig brukte NASA en av dem på New Horizons -sonden [ 1 ]

De første MIPS-arkitekturene var 32-biters fsfs (vanligvis 32-bits brede register- og databaner), selv om senere versjoner ble implementert i 64-bit. Det er fem bakoverkompatible revisjoner av MIPS-instruksjonssettet , kalt MIPS I , MIPS II , MIPS III , MIPS IV og MIPS 32/64 . I den siste av dem, MIPS 32/64 Release 2, er et registerkontrollsett videre definert. Flere "utvidelser" er også tilgjengelige, for eksempel MIPS-3D , som består av et enkelt sett med flytende punkt SIMD -instruksjoner dedikert til vanlige 3D-oppgaver, MDMX(MaDMaX) bestående av et mer omfattende sett med heltalls SIMD MIPS16 som legger til komprimering til instruksjonsstrømmen for å få programmer til å ta opp mindre plass (antagelig som svar på Thumb -komprimeringsteknologien til ARM - arkitekturen ) eller den nylige MIPS MT som legger til funksjonalitet som multithreading som ligner på HyperThreading -teknologien til Intel Pentium 4-prosessorer .

Fordi designerne laget et så tydelig sett med instruksjoner, er dataarkitekturkurs ved universiteter og tekniske skoler ofte basert på MIPS-arkitekturen. Utformingen av MIPS-familien av CPUer vil i stor grad påvirke andre senere RISC -arkitekturer som DEC Alpha .

Historikk

I 1981 begynte et team ledet av John L. Hennessy ved Stanford University arbeidet med det som skulle bli den første MIPS-prosessoren. Grunnideen var å drastisk forbedre ytelsen gjennom bruk av segmentering , en teknikk som da var velkjent, men også vanskelig å implementere. Dens operasjon kan oppsummeres ved at utførelsen av en instruksjon er delt inn i flere stadier, og starter "trinn 1" av en instruksjon før utførelsen av den forrige instruksjonen er fullført. Derimot ventet tradisjonelle design på at en instruksjon skulle fullføres helt før de gikk videre til neste, slik at store deler av CPU-en ble uvirksomme mens behandlingen fortsatte. I tillegg ble klokkehastigheten til hele CPUen diktert av full sykluslatens, snarere enn den såkalte kritiske banelatensen til pipeline-stadiet som tar lengst å fullføre.

En annen stor barriere å overvinne med pipeline var behovet for å innføre låser for å sikre at instruksjoner som tar flere klokkesykluser for å fullføre stopper lasting av data fra rørledningsregistrene. Disse låsingene kan vare i betydelige mengder tid, og var en stor barriere for ytterligere speedups. Derfor var et av hovedaspektene ved MIPS-designet å sette som et mål at alle underfaser (inkludert minnetilgang) av alle instruksjoner tar en enkelt syklus å fullføre, og dermed gjøre låser unødvendige og tillate en enkelt syklusytelse.

Selv om denne designideen eliminerte mange nyttige instruksjoner, og fremhevet det faktum at multiplikasjon og divisjon ville kreve flere instruksjoner, var det totalt sett kjent at den generelle ytelsen til systemet ville bli drastisk forbedret ved å kunne kjøre brikkene ved mye høyere frekvenser. Denne hastighetsøkningen ville være vanskelig med inngrep fra låser, siden tiden som kreves er en funksjon av størrelsen på brikken og klokkefrekvensen: å legge til nødvendig maskinvare for å unngå dem vil redusere hastigheten til systemet betydelig.

Fjerningen av disse instruksjonene ble et kontroversielt spørsmål. Mange observatører hevdet at denne designen (og RISC-prosessorer generelt) aldri ville leve opp til sine høye forventninger ("Hvis man bare erstatter den komplekse multiplikasjonsinstruksjonen med en enkel serie addisjoner, hvor skjer hastighetsøkningen?"). Denne forenklede analysen ignorerte det faktum at designhastigheten lå i rørledningen, ikke i instruksjonene.

I 1984 ble Hennessy overbevist om designets fremtidige kommersielle potensial, og etterlot Stanford for å danne MIPS Computer Systems . Selskapet introduserte sin første design, R2000 , i 1985, og ble forbedret med R3000 i 1988. Disse 32-bits CPU-ene var selskapets grunnlag gjennom 1980-tallet, og ble først og fremst brukt i noen serier med SGI - arbeidsstasjoner . Disse kommersielle designene skilte seg fra Stanfords akademiske forskningsdesign på slike måter som å implementere de fleste låser med maskinvare og gi fullstendige instruksjoner for multiplikasjon og divisjon, blant andre.

I 1991 introduserte MIPS sin første 64-bits prosessor, R4000 . MIPS fikk imidlertid økonomiske vanskeligheter ved sin markedslansering. Designet var så viktig for SGI, den gang en av MIPS sine få store kunder, at man i 1992 ukritisk kjøpte selskapet for å hindre at designet skulle gå tapt. Som et datterselskap av SGI ble selskapet omdøpt til MIPS Technologies .

På begynnelsen av 1990-tallet begynte MIPS å lisensiere designene deres til tredjeparter. Dette beviste med rimelig suksess enkelheten til kjernen, noe som gjorde at den ble brukt i en rekke applikasjoner som tidligere brukte CISC- design som var mye mindre kapable og av lignende pris og antall porter (kommentar at begge størrelsene er nært beslektet; prisen til en CPU er vanligvis relatert til antall porter og eksterne pinner). Sun Microsystems prøvde å hoppe på vognen ved å lisensiere SPARC -kjernen sin , men det var ikke i nærheten av suksessen til MIPS. På slutten av 1990-tallet hadde MIPS en arbeidshest i innebygde prosessorer , og i 1997 ble MIPS 48 millioner prosessorer sendt, og ble den første RISC-prosessoren som løsnet Motorolas berømte 68k -familie . MIPS-familien var så vellykket at SGI relanserte MIPS Technologies i 1998. Mer enn halvparten av MIPS-inntektene kommer nå fra lisensiering, mens mye av resten kommer fra kjernedesignkontrakter som skal produseres av tredjeparter.

I 1999 konsoliderte MIPS lisensieringssystemet sitt rundt to grunnleggende design, MIPS32 32-bit og MIPS64 64-bit. NEC , Toshiba og SiByte (senere kjøpt opp av Broadcom ) lisensierte MIPS64 så snart denne prosessoren ble annonsert; disse selskapene ble fulgt av andre som Philips , LSI Logic og IDT . Suksessene fulgte på hverandre, og for tiden er MIPS-kjerner en av tungvekterne på markedet for enheter som håndholdte datamaskiner eller dekodere og TV-tunere. En indikasjon på suksessen er det faktum at Freescale (et datterselskap av Motorola ) bruker MIPS-prosessorer i enhetene sine, i stedet for sine egne PowerPC -baserte .

Siden MIPS-arkitekturen er lisensiert, har den tiltrukket seg mange unge selskaper gjennom årene. Et av de første nye selskapene som designet MIPS-prosessorer var Quantum Effect Devices . MIPS-designteamet bak R4300 grunnla SandCraft , som designet R5432 for NEC og senere SR7100 , en av de første ut-av-ordne baserte prosessorene for innebygde systemer. Det originale DEC StrongARM -designteamet delte seg til slutt i to MIPS-selskaper: SiByte, produsent av SB-1250 , et av de første MIPS-baserte høyytelses single-chip systemene; og Alchemy Semiconductor (senere kjøpt av AMD ), som laget Au-1000 enkeltbrikkesystemet for applikasjoner med lav etterspørsel. Lexra brukte pseudo-MIPS-arkitektur og la til DSP-utvidelser for lydbrikkemarkedet og multithreading -støtte for nettverksmarkedet. Fordi Lexra ikke var konsesjonær av noen MIPS-lisens, ble det åpnet to søksmål mellom de to selskapene. Den første ble raskt løst ved at Lexra lovet å ikke fortsette å annonsere sine prosessorer som MIPS-kompatible. Den andre var lang og skadet interessene til begge selskapene, og endte med at MIPS ga en gratis lisens til Lexra, samt betalte en stor sum penger.

CPU-familie

MIPS sin første kommersielle CPU-modell, R2000 , ble annonsert i 1985 . Den la til flersyklusinstruksjoner for multiplikasjon og divisjon i en egen enhet innebygd i prosessoren. Instruksjoner ble også lagt til for å sende resultatene av denne enheten til kjernen; som trengte låser.

R2000 kan startes opp i både big-endian- og little-endian- formater . Den hadde 32 32-bits registre for generell bruk, men ingen statusregister, noe som var en betydelig flaskehals. Dette problemet ble delt med AMD 29000 og DEC Alpha . I motsetning til andre registre er ikke programtelleren direkte tilgjengelig.

R2000 støttet også opptil fire co-prosessorer, hvorav en var integrert i hoved-CPU for håndtering av unntak og avbrudd, mens de tre andre var for annen bruk. Et alternativ var å legge til R2010 flyttallsenhet , som hadde 32 32-bits registre som kunne brukes som sådan for å håndtere enkeltpresisjonstall eller som 16 64-bits dobbelpresisjonsregistre.

R3000 skulle etterfølge R2000 i 1988 , og legge til en 32 kB cache (snart økt til 64 kB) for instruksjoner og data, sammen med "cache coherence"-støtte for multiprosessorbruk. Så lenge det var feil i R3000s multiprosessorstøtte, fortsatte MIPS å gjøre den til en del av flere vellykkede multiprosessordesigner. R3000 inneholdt også en integrert minnestyringsenhet (MMU) , en vanlig funksjon blant prosessorer på den tiden. R3000 var den første vellykkede MIPS-designen på markedet, og over 1 million enheter ble til slutt produsert. R3000A, brukt i den ekstremt suksessrike Sony PlayStation , var en versjon klokket opp til 40 MHz. I likhet med R2000 ble R3000 sammenkoblet med R3010 FPU . Pacemips gjorde R3400 og IDT til R3500 , begge modellene var R3000s-prosessorer med R3010 FPU på en enkelt brikke. Toshiba R3900 var det første enkeltbrikkesystemet for tidlige Windows CE -håndholdte datamaskiner .

I R4000 -serien , introdusert i 1991, ble MIPS-instruksjonssettet utvidet til å danne en ekte 64-bits arkitektur, og FPU-en ble flyttet til samme krets for å lage et enkeltbrikkesystem, som opererer med en radikalt høyere klokkehastighet (opprinnelig 100 MHz). For å nå en slik frekvens ble imidlertid cachene redusert til 8 kB hver, noe som krevde tre klokkesykluser for å få tilgang til dem. De høye arbeidsfrekvensene ble oppnådd takket være den dype segmenteringsteknikken (den gang kalt supersegmentering). R4000 ble fulgt av en rekke forbedrede versjoner, inkludert 1993 R4400 med 16 kB cacher, 64-bits operasjoner nesten uten feil, og en driver for ytterligere 1 MB ekstern ( L2 ) cache.

MIPS, nå en avdeling av SGI kalt MTI, designet lavprisversjonen R4200 , og senere den enda billigere R4300 , som er en R4200 med en 32-bits ekstern buss. Nintendo 64 bruker en NEC VR4300 CPU basert på den rimelige MIPS R4300i . [ 2 ]

Quantum Effect Devices (QED), et eget selskap grunnlagt av tidligere MIPS-ingeniører, designet R4600 "Orion", R4700 "Orion", R4650 og R5000 . Mens R4000 økte frekvensen i bytte mot redusert hurtigbufferkapasitet, inneholdt QEDs design store cacher tilgjengelig på bare to klokkesykluser og effektiv bruk av silisiumområde. R4600 og R4700 ble brukt i lavkostversjonene av SGI Indy-arbeidsstasjoner så vel som i de første MIPS-baserte Cisco-ruterne, de i 36x0- og 7x00-serien. R4650 ble brukt i de originale WebTV -settene (nå Microsoft TV). R5000 FPU fungerte mer effektivt og fleksibelt med enkeltpresisjonstall enn R4000, og som et resultat, med lignende grafikkmaskinvare, tilbød SGI Indys som kjørte R5000 FPU mye bedre grafikkytelse enn de som kjører R4400. SGI ga nytt navn til de gamle grafikkortene som inneholdt R5000 for å markere forbedringen. QED designet deretter RM7000- og RM9000- familiene for innebygde systemer som nettverk og laserskrivere. QED ble kjøpt opp av halvlederprodusenten PMC-Sierra i august 2000 , noe som gjør det til det siste selskapet som har investert i MIPS-arkitekturen.

R8000 ( 1994 ) var den første superskalære MIPS-designen , som var i stand til å utføre to ALU og to andre minneoperasjoner i hver klokkesyklus. Designet ble nedfelt i seks brikker: en heltallsenhet (med to 16 KB cacher, en for instruksjoner og en L1 for data), en flytende punktenhet, tre fullt tilpassbare sekundære cache-RAM-er (to for sekundære cache-tilganger og to for én for buss), og en ASIC cache-kontroller. Designet hadde to segmenterte dobbelpresisjon add-multiplikeringsenheter, som begge mottok datastrømmen fra den 4 MB eksterne sekundære cachen. R8000 ble bygget på SGI Power Challenge-servere på midten av 1990-tallet og senere på Power Indigo2-arbeidsstasjoner. Den begrensede ytelsen i heltallsoperasjoner og dens høye kostnad gjorde den upopulær blant de fleste brukere, selv om den gode ytelsen til FPU-en ble utnyttet av vitenskapelige brukere; R8000 var knapt et år på markedet.

I 1995 ble R10000 utgitt . Denne prosessoren var en enkeltbrikkedesign, med høyere klokkehastighet enn R8000, og større 32 kB primære cacher for instruksjoner og data. Den var også superskalær, men dens store innovasjon var å være "ute av drift". Selv med en enklere FPU, gjorde den enorme forbedringen i heltallsoperasjoner, lavere pris og høyere tetthet R10000 til det foretrukne valget for mange kunder.

De nyeste designene er basert på R10000. R12000 har blitt produsert med forbedret teknologi for å komprimere brikken og operere med høyere klokkehastighet. Revisjon R14000 tillot høyere klokkefrekvenser, ekstra støtte for DDR SRAM på den eksterne cache -brikken og en 200 MHz FSB for bedre gjennomstrømning. De siste versjonene ble kalt R16000 og R16000A , med høyere klokkehastighet, ekstra L1-cache og mindre brikker sammenlignet med de forrige.

MIPS mikroprosessor spesifikasjoner
Modell Frekvens [MHz] År Prosess [µm] Transistorer [millioner] Chipstørrelse [mm²] I/O-pinner Strøm [W] Spenning Dcache [k] Icache[k] Scache [k]
R2000 8-16.7 1985 to 0,11 -- -- -- -- 32 64 ingen
R3000 12-40 1988 1.2 0,11 66,12 145 4 -- 64 64 ingen
R4000 100 1991 0,8 1,35 213 179 femten 5 8 8 1024
R4400 100-250 1992 0,6 23 186 179 femten 5 16 16 1024
R4600 100-133 1994 0,64 2.2 77 179 4.6 5 16 16 512
R5000 150-200 nitten nittiseks 0,35 3.7 84 223 10 3.3 32 32 1024
R8000 75-90 1994 0,5 2.6 299 591 30 3.3 16 16 1024
R10 000 150-250 nitten nitti fem 0,35 6.8 299 599 30 3.3 32 32 512
R12000 270-400 1998 0,18–0,25 6.9 204 600 tjue 4 32 32 1024
R14000 500-600 2001 0,13 7.2 204 527 17 -- 32 32 2048
R16000 700-800 2002 0,11 -- -- -- tjue -- 64 64 4096

Merk: Disse spesifikasjonene refererer til de vanligste konfigurasjonene. Variasjoner finnes, spesielt i nivå 2-cacher.

Applikasjoner

Bemerkelsesverdige produsenter av MIPS-prosessorbaserte arbeidsstasjoner inkluderer SGI , MIPS Computer Systems, Inc. , Olivetti , Siemens-Nixdorf, Acer , Digital Equipment Corporation , NEC og DeskStation . Ulike operativsystemer ble portert til arkitekturen, eksempler er SGI IRIX , Microsoft Windows NT (selv om støtte for MIPS endte med utgivelsen av Windows NT 4.0), og Windows CE , Linux , BSD , UNIX System V , SINIX , MIPS Computer Systems RISC/os , blant annet.

Bruken av MIPS som hovedprosessor for arbeidsstasjoner har imidlertid gått ned, og SGI har kunngjort planer om å slutte å utvikle høyytelses iterasjoner av MIPS-arkitekturen til fordel for prosessorer basert på Intel IA64 -teknologi (se avsnittet "Andre modeller og fremtidige planer" ).

På den annen side vil bruken av MIPS-mikroprosessorer i innebygde systemer sannsynligvis fortsette takket være det lave strømforbruket og termiske egenskapene til innebygde implementeringer, samt den brede tilgjengeligheten av utviklingsverktøy og kunnskapsrike arkitektureksperter.

Andre modeller og fremtidsplaner

Et annet medlem av MIPS-familien er R6000 , en ECL -implementering av MIPS-arkitekturen laget av Bipolar Integrated Technology . R6000 introduserte MIPS II instruksjonssettet . Dens TLB og cache-arkitektur er forskjellig fra andre medlemmer av MIPS-familien. R6000 ga ikke de forventede resultatene, og selv om den ble brukt i noen Control Data- maskiner , forsvant den raskt fra det vanlige markedet . PMC-Sierra RM7000 var en versjon av R5000 med en integrert 256 kB nivå 2 cache og en driver for en valgfri tredje nivå cache. Primært designet for innebygde systemer som SGI-grafikkprosessorer og ulike Cisco -nettverksløsninger . R9000 - navnet ble aldri brukt.

SGI prøvde en gang å migrere fra MIPS-plattformen til Intel Itanium , etter å ha fullført utviklingen med R10000. Lange forsinkelser i Itanium-utgivelsen gjorde at antallet installerte MIPS-baserte prosessorer fortsatte å vokse. I 1999 ble det klart at utviklingsprosessen var avsluttet for tidlig, og resultatet er R14000- og R16000-versjonene. SGI lekte med å legge til en mer kompleks R8000-stil FPU i senere iterasjoner, i tillegg til å lansere en dual-core prosessor, men selskapets økonomiske problemer og den offisielle og støttede bruken av QuickTransit -emulering for å kjøre IRIX-binærfiler på toppen av Altix forårsaket den permanente opphør av IRIX/MIPS maskinvareutvikling.

Longson

Loongson er en familie av mikroprosessorer designet av det kinesiske vitenskapsakademiet. Den interne mikroarkitekturen til Loongson mikroprosessorer ble uavhengig designet av kineserne. Tidlige implementeringer av familien manglet fire instruksjoner, proprietære til MIPS Technologies. I juni 2009 lisensierte IKT MIPS32 og MIPS64 direkte fra MIPS Technologies.

Fra og med 2006 begynte en rekke selskaper å sende en rekke maskinvare med Loongson-prosessoren, inkludert laveffekts nettops og netbooks . [ 3 ]​ [ 4 ]​ [ 5 ]

Kjerner

De siste årene har mye av teknologien brukt i de forskjellige MIPS-generasjonene blitt tilbudt som "IP-kjerne"-design (byggeklosser) for innebygde systemer . De grunnleggende 32-biters og 64-biters kjernene, kjent som henholdsvis 4K og 5K , og med MIPS32- og MIPS64- lisenser tilbys . Disse kjernene kan kombineres med tilleggsenheter som FPUer, SIMD-systemer, I/O-enheter, etc.

MIPS-kjerner har vært kommersielt vellykket, og brukes for tiden i mange forbruker- og industrielle applikasjoner. De kan finnes i de nyeste Cisco- , TP-Link- og Linksys - ruterne , kabel- og ADSL -modemer , smartkort , laserskriverkontrollere , TV-set-top-bokser, roboter , håndholdte datamaskiner, Sony PlayStation 2 og Sony PlayStation Portable .

I mobiltelefoner og PDA -er var imidlertid ikke MIPS-kjernen i stand til å løsne ARM -arkitekturkonkurrenten .

Programmering og emulering

Det er en helt gratis MIPS R2000/R3000 simulator kalt SPIM (MIPS bakover) kompatibel med flere operativsystemer (spesielt Unix eller GNU/Linux; Mac OS X; MS Windows 95, 98, NT, 2000, XP og DOS) designet for lære MIPS assembly programmering og generelle RISC assembly konsepter: http://www.cs.wisc.edu/~larus/spim.html

En annen populær simulator er MARS (MIPS Assembler and Runtime Simulator), en IDE (Integrated Design Environment) for programmering av MIPS i Assembly-språk. MARS er et lettvekts, interaktivt utviklingsmiljø, skrevet i Java og kompatibelt med mange plattformer, beregnet for bruk på utdanningsnivå.

En mer komplett MIPS-emulator tilhører GXemul- prosjektet (tidligere kjent som mips64emul Project), som ikke bare emulerer de forskjellige versjonene av MIPS III og høyere mikroprosessorer (fra R4000 til R10000), men også hele systemer som bruker disse prosessorene. For eksempel kan GXemul emulere både en DECstation med en MIPS R4400-prosessor (og starte opp i Ultrix ) og en SGI O2 med en MIPS R10000 CPU (selv om muligheten til å kjøre Irix er begrenset), i tillegg til forskjellige rammebuffere og kontrollere SCSI .

QEMU- programvaren er også i stand til å emulere, blant mange andre, MIPS- og MIPSel-arkitekturen, i tillegg til å kjøre GNU/Linux på den emulerte maskinen.

CREATOR-simulatoren [ 6 ]​ [ 7 ]​ [ 8 ]​ [ 9 ]​ er bærbar og lar deg lære ulike assembly-språk for forskjellige prosessorer (CREATOR har eksempler med implementering av MIPS32 og RISC-V-instruksjonene) .

WepSIM-simulatoren [ 10 ] ​[ 11 ]​ kan brukes fra en nettleser. Det er en pedagogisk simulator å programmere i MIPS som har forskjellige eksempler som bruker en implementering av MIPS-instruksjoner på en mikroprogrammert måte. WepSIM gjør det enkelt å lære ulike aspekter av hvordan en CPU fungerer (mikroprogrammering, avbrudd, systemanrop, unntak, etc.).

Sammendrag av systemanrop

Å foreta et systemanrop av et program er å be om en tjeneste fra operativsystemet, vanligvis for å vise informasjon på skjermen eller lese informasjon fra tastaturet.

Før du ber om tjenesten gjennom syscall-instruksjonen, må koden knyttet til tjenesten angis i registeret $v0 og informasjonsverdiene som skal opereres med, må angis i registrene knyttet til nevnte tjeneste.

Tabellen nedenfor viser eksempler på de mest brukte tjenestene i SPIM-, MARS-, CREATOR- eller WepSIM- simulatorene .

Eksempler på systemanrop brukt i SPIM
Service juksekode Inngang Avgang Karakterer
print_int $v0=1 $a0= heltall å skrive ut Skriv ut $a0 til standardutdata
print_float $v0=2 $f12= flyte til utskrift Skriv ut $f12 til standardutdata
print_double $v0=3 $f12= dobbel for å skrive ut Skriv ut $f12 til standardutdata
print_string $v0=4 $a0= adressen til det første tegnet Skriv ut tegnstrengen til standardutdata
read_int $v0=5 Les inn i $v0 et heltall fra standardinndata
read_float $v0=6 Les inn $v0 en flyte fra standardinndata
les_dobbel $v0=7 Les inn i $v0 en dobbel fra standardinndata
lese_streng $v0=8 $a0 = bufferadresse, $a1= bufferlengde Les inn i standard inngangsbuffer
sbrk $v0=9 $a0= nødvendig antall byte La den reserverte minneadressen stå i $v0 Reserver minne fra haugen
exit $v0=10 Avslutt utførelse

R3000 instruksjonssett sammendrag

Instruksjoner er delt inn i tre typer: R, I og J. Alle instruksjoner starter med en 6-bits opkode . I tillegg til opkoden er tre registre spesifisert i R-type instruksjoner, ett felt for størrelsen på offset ('shamt') og et annet for funksjonskoden; Type Is spesifiser to registre og en 16-bits umiddelbar verdi; i type J, er operasjonskoden etterfulgt av 26 bits med hoppdestinasjonsadresse. [ 12 ] ​[ 13 ]

Registrer navn, nummer, bruk og ringekonvensjoner (hvis lagret i oppringt subrutine):

Rekorder
Navn Antall Bruk Bevart i kalt subrutine
$null $0 heltallskonstant 0 Ja
$at $1 montør midlertidig Nei
$v0–$v1 $23 Funksjonsreturverdier og uttrykksevaluering Nei
$a0–$a3 $4–$7 Send argumenter til subrutiner Nei
$t0–$t7 $8–$15 midlertidig Nei
$s0–$s7 $16–$23 reddet stormer Ja
$t8–$t9 $24–$25 midlertidig Nei
$k0–$k1 $26–$27 Reservert for OS-kjernen Nei
$gp $28 global peker Ja
$sp $29 stabelpeker Ja
$fp $30 stabelrammepeker Ja
$ra $31 returadresse Nei

Registrene som er bevart under en samtale er de som (ved konvensjon) ikke vil bli modifisert av et systemanrop eller en subrutine (som implementerer en prosedyre eller funksjon i sammenstilling). For eksempel må registrene $s_ lagres på stabelen ved prosedyren som trenger dem (kalt subrutine), alltid økes i konstantene $sp og $fp, for senere å reduseres når prosedyren er ferdig (det reserverte minnet). Derimot endres $ra automatisk etter et normalt funksjonskall (hvilken som helst som bruker jal-setningen), og $t_-registrene må lagres av den anropende subrutinen før du kaller noen funksjoner (i tilfelle programmet trenger dem). values som finnes i disse registrene etter utførelsen av subrutinen).

Kongelige instruksjoner

Det er en rekke instruksjoner som har en direkte maskinvareimplementering, i motsetning til pseudo -instruksjoner som er oversatt til flere virkelige instruksjoner før de settes sammen.

Følgende er de tre mulige instruksjonsformatene:

Fyr -31- Format (biter) -0-
R albue (6) ms (5) rt (5) dr (5) sjamt (5) codfunc (6)
Yo albue (6) ms (5) rt (5) umiddelbar/offset (16)
J albue (6) adresse (26)
Kategori Navn Instruksjonssyntaks Betydning Format/codop/codfunc Karakterer
aritmetikk Addisjon legg til $1,$2,$3 $1 = $2 + $3 (signert) R 0 legge til to poster
usignert sum legg til $1,$2,$3 $1 = $2 + $3 ( usignert ) R 0
Subtraksjon under$1,$2,$3 $1 = $2 - $3 (signert) R 0 trekke fra to poster
umiddelbar sum legg til $1,$2,CONST $1 = $2 + CONST (signert) Yo brukes til å legge til konstanter (og også for å kopiere fra ett register til et annet "addi $1, $2, 0")
Usignert umiddelbar tillegg legg til $1,$2,CONST $1 = $2 + CONST ( usignert ) Yo
Multiplikasjon bot $1,$2 LO = (($1 * $2) << 32) >> 32;
HI = ($1 * $2) >> 32;		 R 0 Den multipliserer to registre og lagrer 64-bits resultatet i to spesielle minneplasseringer - LO og HI. Alternativt kan man si at resultatet av denne operasjonen er: (int HI,int LO) = (64 bits) $1 * $2 .
Inndeling $1, $2 LO = $1 / $2 HI = $1 % $2 R Deler to registre og lagrer 32-bits heltallsresultatet LO og resten HI. [ 12 ]
Data overføring adressebelastning $1, Tag $1 = minneadresse Yo Laster inn minneadressen til en tag.
ordlasting lw$1,CONST($2) $1 = Minne[$s2 + CONST] Yo Laster det lagrede ordet fra ($s2+CONST) fremover (3 flere byte).
halv ord belastning lh$1,CONST($2) $1 = Minne[$s2 + CONST] Yo Last inn det halve ordet som er lagret fra ($s2+CONST) og utover (1 byte til).
byte belastning lb$1,CONST($2) $1 = Minne[$s2 + CONST] Yo Last inn byten som er lagret i ($s2+CONST).
ordlagring sw$1,CONST($2) Minne[$s2 + CONST] = $1 Yo Lagrer et ord i ($s2+CONST) og de neste 3 byte. Rekkefølgen på operandene er en stor kilde til forvirring.
lagring av et halvt ord sh$1,CONST($2) Minne[$s2 + CONST] = $1 Yo Lagrer den første halvdelen av et register (et halvt ord) i ($s2+CONST) og neste byte.
byte lagring sb $1,CONST($2) Minne[$s2 + CONST] = $1 Yo Lagrer den første byten i et register i ($s2+CONST).
Ansvar for nærmeste overordnede av $1,CONST $1 = KONST << 16 Yo Laster en 16-bits umiddelbar operand inn i de 16 bitene i det spesifiserte registeret. Maksimal verdi av konstanten er 2 16 -1
Flytt fra "høy" mfhi $1 $1 = HI R Flytter en HI-verdi til registeret. En multipliser eller divider-instruksjon må ikke brukes mellom to mfhi-instruksjoner (denne handlingen er udefinert på grunn av MIPS-rørledningen).
Flytt fra "lav" mflo $1 $1 = LO R 0 Flytt en LO-verdi til registeret. En multiplikasjons- eller delinstruksjon må ikke brukes mellom to mflo-instruksjoner (denne handlingen er udefinert på grunn av MIPS-rørledningen)
logikk Og og $1,$2,$3 $1 = $2 og $3 R Og bitvis
Og med umiddelbar og $1,$2,CONST $1 = $2 & CONST Yo
Eller eller $1,$2,$3 $1 = $2 | $3 R eller bitvis
Eller med umiddelbar eller $1,$2,CONST $1 = $2 | KONST Yo
eller eksklusivt xor $1,$2,$3 $1 = $2 ^ $3 R
Heller ikke heller ikke $1,$2,$3 $1 = ~($2 | $3) R ikke bitvis
Initialiser hvis mindre enn slt$1,$2,$3 $1 = ($2 < $3) R Sjekk om den ene posten er mindre enn den andre.
Initialiser hvis mindre enn med umiddelbar slti $1,$2,CONST $1 = ($2 < KONST) Yo Sjekker om et register er mindre enn en konstant.
bitskifte Logisk skift til venstre sll $1,$2,CONST $1 = $2 << KONST R Flytt CONST registerbiter til venstre (multipliser med )
Logisk høyreskifte srl $1,$2,CONST $1 = $2 >> KONST R Skift CONST-registerbitene til høyre polstret med nuller (dele med ). Merk at denne instruksjonen bare fungerer som en divisjon av et tall i 2-komplementet hvis dette tallet er positivt.
Aritmetisk forskyvning til høyre fru $1,$2,CONST
R Skift CONST-registerbitene ved å fylle med den tilsvarende fortegnsbiten (del et 2-komplementnummer med )
betingede hopp hopp hvis det samme beq $1,$2,CONST hvis ($1 == $2) gå til PC+4+CONST Yo Hopp til instruksjonen på den angitte adressen hvis begge registre er like.
hopp hvis ikke likt bne $1,$2,CONST hvis ($1 != $2) gå til PC+4+CONST Yo Hopp til instruksjonen på den angitte adressen hvis begge registre ikke er like.
ubetinget hopp Hoppe j KONST gå til adressen CONST J Hopp ubetinget til instruksjonen som er lagret på den angitte adressen.
hoppe til opptak junior $1 fikk adresse $1 R Hopp til adressen som er lagret i det angitte registeret.
hopp og link jal CONST $31 = stk + 4; gå til CONST J Brukes i anrop til subrutiner. Lagre returadressen i $31, som returneres med jr $31

MERK: I jump- og branch-setninger kan CONST erstattes med en eksisterende tag hvor som helst i koden.

Pseudo-instruksjoner blir oversatt til flere reelle instruksjoner før de settes sammen.

Navn Instruksjonssyntaks Oversettelse til ekte instruksjoner Betydning
hopp hvis større enn bgt $rs,$rt,Label slt $at,$rt,$rs; bne $at,$null,Label if(R[rs]>R[rt]) PC=Etikett
Hopp hvis mindre enn blt $rs,$rt,Label slt $at,$rs,$rt; bne $at,$null,Label if(R[rs]<R[rt]) PC=Etikett
Hopp hvis større enn eller lik bge $rs,$rt,Label slt $at,$rs,$rt; beq $at,$zero,Label if(R[rs]>=R[rt]) PC=Etikett
Hopp hvis mindre enn eller lik ble $rs,$rt,Label slt $at,$rt,$rs; beq $at,$zero,Label if(R[rs]<=R[rt]) PC=Etikett
hopp hvis samme som beq $rs, $rt, Label beq $rs, $rt, Label if(R[rs]==R[rt]) PC=Etikett
hopp hvis lik null beqz$rs,Etikett beq $rs,$zero,Label if(R[rs]==0) PC=Etikett
Hopp hvis større enn (usignert) bgtu $rs,$rt,Label sltu $at,$rt,$rs; bne $at,$null,Label if(R[rs]>R[rt]) PC=Etikett
Hopp hvis større enn null bgtz$rs,Etikett slt $at,$null,$rs; bne $at,$null,Label if(R[rs]>0) PC=Etikett

Andre instruksjoner

Disse instruksjonene kan klassifiseres som både "ekte" og "pseudo-instruksjoner".

Vanlige bitvise logiske instruksjoner
legg til $1,$2,100 $1 = $2 + 100 (usignert sum med umiddelbar)
legg til $1,$2,$3 $1 = $2 + $3 (usignert sum)
div $1,$2 HI = $1 % $2 ; LO = $1 / $2
under $1,$2,$3 $1 = $2 - $3 (usignert subtraksjon)
Instruksjoner for overføring av minne til register
lbu $1100($2) Last inn en usignert byte
lhu$1100($2) usignert halv ord belastning
lwcz$1100($2) Last inn et ord til coprocessor "z" ("z" er coprocessor-nummeret)

Merk at det ikke er noen "lasting av den nedre umiddelbare" instruksjonen, siden dette arbeidet kan gjøres gjennom en addi (legg til med umiddelbar) eller en ori (eller med umiddelbar) med registeret $0 (hvis verdi alltid er null). For eksempel, så mye addi $1, $0, 100som ori $1, $0, 100desimaltallet 100 lastes inn i registeret $1.

Instruksjoner for overføring av register til minne
swcz$1100($2) Lagrer et ord fra coprocessor "z" ("z" er coprocessor-nummeret).
Ta opp-til-opptak flyttningsinstruksjoner
mfcz $1,$c1 Flytter en verdi fra koprosessorregister $1 til hovedprosessorregister $1 ("z" er koprosessornummeret)
mtcz$1,$c1 Flytter en verdi fra hovedprosessorregister $1 til koprosessorregister $1 ("z" er koprosessornummeret)
mov.d $fp1,$fp3 Flytter en dobbelpresisjonsverdi fra FPU - register $3 til flytepunktregister for hovedprosessor $1
mov.s $fp1,$fp3 Flytter en enkeltpresisjonsverdi fra FPU - register $3 til flytepunktregisteret for hovedprosessor $1

(doble presisjonsverdier bruker to tilstøtende FPU-registre)

En operasjon på fortegnskonstanter skiller seg fra en uten fortegn ved at den ikke gir unntak. Subtraksjonen av en konstant kan gjøres som summen av dens negasjon.

Andre viktige instruksjoner

  • nop (ingen operasjon) (fra maskinkode 0x00000000 og tolket av CPU som sll $0,$0,0)
  • pause (avslutter programmet, brukes på feilsøkingstidspunktet )
  • syscall (systemanrop)
  • noen instruksjoner knyttet til FPU
  • virtuelle instruksjoner , brutt ned av assembleren i opprinnelige instruksjoner

MIPS R4000 Instruksjon og registerreferanse

Dette er MIPS R4000 instruksjons- og registerreferanseliste, med 32 32-bits registre. Denne prosessoren finnes spesifikt i Sony Computer Entertainments PlayStation Portable -konsoll

* Bruksanvisning

legg addu addi addiu og andi divu mult multu div nor or ori sll sllv sra srav srl srlv subu xor xori lhi llo slt sltu slti sltiu beq bgtz blez bne j jal jalr jr la li lb lbu lh lhu mws mws mtlo trape

* Rekorder

$at $v0 $v1 $a0 $a1 $a2 $a3 $t0 $t1 $t2 $t3 $t4 $t5 $t6 $t7 $s0 $s1 $s2 $s3 $s4 $s5 $s6 $s7 $t8 $t9 $k0 $k1 $gp $sp $fp $ra

Referanser

  1. ^ "Arkiveret kopi" . Arkivert fra originalen 19. juli 2015 . Hentet 19. juli 2015 . 
  2. ↑ NEC tilbyr to rimelige 64-biters RISC-mikroprosessorer
  3. ↑ [1]
  4. ↑ [2]
  5. ↑ https://web.archive.org/web/20110308062931/http://www.loongson.cn/EN/
  6. ↑ https://zenodo.org/record/5130302#.YVSL23UzZNg
  7. ↑ https://doi.org/10.1109/CLEI53233.2021.9640144
  8. ↑ CREATOR Web med MIPS32 eksempel: https://creatorsim.github.io/creator/?example_set=default&example=e12
  9. ↑ CREATOR kildekode på GitHub: https://github.com/creatorsim/creator
  10. ↑ WepSIM Web med MIPS32 eksempel: https://wepsim.github.io/wepsim/ws_dist/wepsim-classic.html?mode=ep&examples_set=Default-MIPS&example=12&simulator=assembly:register_file¬ify=false
  11. ↑ WepSIM kildekode på GitHub: https://github.com/wepsim/wepsim
  12. ^ a b "MIPS R3000 instruksjonssettsammendrag (på engelsk)" . Arkivert fra originalen 28. juni 2018 . Hentet 14. oktober 2005 . 
  13. ↑ MIPS-instruksjonsreferanse

Senere lesninger

  • Patterson og Hennessy: Struktur og design av datamaskiner. Krets/programmeringsgrensesnitt . Redaksjonell Reverté. ISBN 84-291-2619-8

Se også

Eksterne lenker