Arquitetura MIPS

Origem: Wikipédia, a enciclopédia livre.
Ir para: navegação, pesquisa
Translation Latin Alphabet.svg
Este artigo ou secção está a ser traduzido (desde março de 2008). Ajude e colabore com a tradução.

MIPS, acrônimo para Microprocessor without interlocked pipeline stages (microprocessador sem estágios interligados de pipeline - não confundir com o outros significados de "MIPS"), é uma arquitetura de microprocessadores RISC desenvolvido pela MIPS Computer Systems.

Em meados de 1990s estimou-se que um em cada três microprocessadores RISC era MIPS.

Os processadores MIPS são usados em aplicações tais como:

Arquitetura[editar | editar código-fonte]

As primeiras versões das CPU's MIPS eram de 32-bits, mas as mais recentes tornaram-se 64-bits. Existem 5 versões da implementação MIPS, compatíveis entre si, chamadas MIPS I, MIPS II, MIPS III, MIPS IV, e MIPS 32/64. O mais recente, MIPS 32/64 de liberação 2, define um registrador de controle ajustado assim como o conjunto de instruções.

  • Diversas extensões “add-on” estão também disponíveis, incluindo MIPS-3D que é um conjunto simples das instruções ponto-flutuante SIMD dedicadas às tarefas 3D comuns;
  • MDMX, que é um conjunto de instruções mais extensivo do inteiro SIMD usando os registos ponto-flutuante 64-bit;
  • MIPS MT , adições ao sistema similar a HyperThreading nas famílias mais recentes de processadores da Intel.

Pelo fato de ser um processador com design "limpo", esta arquitetura MIPS pode ser usada com fins educativos, e influenciou processadores tais como o SPARC da Sun.

História[editar | editar código-fonte]

Um grupo liderado por David Patterson e Carlo Séquin, em Berkeley, desenvolveu chips processadores, para dar um nome a este conceito eles utilizaram o termo RISC, e deram ao chip desenvolvido por eles nessa filosofia o nome RISC I no ano de 1980. Esse chip foi quase imediatamente seguido pelo RISC II, projetado pelos mesmos dois pesquisadores. Pouco mais tarde, em 1981, John Hennessy, pesquisador de Stanford, universidade situada do outro lado da baía de San Francisco, projetou e fabricou um chip diferente, ao qual ele deu o nome de MIPS. O conceito básico era aumentar muito o desempenho com o uso de pipelines profundos para as instruções, uma técnica que, embora fosse boa, era difícil de fazer. Geralmente um pipeline divide a tarefa de executar uma instrução em diversas etapas, executando, de forma sobreposta, várias instruções ao mesmo tempo. Porém, os projetos tradicionais da época esperavam para terminar uma instrução inteira antes de seguir adiante, deixando assim o processador sem fazer nada por boa parte do tempo enquanto uma instrução era concluída.[1]

Várias dificuldades surgem no momento da implementação de um processador com pipeline, mas nada preocupava mais do que as medidas de verificação de término de instruções, quando estas duram mais que um ciclo de relógio. Estas medidas impedem o carregamento de novos dados antes da conclusão da instrução, provocando uma pausa no carregamento do pipeline. Isto poderia prejudicar o desempenho no futuro, mas para o projeto MIPS todas as instruções necessárias deveriam ser concluídas em um único ciclo, assim não haveria este problema. Esta foi uma escolha que simplificou e acelerou o projeto, mas também trouxe desvantagens óbvias, como a eliminação de instruções úteis, tais como multiplicação e divisão que requerem múltiplos passos. Alguns observadores notaram que o projeto MIPS (abrangendo a filosofia RISC), exige que o programador substitua as instruções de multiplicações e divisões com uma série de operações simples e, portanto, a melhoria do desempenho foi eliminada ou reduzida em boa parte.

Os analistas responsáveis pela eliminação dessas instruções foram bastante controversos, e muitos pensaram que o MIPS (RISC e processadores em geral) não se concretizaria. Se uma única instrução tem de ocorrer em meio a outras, o tempo total seria o mesmo de uma instrução executada após a outra, então onde estaria o aumento de velocidade? Esta análise simplista, não considerou que a chave para a velocidade do processador estava nos pipelines.

Hennessy começou a acreditar no potencial da arquitetura, e formou a MIPS Computer Systems, no ano de 1984. A empresa apresentou seu primeiro projeto, o R2000, em 1985 como a primeira máquina comercial RISC,[2] as falhas encontradas nesta máquina foram corrigidas com o lançamento do R3000 em 1988. Este projeto era a base da companhia na década de 1980, e foi utilizado principalmente em algumas séries de estações de trabalho da Silicon Graphics Inc. Estes projetos comerciais deram início, na Stanford, a uma série de pesquisas acadêmicas em áreas como a implementação da maioria dos bloqueios de hardware e instruções completas para a multiplicação e divisão, entre outros.

Os novos processadores criados por Hennessy eram muito diferentes dos processadores comercializados na época. Considerando que tais processadores não precisavam ser compatíveis com nenhum outro, seus projetistas tinham toda a liberdade para escolher novos conjuntos de instruções que viessem a maximizar o desempenho do sistema. Apesar de a ênfase inicial ter privilegiado instruções simples, que pudessem ser executadas rapidamente, logo ficou clara a importância de se projetarem instruções que pudessem ser iniciadas prontamente, como questão fundamental para o bom desempenho. O tempo que uma instrução leva para ser executada passou a importar menos do que a quantidade de instruções que pudessem ser iniciadas em um ciclo.

O primeiro microprocessador de 64 bits utilizando a tecnologia MIPS chega ao mercado em 1991, o R4000TM também pode executar facilmente aplicações de 32 bits mesmo que o processador esteja rodando em 64 bits. Os principais destaques do R4000TM são: 64 bits em unidade lógica aritimética (ULA) e 64 bits em espaço de endereço virtual.

A Silicon Graphics Inc., adquire a MIPS Computer Systems em 1992, dando sequência ao desenvolvimento de microprocessadores MIPS através do seu Grupo, e incorpora MIPS Technologies, Inc. como uma subsidiária de propriedade da SGI. Três anos depois o R4700 entra no mercado como uma versão de baixo custo levando o título de microprocessador do ano.

Em 1996, a arquitetura MIPS tornou-se arquitetura RISC que teve maior ascensão no mundo, com 19,2 milhões de processadores licenciados MIPS. No ano seguinte foram licenciados 48 milhões de processadores fazendo com que a arquitetura mips ultrapassesse o processador 68000 Motorola com tecnologia CISC.

Em 1998, estava claro que havia um mercado emergente onde microprocessadores 32-bit poderiam trabalhar em desktops para uso nos lares. Como o custo de projetar e fabricar microprocessadores baseados na tecnologia MIPS diminuiu, foi um grande momento para a MIPS atender diretamente o mercado. Em 30 de junho de 1998, a MIPS Technologies lançou oferta como empresa de Sociedade Anônima. E em 1999, os padrões de arquitetura MIPS64 e MIPS32 são introduzidos, incorporando todas as instruções MIPS anteriores ao conjunto destas arquiteturas e fornecendo uma base para todo o desenvolvimento futuro dos processadores MIPS.

No ano 2001 são apresentadas melhorias para as arquiteturas MIPS32 e MIPS64 estas melhorias são entítuladas como “versão 2” da arquitetura outra vez obteve o mais alto desempenho da indústria com 32 bits disponíveis. Posteriormente é apresentado um pequeno processador, de alto desempenho e baixo consumo de energia o MIPS32 M4K® core, projetado para múltiplos núcleos de CPU, mas logo é substituído pelo MIPS32 24k, com núcleos de alta performance.[3]

Em 2007, a MIPS Technologies adquire a Chipidea empresa voltada para o projeto e fabricação de semicondutores. Agora, com mais de 250 milhões de clientes ao redor do mundo, a empresa tem o controle de alguns dos produtos mais populares do mundo para o entretenimento digital, redes domésticas sem fio, e mercados de mídia portáteis. No mesmo ano anuncia uma entrada estratégica no mercado de microcontroladores com 32 bits. Também em 2007 o próprio recorde em fabricação de processadores foi mais uma vez quebrado com mais de 350 milhões de unidades expedidas durante todo o ano.

Após dez anos como uma empresa de Sociedade Anônima a MIPS Technologies Introduz o MIPS Navigator Integrated Component Suite (ICS) com o intuito de permitir que desenvolvedores gerem mais facilmente o código e possam depurar e analisar sistemas Linux em MIPS-BasedTM e sistemas embarcados. Agora a MIPS Tecnologies tem cinco grandes famílias de núcleos de processador com opções de configuração robusta para uma ampla gama de mercados e aplicações, bem como quatro grandes linhas de produtos analógicos. Além disto, a MIPS Technologies em 2008 apresenta um completo portfólio de ferramentas de desenvolvimento com algumas das soluções mais avançadas da indústria para ajudar os desenvolvedores a diminuir custos e obter mais rapidamente um elevado grau de confiança no mercado.

Em 2009, a MIPS Technologies publicou informações sobre o uso do Android em processadores MIPS. Os desenvolvedores podem usar esta plataforma para dispositivos de consumo, tais como, televisores digitais, dispositivos móveis de internet, telefones celulares, players de mídia e sistemas de VoIP em casa. Também foi oferecido um programa de acesso a fabricantes de produtos, que poderão ter contato com engenheiros da empresa e fazer adaptações específicas de software e hardware utilizando o Android.

Neste mesmo ano a MIPS anunciou sua aproximação do sistema do Google durante a feira Computex, na China, mostrando um tocador de mídia residencial e uma tela LCD de 10,4 polegadas com um computador portátil rodando o sistema Android. Estes foram os primeiros produtos fora da categoria de celulares e smartphones com o sistema do Google.

Família do processador central[editar | editar código-fonte]

O primeiro modelo comercial do processador central dos MIPS, o R2000, foi anunciado em 1985. Adicionou o múltiplo-ciclo multiplica e divide instruções em uma unidade um tanto independente da em-microplaqueta. As instruções novas foram adicionadas para recuperar os resultados desta parte traseira da unidade ao núcleo da execução. Ironicamente, as instruções de recuperação foram bloqueadas, que melhoraram a densidade compilada do código mas fizeram o nome dos MIPS sem sentido.

O R2000 podia ser big-endian ou little-endian carregado. Não teve o thirty-two 32 registos de uso geral do bocado, mas o nenhum registro do código de circunstância, considerando o um potencial gargalo, uma característica que compartilhasse com o AMD 29000 e o alfa do DEC. Ao contrário de outros registos o contador de programa não é diretamente acessível.

O R2000 teve também a sustentação para até quatro co-processadores, um de que foi construído no processador central principal e segurou exceções e armadilhas, quando os outros três foram deixados para outros usos. Um destes poderia ser enchido pelo R2010 opcional FPU, que teve o thirty-two 32 registos do bocado que poderiam ser usados como dezesseis registos 64-bit para double-precision.

O R3000 sucedeu o R2000 em 1988, adicionando esconderijos de 32 kB (aumentados logo a 64 KB) para instruções e dados, junto com a sustentação da coerência do esconderijo para o uso do multi-processor. Quando havia umas falhas na sustentação do multiprocessor de R3000, controlou ainda ser uma parte de diversos projetos bem sucedidos do multiprocessor. O R3000 incluiu também um MMU interno, uma característica comum nos processadores centrais da era. O R3000 era os primeiros MIPS bem sucedidos projeta no marketplace, e sobre 1 milhão foram feitos eventualmente. O R3000A, usado em Sony extremamente bem sucedido PlayStation, era uma versão colidida velocidade que funciona em 40 megahertz que entregou um desempenho de 32 VUPs. Como o R2000, o R3000 foi emparelhado com o R3010 FPU. Pacemips produziu um R3400 e IDT produziu R3500, ambos ele era R3000s com o fpu R3010 em uma única microplaqueta. R3900 de Toshiba era virtualmente um primeiro SoC para os PCes Handheld adiantados baseados no CE de Windows.

A série R4000, liberada em 1991, estendida o jogo de instrução dos MIPS a uma arquitetura 64-bit cheia, movida o FPU no dado principal para criar um sistema single-chip, e operada em uma velocidade de pulso de disparo interna radical elevada (foi introduzida em 100 megahertz). Entretanto, a fim conseguir a velocidade de pulso de disparo os esconderijos foram reduzidos a 8 KB cada e fizeram exame de três ciclos ao acesso. As freqüências operando-se elevadas foram conseguidas com a técnica do encanamento profundo (chamado super-encanamento naquele tempo). Com a introdução do R4000 um número de versões melhoradas seguiram logo, including o R4400 de 1993 que incluíram esconderijos de 16 KB, a operação 64-bit pela maior parte bug-free, e um controlador para um outro esconderijo externo de 1 MB (2 nivelados).

Os MIPS, agora uma divisão do SGI chamaram MTI, projetams o baixo-custo R4200, e mais tarde o custo mesmo mais baixo R4300, que era o R4200 com uma barra-ônibus externa de 32 bocados. Nintendo 64 usou um processador central de NEC VR4300 que fosse baseado nos MIPS low-cost R4300i. [1]

Os dispositivos do efeito de Quantum (QED), uma companhia separada enfiada por refugees dos MIPS, projetaram o R4600 “Orion”, o R4700 “Orion”, o R4650 e o R5000. Onde o R4000 tinha empurrado a freqüência de pulso de disparo e é sacrificado a capacidade do esconderijo, os projetos de QED emfatizaram os esconderijos grandes que poderiam ser alcançados em apenas dois ciclos e no uso eficiente da área do silicone. Os R4600 e os R4700 foram usados nas versões low-cost da estação de trabalho do SGI Indy assim como os primeiros roteadores da Cisco baseados em MIPS, tais como os roteadores 36x0 e 7x00-séries. O R4650 foi usado nas caixas originais do ajust-alto de WebTV (agora tevê de Microsoft). O R5000 FPU teve programar floating-point mais flexível de precisão simples do que o R4000, e em conseqüência, R5000-based SGI Indys teve o desempenho para gráficos muito melhor do que R4400 similarmente cronometrado Indys com a mesma ferragem dos gráficos. O SGI deu à placa velha dos gráficos um nome novo quando foi combinado com o R5000 a fim emfatizar a melhoria. QED projetou mais tarde a família RM7000 e RM9000 dos dispositivos para mercados encaixados como o trabalho em rede e as impressoras de laser. QED foi adquirido pelo PMC-Sierra do fabricante do semicondutor em agosto 2000, última companhia que continua a invest na arquitetura dos MIPS.

O R8000 (1994) era os primeiros MIPS superscalar projeta, capaz de executar dois ALU e duas operações de memória por o ciclo. O projeto foi espalhado sobre seis microplaquetas: uma unidade do inteiro (com esconderijos de dados de 16 KB da instrução e de 16 KB L1), uma unidade floating-point, três ram secundárias do Tag do esconderijo do cheio-costume (dois para acessos secundários do esconderijo, um para a barra-ônibus que snooping), e um controlador ASIC do esconderijo. O projeto mandou a precisão dois dobro inteiramente pipelined multiplic-adicionar as unidades, que poderiam fluir dados do esconderijo secundário off-chip do MB 4. O R8000 powered usuários do computador do desafio do poder do SGI nos 1990s mid e tornou-se mais tarde disponível na estação de trabalho do poder Indigo2. Seus desempenho limitado do inteiro e custo elevado umedeceram a apelação para a maioria de usuários, embora seus usuários científicos aptos do desempenho de FPU completamente bem, e o R8000 não fossem no marketplace por somente um ano e remanescessem razoavelmente raros.

Em 1995, o R10000 foi liberado. Este processador era um projeto single-chip, funcionava em uma velocidade de pulso de disparo mais rápida do que o R8000, e tinha 32 KB maiores esconderijos preliminares da instrução e dos dados. Era também superscalar, mas sua inovação principal era execução out-of-order. Mesmo com um único encanamento da memória e um FPU mais simples, o desempenho do inteiro, o preço mais baixo vastamente melhorado, e a densidade mais elevada fizeram o R10000 preferível para a maioria de clientes.

Os projetos recentes tudo foram baseados no núcleo R10000. O R12000 usou o manufacturing melhorado encolher a microplaqueta e operar-se em umas taxas de pulso de disparo mais elevadas. O R14000 revisado permitiu umas taxas de pulso de disparo mais elevadas com sustentação adicional para DDR SRAM no esconderijo off-chip, e uma barra-ônibus mais rápida do lado dianteiro cronometrou a 200 megahertz para o throughput melhor. Umas iterações mais atrasadas são nomeadas o R16000 e o R16000A e caracterizam a velocidade de pulso de disparo aumentada, o esconderijo L1 adicional, e o manufacturing menor do dado comparado com antes. MIPS das especificações do microprocessador Modelo Freqüência [megahertz] Ano Processo [µm] Transistor [milhões] Tamanho do dado [² do milímetro] Pinos do IO Poder [W] Tensão Dcache [k] Icache [k] Scache [k] R2000 8-16.7 1985 2.0 0.11 -- -- -- -- 32 64 nenhuns R3000 20-40 1988 1.2 0.11 66.12 145 4—64 64 nenhuns R4000 100 1991 0.8 1.35 213 179 15 5 8 8 1024 R4400 100-250 1992 0.6 2.3 186 179 15 5 16 16 1024 R4600 100-133 1994 0.64 2.2 77 179 4.6 5 16 16 512 R5000 150-200 1996 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 R10000 150-250 1995 0.35 6.8 299 599 30 3.3 32 32 512 R12000 270-400 1998 0.18-0.25 6.9 204 600 20 4 32 32 1024 R14000 500-600 2001 0.13 7.2 204 527 17—32 32 2048 R16000 700-800 2002 0.11 -- -- -- 20—64 64 4096

Nota: Estas especificações são somente configurações comuns do processador. As variações existem, especialmente no esconderijo do nível 2.

Aplicações[editar | editar código-fonte]

Entre os fabricantes que fizeram sistemas da estação de trabalho do computador que usam processadores dos MIPS ser SGI, MIPS de Sistemas Computatorizados, Inc., Olivetti, Siemens-Nixdorf, Acer, Digital Equipment Corporation, NEC, e DeskStation. Os vários sistemas operando-se foram movidos à arquitetura, tal como o CE de IRIX do SGI, de Windows NT de Microsoft (embora sustentação para os MIPS terminados com a liberação de Windows NT 4.0) e de Windows, Linux, sistema V do DEB, do UNIX, SINIX, MIPS próprio RISC/os dos sistemas computatorizados, e outros.

Entretanto, o uso dos MIPS como o processador principal de estações de trabalho do computador declinou, e o SGI anunciou suas plantas para cessar de desenvolver iterações high-performance da arquitetura dos MIPS no favor de usar processadores de Intel IA64-based (ver a “outra seção dos modelos e das plantas futuras” abaixo).

Na uma mão, o uso dos microprocessadores dos MIPS em papéis encaixados é provável remanescer comum, por causa das características baixas de execuções encaixadas dos MIPS, a disponibilidade larga do poder-consumo e do calor de ferramentas de desenvolvimento encaixadas para MIPS, as well as os peritos knowledgeable sobre a arquitetura.

Outros modelos e plantas futuras[editar | editar código-fonte]

Outros membros da família dos MIPS incluem o R6000, uma execução do ECL da arquitetura dos MIPS que foi produzida pela tecnologia integrada bipolar. O microprocessador R6000 introduziu o jogo de instrução dos MIPS II. Sua arquitetura de TLB e de esconderijo é diferente de todos membros restantes da família dos MIPS. O R6000 não entregou os benefícios prometidos do desempenho, e embora visse algum uso em máquinas dos dados de controle, desapareceu rapidamente do mercado mainstream. O RM7000 era uma versão do R5000 com um built-in 256 esconderijo do nível 2 do kB e um controlador para o esconderijo opcional do nível três. Foi alvejado primeiramente em projetos encaixados, including processadores dos gráficos do SGI e várias soluções do trabalho em rede, primeiramente por Cisco. O nome R9000 foi usado nunca.

Em uma vez o SGI tinha pretendido mover-se fora da plataforma dos MIPS para Intel Itanium, e o desenvolvimento era ter terminado com o R10000. O sempre-mais longo atrasa em introduzir o Itanium significou que a base instalada de máquinas MIPS-baseadas continuou a aumentar. Por 1999 estava desobstruído que o desenvolvimento tinha terminado demasiado logo, e os R14000 e os R16000 foram liberados em conseqüência. O SGI tinha sugerido R8000 em um estilo mais complexo FPU para umas R-séries mais atrasadas, e também em um processador duplo do núcleo, mas os problemas financeiros e o uso oficialmente suportado do SGI da emulation de QuickTransit funcionar binaries de IRIX em Altix eliminaram essencialmente o desenvolvimento da ferragem de IRIX/MIPS.

Núcleos[editar | editar código-fonte]

Em anos recentes da tecnologia usada nas várias gerações dos MIPS foi oferecido mais como IP-núcleos (edifício-obstrui) para projetos encaixados do processador. O bocado ambos os 32 e os núcleos básicos 64-bit são oferecidos, sabido como o 4K e o 5K respectivamente, e o projeto próprio pode ser licenciado como MIPS32 e MIPS64. Estes núcleos podem ser misturados com as unidades add-in tais como FPUs, sistemas de SIMD, a vária entrada - dispositivos de saída, etc.

Os MIPS dos núcleos foram comercialmente bem sucedidos, agora sendo usado nos muitos consumidor e aplicações industriais. Os MIPS dos núcleos podem ser encontrados em uns roteadores mais novos de Cisco e de Linksys, em uns modem de cabo e em uns modem do ADSL, em uns smartcards, em uns motores da impressora de laser, em umas caixas do ajust-alto, em uns robôs, em computadores handheld, em Sony PlayStation 2 e em Sony PlayStation portátil. Em aplicações de cellphone/PDA, o núcleo dos MIPS foi incapaz de deslocar o encarregado, núcleo competindo do BRAÇO.

Exemplos de dispositivos baseados em MIPS: Broadcom BCM5352E - Processador do roteador de WiFi com 802.11g WLAN, Fast Ethernet, 200 megahertz, ins 16KiB. esconderijo dos dados 8KiB, esconderijo do prefetch 256B, MMU, 16 flash de série/paralelo do controlador do megahertz SDRAM do bocado 100, 5 Ethernet do porto 100 Mbit/s (interruptor), 16 GPIO, JTAG, 2xUART, 336 esfera BGA. BCM 11xx, 12xx, 14xx - linha dos MIPS de 64bit “SiByte”.

IDT RC32438, ATI Xilleon, Alchemy Au1000, 1100, 1200, Broadcom Sentry5, Cavium Octeon CN34xx e CN38xx, tecnologias EasyPort de Infineon, Amazon, ADM5120, WildPass, INCA-IP, INCA-IP2, EMMA de NEC e EMMA2, NEC VR4181A, VR4121, VR4122, VR4181A, VR5432, VR5500, geração das tecnologias do carvalho, PMC-Sierra RM11200, QuickLogic QuickMIPS ESP, Toshiba “Donau”, Toshiba TMPR492x, TX4925, TX9956, TX7901

Programação e emulação[editar | editar código-fonte]

Há dos “um simulador livremente disponível” SPIM chamado MIPS R2000/R3000 para diversos sistemas operacionais (UNIX, especificamente GNU/Linux; Mac OS X; MS Windows 95, 98, NT, 2000, XP; e DOS) qual é útil para o aprendizado de programação no conjunto de instruções MIPS e os conceitos gerais de programação RISC: http://www.cs.wisc.edu/~larus/spim.html

Um emulador livre característica-mais rico dos MIPS está disponível do projeto de GXemul (sabido anteriormente como o projeto de mips64emul), que emula não somente os vários MIPS III e uns microprocessadores mais elevados (do R4000 com o R10000), mas emula também os sistemas computatorizados inteiros que usam os microprocessadores. Por exemplo, GXemul pode emular um DECstation com um processador central dos MIPS R4400 (e o carregador a Ultrix), e um O2 do SGI com um processador central dos MIPS R10000 (embora a habilidade de carregar Irix seja limitada), entre outros, assim como os vários framebuffers, os controladores de SCSI, e o gosto que compreendem aqueles sistemas. Mips das chamadas do sistema serviço Código da armadilha Entrada Saída Notas print_int $v0=1 inteiro de $a0= a imprimir imprime a0 à saída padrão print_string $v0=4 endereço de $a0= do primeiro caráter imprime uma corda de caráter à saída padrão sbrk $v0=9 número de $a0= dos bytes requeridos endereço de $v0= da memória alocada Aloca a memória do heap

Sumário do jogo de instrução R3000[editar | editar código-fonte]

As instruções são divididas em três tipos do formato: Formato de R, de I e de J. O formato de R consiste em três registros e campo funcional, o I formato contém dois registros e o valor imediato de 16 bits, e o por último o formato J, no qual seu opcode tem seis bits seguido de um valor imediato de 26 bits. [2] [3]

Nome de registo, número, uso, e convenções da chamada: Registos Nome Número Uso O Callee deve preservar? $zero $0 constante 0 N/A $at $1 ajuntador provisório não $v0-$v1 $2–$3 Valores para retornos da função e avaliação da expressão não $a0-$a3 $4–$7 argumentos da função não $t0-$t7 $8–$15 temporaries não $s0-$s7 $16–$23 temporaries conservados sim $t8-$t9 $24–$25 temporaries não $k0-$k1 $26–$27 reservado para a semente do ósmio não $gp $28 ponteiro global sim $sp $29 ponteiro de pilha sim $fp $30 ponteiro do frame sim $ra $31 endereço do retorno N/A

Regista que é preservado através de uma chamada é os registos que (pela convenção) não será mudado por uma chamada do sistema ou pela chamada do procedimento (função). Por exemplo, $s-registers deve ser conservado à pilha por um procedimento que necessite o usar, e $sp e $fp estão incrementados sempre por constantes, e decrecidos para trás depois que o procedimento é feito com elas (e a memória que apontam a). Pelo contraste, $ra é mudado automaticamente por toda a ligação de controle normal (umas que usa o jal), e $t-registers deve ser conservado pelo programa antes de qualquer chamada do procedimento (se o programa necessita os valores dentro deles após a chamada).

Instruções reais[editar | editar código-fonte]

Estas são as instruções que têm a execução de ferragem direta. Isto é ao contrário das instruções pseudo que são traduzidas em instruções reais múltiplas antes de ser montada.

Os seguintes são os três formatos usados para o jogo de instrução do núcleo: Tipo -31 - formato (bocados) -0- R opcode (6) rs (5) rt (5) rd (5) shamt (5) funct (6) I opcode (6) rs (5) rt (5) imediato (16) J opcode (6) endereço (26)

  • CONST denota uma constante (“imediato”).
  • No seguinte, os números do registo são somente exemplos, e todos os outros registos podem ser usados em seus lugares.
  • Todas as seguintes instruções são instruções nativas.
  • Opcodes e os códigos do funct estão no hexadecimal.
Categoria Nome Sintaxe da Instrução Significado Format/opcode/funct Notas
Arithmetic Add add $1,$2,$3 $1 = $2 + $3 (signed) R 0 20_{16} adds two registers, extends sign to width of register
Add unsigned addu $1,$2,$3 $1 = $2 + $3 (unsigned) R 0 21_{16} as above without sign extension
Subtract sub $1,$2,$3 $1 = $2 – $3 (signed) R 0 22_{16} subtracts two registers
Subtract unsigned subu $1,$2,$3 $1 = $2 – $3 (unsigned) R 0 as above without sign extension
Add immediate addi $1,$2,CONST $1 = $2 + CONST (signed) I 8_{16} Used to add constants (and also to copy one register to another "addi $1, $2, 0"), with sign extension
Add immediate unsigned addiu $1,$2,CONST $1 = $2 + CONST (unsigned) I 9_{16} as above without sign extension
Multiply mult $1,$2 LO = (($1 * $2) << 32) >> 32;
HI = ($1 * $2) >> 32;
R 0 18_{16} Multiplies two registers and puts the 64-bit result in two special memory spots - LOW and HI. Alternatively, one could say the result of this operation is: (int HI,int LO) = (64-bit) $1 * $2 .
Divide div $1, $2 LO = $1 / $2     HI = $1 % $2 R Divides two registers and puts the 32-bit integer result in LO and the remainder in HI.
Data Transfer Load word lw $1,CONST($2) $1 = Memory[$2 + CONST] I 23_{16} loads the word stored from: MEM[$s2+CONST] and the following 3 bytes.
Load halfword lh $1,CONST($2) $1 = Memory[$2 + CONST] (signed) I 25_{16} loads the halfword stored from: MEM[$2+CONST] and the following byte. Sign is extended to width of register.
Load halfword unsigned lhu $1,CONST($2) $1 = Memory[$2 + CONST] (unsigned) I As above without sign extension.
Load byte lb $1,CONST($2) $1 = Memory[$2 + CONST] (signed) I loads the byte stored from: MEM[$2+CONST].
Load byte unsigned lbu $1,CONST($2) $1 = Memory[$2 + CONST] (unsigned) I As above without sign extension.
Store word sw $1,CONST($2) Memory[$2 + CONST] = $1 I stores a word into: MEM[$2+CONST] and the following 3 bytes. The order of the operands is a large source of confusion.
Store half sh $1,CONST($2) Memory[$2 + CONST] = $1 I stores the first half of a register (a halfword) into: MEM[$2+CONST] and the following byte.
Store byte sb $1,CONST($2) Memory[$2 + CONST] = $1 I stores the first fourth of a register (a byte) into: MEM[$2+CONST].
Load upper immediate lui $1,CONST $1 = CONST << 16 I loads a 16-bit immediate operand into the upper 16-bits of the register specified. Maximum value of constant is 216-1
Move from high mfhi $1 $1 = HI R Moves a value from HI to a register. Do not use a multiply or a divide instruction within two instructions of mfhi (that action is undefined because of the MIPS pipeline).
Move from low mflo $1 $1 = LO R 0 12_{16} Moves a value from LO to a register. Do not use a multiply or a divide instruction within two instructions of mflo (that action is undefined because of the MIPS pipeline).
Move from Control Register mfcZ $1, $2 $1 = Coprocessor[Z].ControlRegister[$2] R Moves a 4 byte value from Coprocessor Z Control register to a general purpose register. Sign extension.
Move to Control Register mtcZ $1, $2 Coprocessor[Z].ControlRegister[$2] = $1 R Moves a 4 byte value from a general purpose register to a Coprocessor Z Control register. Sign extension.
Load word coprocessor lwcZ $1,CONST($2) Coprocessor[Z].DataRegister[$1] = Memory[$2 + CONST] I Loads the 4 byte word stored from: MEM[$2+CONST] into a Coprocessor data register. Sign extension.
Store word coprocessor swcZ $1,CONST($2) Memory[$2 + CONST] = Coprocessor[Z].DataRegister[$1] I Stores the 4 byte word held by a Coprocessor data register into: MEM[$2+CONST]. Sign extension.
Logical And and $1,$2,$3 $1 = $2 & $3 R Bitwise and
And immediate andi $1,$2,CONST $1 = $2 & CONST I
Or or $1,$2,$3 $1 = $2 | $3 R Bitwise or
Or immediate ori $1,$2,CONST $1 = $2 | CONST I
Exclusive or xor $1,$2,$3 $1 = $2 ^ $3 R
Nor nor $1,$2,$3 $1 = ~($2 | $3) R Bitwise nor
Set on less than slt $1,$2,$3 $1 = ($2 < $3) R Tests if one register is less than another.
Set on less than immediate slti $1,$2,CONST $1 = ($2 < CONST) I Tests if one register is less than a constant.
Bitwise Shift Shift left logical sll $1,$2,CONST $1 = $2 << CONST R shifts CONST number of bits to the left (multiplies by 2^{CONST} )
Shift right logical srl $1,$2,CONST $1 = $2 >> CONST R shifts CONST number of bits to the right - zeros are shifted in (divides by 2^{CONST} ). Note that this instruction only works as division of a two's complement number if the value is positive.
Shift right arithmetic sra $1,$2,CONST  $1 = $2 >> CONST + \
 \bigg(\bigg(\sum_{n=1}^{CONST}2^{31-n}\bigg)\cdot $2 >> 31 \bigg)
R shifts CONST number of bits - the sign bit is shifted in (divides 2's complement number by 2^{CONST} )
Conditional branch Branch on equal beq $1,$2,CONST if ($1 == $2) go to PC+4+CONST I Goes to the instruction at the specified address if two registers are equal.
Branch on not equal bne $1,$2,CONST if ($1 != $2) go to PC+4+CONST I Goes to the instruction at the specified address if two registers are not equal.
Unconditional jump Jump j CONST goto address CONST J Unconditionally jumps to the instruction at the specified address.
Jump register jr $1 goto address $1 R Jumps to the address contained in the specified register
Jump and link jal CONST $31 = PC + 4; goto CONST J For procedure call - used to call a subroutine, $31 holds the return address; returning from a subroutine is done by: jr $31

NOTA: nas instruções ramificar e de salto, o offset pode ser substituído por um presente da etiqueta em algum lugar no código.

Os Pseudoinstructions são traduzidos em instruções reais múltiplas (ver acima) antes de ser montada.

Name instruction syntax Real instruction translation meaning
Load Address la $1, LabelAddr lui $1, LabelAddr[31:16]; ori $1,$1, LabelAddr[15:0] $1 = Label Address
Load Immediate li $1, IMMED[31:0] lui $1, IMMED[31:16]; ori $1,$1, IMMED[15:0] $1 = 32 bit Immediate value
Branch greater than bgt if(R[rs]>R[rt]) PC=Label
Branch less than blt if(R[rs]<R[rt]) PC=Label
Branch greater than or equal bge if(R[rs]>=R[rt]) PC=Label
branch less than or equal ble if(R[rs]⇐R[rt]) PC=Label
branch greater than unsigned bgtu if(R[rs]⇒R[rt]) PC=Label
branch greater than zero bgtz if(R[rs]>0) PC=Label

Outras instruções[editar | editar código-fonte]

Estas instruções devem ser colocadas acima “nas seções reais das instruções” ou dos “pseudoinstructions”.

Instruções lógicas comuns (bitwise)[editar | editar código-fonte]

addiu $1, $2.100 $1 = $2 + 100 (imediato não assinado) addu $1, $2, $3 $1 = $2 + $3 (não assinado) div $1, $2 HI = $ 1% $2; = $1 BAIXOS/$2 subu $1, $2, $3 $1 = $2 – $3 (não assinado)

Memória para registar instruções de transferência[editar | editar código-fonte]

lbu $1.100 ($2) carrega um byte não assinado lhu $1.100 ($2) carrega um halfword não assinado lwcz $1.100 ($2) carrega uma palavra ao coprocessor de “z” (“z” é o número do coprocessor)

Anotar que não há nenhuma da “instrução imediata correspondente carga mais baixo”; isto pode ser feito usando o addi (adicionar imediato, vêem abaixo) ou o ori (ou imediato) com o registo $0 (cujo o valor é sempre zero). Por exemplo, o addi $1, $0, 100 e ori $1, $0, 100 carrega o valor decimal 100 no registo $1.

Registar às instruções de transferência da memória[editar | editar código-fonte]

swcz $1.100 ($2) armazena uma palavra do coprocessor de “z” (“z” é o número do coprocessor).

Registro - a - instruções do registo (movimento)[editar | editar código-fonte]

mfcz $1, $c1 move um valor no registo $1 do coprocessor para o registo principal $1 do processador (“z” é o número do coprocessor) mtcz $1, $c1 move um valor do registo principal $1 do processador para o registo $1 do coprocessor mov.d $fp1, $fp3 move um valor com precisão dobro do registo $3 de FPU para o registo $1 de f.p. mov.s $fp1, $fp3 move um valor com única precisão do registo $3 de FPU para o registo $1 de f.p.

(valores com registos adjacentes do uso dois FPU da precisão dobro)

Uma operação com os immediates assinados difere de um com os não assinados que não joga uma exceção. Subtrair um imediato pode ser feito com adição da negação desse valor como o imediato.

Algumas outras instruções importantes[editar | editar código-fonte]

  • nop (nenhuma operação) (código de máquina 0x00000000, interpretado pelo processador central como o sll $0, $0.0)
  • ruptura (rupturas o programa, usado por debuggers)
  • syscall (usos para chamadas do sistema ao sistema se operando)
  • um jogo de instruções FPU-relacionadas
  • um jogo vasto de instruções virtuais, decomposed pelo ajuntador em instruções nativas

Curiosidade[editar | editar código-fonte]

Em Super Mario 64, o coelho é nomeado Mips em homenagem ao processador MIPS usado no sistema Nintendo 64.

Notas[editar | editar código-fonte]

  1. O NEC oferece a dois o desempenho elevado do custo os microprocessadores 64-bit do RISC
  2. um sumário do jogo de instrução dos MIPS R3000 de b
  3. Referência da instrução dos MIPS do ^

Leitura adicional[editar | editar código-fonte]

  • David A. Patterson e John L. Hennessy - Organização e Projeto de Computadores: A Interface Hardware/Software. Publishers de Morgan Kaufmann. ISBN 1-55860-604-1
  • Dominic Sweetman: Ver MIPS funcionar. Publishers de Morgan Kaufmann. ISBN 1-55860-410-3

Referências

  1. TANENBAUM, Andrew S. Sistemas Operacionais Modernos. 2ª ed. São Paulo: Prentice Hall, 2003.
  2. TANENBAUM, Andrew S. Organização estruturada de computadores. 5ª ed. São Paulo: Pearson Prentice Hall, 2007.
  3. HENNESSY, J.L. and PATTERSON, D.A. Arquiteturade Computadores: Uma Abordagem Quantitativa. 3ª ed. Rio de Janeiro: Campus, 2003.

Ver também[editar | editar código-fonte]