b'\n_START_ARTICLE_\nRISC\n_START_SECTION_\nHist\xc3\xb3ria\n_START_PARAGRAPH_\nDesde os primeiros momentos da ind\xc3\xbastria de computadores os cientistas dos principais fabricantes de componentes de hardware t\xc3\xaam estudado m\xc3\xa9todos e t\xc3\xa9cnicas que possam aperfei\xc3\xa7oar o desempenho e a capacidade dos sistemas de computa\xc3\xa7\xc3\xa3o._NEWLINE_Alguns aspectos atribu\xc3\xaddos ao primeiro RISC: projetos marcados por volta de 1975 incluem as observa\xc3\xa7\xc3\xb5es que os compiladores de mem\xc3\xb3ria restritos da \xc3\xa9poca eram frequentemente incapazes de tirar proveito dos recursos destinados a facilitar a montagem manual de codifica\xc3\xa7\xc3\xa3o, e que os modos de endere\xc3\xa7amento complexos levavam muitos ciclos para executar devido aos exigidos acessos \xc3\xa0 mem\xc3\xb3ria adicional. Foi alegado que tais fun\xc3\xa7\xc3\xb5es seriam melhor executadas por sequ\xc3\xaancias de instru\xc3\xa7\xc3\xb5es mais simples se isso poderia render implementa\xc3\xa7\xc3\xb5es pequenas o suficiente para deixar espa\xc3\xa7o para muitos registros, reduzindo o n\xc3\xbamero de acessos \xc3\xa0 mem\xc3\xb3ria lenta. Nestes projetos simples, a maioria das instru\xc3\xa7\xc3\xb5es s\xc3\xa3o de tamanho uniforme e estrutura semelhante, as opera\xc3\xa7\xc3\xb5es aritm\xc3\xa9ticas s\xc3\xa3o restritas a registros de CPU e instru\xc3\xa7\xc3\xb5es a carregar apenas separam e armazenam a mem\xc3\xb3ria de acesso. Essas propriedades permitem um melhor balanceamento de est\xc3\xa1gios no pipeline do que antes, fazendo pipelines RISC significativamente mais eficientes e permitindo que as frequ\xc3\xaancias de clock fossem mais altas._NEWLINE_No in\xc3\xadcio da d\xc3\xa9cada de 1980, surgiram v\xc3\xa1rias pesquisas cujo desejo era de aumentar o desempenho do sistema de computa\xc3\xa7\xc3\xa3o. Se o desejo era esse, deve-se procurar aperfei\xc3\xa7oar o emprego das instru\xc3\xa7\xc3\xb5es que consomem mais tempo de execu\xc3\xa7\xc3\xa3o, e n\xc3\xa3o se preocupar tanto com instru\xc3\xa7\xc3\xb5es mais complexas que raramente s\xc3\xa3o usadas._NEWLINE_Ao longo das d\xc3\xa9cadas em que \xc3\xa9 usado o computador, observa-se que o hardware em geral, os processadores e a mem\xc3\xb3ria, tem evolu\xc3\xaddo mais rapidamente que o software._NEWLINE_Por outro lado, a manuten\xc3\xa7\xc3\xa3o e desenvolvimento de programas n\xc3\xa3o evolu\xc3\xadram em custo/benef\xc3\xadcio. Apesar de a todo o momento surgirem novas cria\xc3\xa7\xc3\xb5es e lan\xc3\xa7amentos, isso acarreta um custo muito elevado. A manuten\xc3\xa7\xc3\xa3o tamb\xc3\xa9m pode ser um problema, pois os programas oferecidos pelos fabricantes est\xc3\xa3o longe da aus\xc3\xaancia de falhas (bugs)._NEWLINE_Entre as pesquisas realizadas nessa \xc3\xa9poca, podemos citar a de David Patterson, que, juntamente com Carlos S\xc3\xa9quin, publicou em 1982 [PATT82] um estudo mostrando o desempenho, os par\xc3\xa2metros e elementos de linguagens de alto n\xc3\xadvel quando compiladas e executadas. Esse artigo descrevia uma nova arquitetura para um processador, propondo solucionar os problemas de desempenho e custo existentes nas arquiteturas complexas vigentes (CISC). Esta arquitetura foi chamada de RISC, porque criava um processador com pequeno conjunto de instru\xc3\xa7\xc3\xb5es._NEWLINE_Esse trabalho \xc3\xa9 usado como refer\xc3\xaancia para a avalia\xc3\xa7\xc3\xa3o do comportamento dos programas de alto n\xc3\xadvel e seu desempenho din\xc3\xa2mico, no qual os autores apresentaram resultados da compila\xc3\xa7\xc3\xa3o e da execu\xc3\xa7\xc3\xa3o de oito programas diferentes, quatro em linguagem Pascal e quatro em linguagem C._NEWLINE_As an\xc3\xa1lises efetuadas de programas compilados por m\xc3\xa1quinas de arquitetura CISC, mostraram que os compiladores n\xc3\xa3o eram mais t\xc3\xa3o espertos quanto os programadores Assembly na busca de instru\xc3\xa7\xc3\xb5es de m\xc3\xa1quina complexas. O programa compilador utiliza pouco da grande quantidade de instru\xc3\xa7\xc3\xb5es e dos modos de endere\xc3\xa7amento que est\xc3\xa3o dispon\xc3\xadveis, pois parece ser dif\xc3\xadcil analisar o programa de alto n\xc3\xadvel._NEWLINE_Por exemplo, para efetuar a soma entre dois operandos em uma m\xc3\xa1quina com arquitetura CISC, sendo que um dos valores est\xc3\xa1 em um registrador e o outro na mem\xc3\xb3ria, levar\xc3\xa1 um certo tempo gasto para calcular o endere\xc3\xa7o de acesso a mem\xc3\xb3ria._NEWLINE_J\xc3\xa1 em uma m\xc3\xa1quina com arquitetura RISC, s\xc3\xa3o usadas duas instru\xc3\xa7\xc3\xb5es(diferente da arquitetura CISC que utiliza uma instru\xc3\xa7\xc3\xa3o), mas como s\xc3\xa3o instru\xc3\xa7\xc3\xb5es mais simples, sua execu\xc3\xa7\xc3\xa3o \xc3\xa9 bem mais r\xc3\xa1pida fazendo com que seu tempo total seja menor._NEWLINE_\xc3\x89 uma estrat\xc3\xa9gia de desenvolvimento de CPU com base na percep\xc3\xa7\xc3\xa3o de que simplificado (em oposi\xc3\xa7\xc3\xa3o ao complexo) as instru\xc3\xa7\xc3\xb5es podem proporcionar maior desempenho, se essa simplicidade permite a execu\xc3\xa7\xc3\xa3o muito mais r\xc3\xa1pida de cada instru\xc3\xa7\xc3\xa3o. Um computador com base nesta estrat\xc3\xa9gia \xc3\xa9 um computador com um reduzido conjunto de instru\xc3\xa7\xc3\xb5es (tamb\xc3\xa9m RISC). Existem muitas propostas de defini\xc3\xa7\xc3\xb5es precisas, mas o termo est\xc3\xa1 sendo lentamente substitu\xc3\xaddo pela arquitetura mais descritiva load-store. Fam\xc3\xadlias bem conhecidas incluem RISC DEC Alpha, a AMD 29k, ARC, ARM, Atmel AVR, MIPS, PA-RISC, Power (incluindo PowerPC), SuperH e SPARC.\n_START_SECTION_\nFilosofia de Desenvolvimento RISC\n_START_PARAGRAPH_\nEm meados de 1970 investigadores (em especial John Cocke) da IBM (e projetos semelhantes em outros lugares) demonstraram que a maioria das combina\xc3\xa7\xc3\xb5es desses modos ortogonais de endere\xc3\xa7amento e as instru\xc3\xa7\xc3\xb5es n\xc3\xa3o foram utilizados pela maioria dos programas gerados por compiladores dispon\xc3\xadveis no momento. Ele revelou-se dif\xc3\xadcil em muitos casos, para escrever um compilador com mais que a capacidade limitada de tirar proveito dos recursos oferecidos pelos processadores convencionais._NEWLINE_Tamb\xc3\xa9m foi descoberto que, em implementa\xc3\xa7\xc3\xb5es de arquiteturas microcodificadas, certas opera\xc3\xa7\xc3\xb5es complexas tendem a ser mais lentas do que uma sequ\xc3\xaancia de opera\xc3\xa7\xc3\xb5es mais simples fazendo a mesma coisa. Isso foi em parte um efeito do fato de que muitos projetos foram levados \xc3\xa0s pressas, com pouco tempo para otimizar ou sintonizar todas as instru\xc3\xa7\xc3\xb5es, mas sim apenas aquelas usadas com mais frequ\xc3\xaancia. Um exemplo famoso foi a instru\xc3\xa7\xc3\xa3o do VAX de \xc3\xadndice._NEWLINE_Como mencionado anteriormente, a mem\xc3\xb3ria de n\xc3\xbacleo h\xc3\xa1 muito havia sido mais lenta do que muitos projetos de CPU. O advento de mem\xc3\xb3rias de semicondutores reduziu essa diferen\xc3\xa7a, mas ainda era aparente que mais registradores (e mais tarde caches) permitiria maior frequ\xc3\xaancia de opera\xc3\xa7\xc3\xa3o da CPU. registros adicionais exigiriam chips importantes ou \xc3\xa1reas bordo que, na \xc3\xa9poca (1975), poderiam ser disponibilizados se a complexidade da l\xc3\xb3gica de CPU havia sido reduzida._NEWLINE_Contudo um outro impulso de ambos os RISC e outros projetos veio a partir de medi\xc3\xa7\xc3\xb5es pr\xc3\xa1ticas em programas no mundo real. Andrew Tanenbaum resumiu muitos destes, demonstrando que os processadores tiveram muitas vezes tamanhos desproporcionais imediatos. Por exemplo, ele mostrou que 98% de todas as constantes em um programa iriam caber em 13 bits, mas muitos projetos CPU dedicam de 16 ou 32 bits para armazen\xc3\xa1-los._NEWLINE_Isto sugere que, para reduzir o n\xc3\xbamero de acessos \xc3\xa0 mem\xc3\xb3ria, uma m\xc3\xa1quina de comprimento fixo pode armazenar constantes em bits n\xc3\xa3o utilizados da palavra de instru\xc3\xa7\xc3\xa3o em si, de modo que eles seriam imediatamente prontos quando a CPU precisa deles (muito parecido com endere\xc3\xa7amento imediato em um desenho convencional). Estes necess\xc3\xa1rios e pequenos opcodes, ocorreram a fim de deixar espa\xc3\xa7o para uma constante com um tamanho razo\xc3\xa1vel em uma palavra de instru\xc3\xa7\xc3\xa3o de 32 bits._NEWLINE_Uma vez que muitos programas do mundo real passam a maior parte do seu tempo executando opera\xc3\xa7\xc3\xb5es simples, alguns pesquisadores decidiram concentrar em fazer as opera\xc3\xa7\xc3\xb5es o mais r\xc3\xa1pido poss\xc3\xadvel. A velocidade do clock de uma CPU \xc3\xa9 limitado pelo tempo que leva para executar a mais lenta sub-opera\xc3\xa7\xc3\xa3o de qualquer instru\xc3\xa7\xc3\xa3o, diminuindo o tempo de ciclo que, muitas vezes acelera a execu\xc3\xa7\xc3\xa3o de outras instru\xc3\xa7\xc3\xb5es. O foco na "instru\xc3\xa7\xc3\xb5es reduzida" levou ao. resultando m\xc3\xa1quina que est\xc3\xa1 sendo chamado de "computador conjunto reduzido de instru\xc3\xa7\xc3\xb5es" (RISC). O objetivo era fazer instru\xc3\xa7\xc3\xb5es t\xc3\xa3o simples que poderiam ser facilmente e rapidamente processadas, a fim de aumentar o clock e atingir altas frequ\xc3\xaancias._NEWLINE_Mais tarde verificou-se que uma das caracter\xc3\xadsticas mais importantes dos processadores RISC \xc3\xa9 que a mem\xc3\xb3ria externa s\xc3\xb3 era acess\xc3\xadvel por uma instru\xc3\xa7\xc3\xa3o de armazenar carga. Todas as outras instru\xc3\xa7\xc3\xb5es foram limitadas aos registos internos. Isso simplificou muitos aspectos do design do processador: permitir que as instru\xc3\xa7\xc3\xb5es para ser de comprimento fixo, simplifica\xc3\xa7\xc3\xa3o de condutas, e isolar a l\xc3\xb3gica para lidar com o atraso na conclus\xc3\xa3o de um acesso \xc3\xa0 mem\xc3\xb3ria (cache miss, etc.) para apenas duas instru\xc3\xa7\xc3\xb5es. Isso levou a RISC projetos que est\xc3\xa3o sendo referidos como arquiteturas load/store.\n_START_SECTION_\nInstru\xc3\xa7\xc3\xa3o de defini\xc3\xa7\xc3\xa3o do tamanho e terminologia alternativa\n_START_PARAGRAPH_\nUm equ\xc3\xadvoco comum da express\xc3\xa3o "computador conjunto reduzido de instru\xc3\xa7\xc3\xb5es" \xc3\xa9 a ideia de que as instru\xc3\xa7\xc3\xb5es s\xc3\xa3o simplesmente eliminadas, resultando em um menor conjunto de instru\xc3\xa7\xc3\xb5es. De fato, ao longo dos anos, conjuntos de instru\xc3\xa7\xc3\xb5es RISC cresceram em tamanho, e hoje muitos deles t\xc3\xaam um conjunto maior de instru\xc3\xa7\xc3\xb5es do que muitos processadores CISC. Alguns processadores RISC, como o Transputer INMOS t\xc3\xaam conjuntos de instru\xc3\xa7\xc3\xb5es t\xc3\xa3o grandes como, por exemplo, o CISC IBM System/370 e, inversamente, o DEC PDP-8 - claramente uma CPU CISC porque muitas de suas instru\xc3\xa7\xc3\xb5es envolvem m\xc3\xbaltiplos acessos \xc3\xa0 mem\xc3\xb3ria - tem apenas 8 instru\xc3\xa7\xc3\xb5es b\xc3\xa1sicas, al\xc3\xa9m de algumas instru\xc3\xa7\xc3\xb5es prorrogadas._NEWLINE_O termo "redu\xc3\xa7\xc3\xa3o" em que a frase foi concebido para descrever o fato que a quantidade de qualquer trabalho \xc3\xbanico a instru\xc3\xa7\xc3\xa3o realizada \xc3\xa9 reduzida - no m\xc3\xa1ximo um ciclo de mem\xc3\xb3ria de dados \xc3\xbanico - em compara\xc3\xa7\xc3\xa3o com as "instru\xc3\xa7\xc3\xb5es complexas" do CISC CPUs que podem exigir dezenas de ciclos de mem\xc3\xb3ria para executar uma \xc3\xbanica instru\xc3\xa7\xc3\xa3o. Em particular, os processadores RISC geralmente t\xc3\xaam instru\xc3\xa7\xc3\xb5es separadas por I/O (input/output - entrada/sa\xc3\xadda) e de processamento de dados; consequentemente, os observadores da ind\xc3\xbastria come\xc3\xa7aram a utilizar os termos "registro-registro" ou "carga armazenada "para descrever os processadores RISC._NEWLINE_Alguns CPUs foram retroativamente apelidados RISC - um artigo da revista Byte certa vez se referiu a 6502 como "o processador RISC original", devido \xc3\xa0 sua instru\xc3\xa7\xc3\xa3o simplistas e quase ortogonais (mais instru\xc3\xa7\xc3\xb5es de trabalho, com a maioria dos modos de endere\xc3\xa7amento), bem como a sua 256 p\xc3\xa1gina-zero "registos". O 6502 est\xc3\xa1 sem carga design do armazenamento no entanto: opera\xc3\xa7\xc3\xb5es aritm\xc3\xa9ticas pode ler a mem\xc3\xb3ria e as instru\xc3\xa7\xc3\xb5es de como INC ROL e at\xc3\xa9 mesmo modificar a mem\xc3\xb3ria. Al\xc3\xa9m disso, ortogonalidade \xc3\xa9 igualmente associada frequentemente com "CISC". No entanto, o 6502 pode ser considerado semelhante ao RISC (m\xc3\xa1quinas e precoce) no fato de que ele n\xc3\xa3o usa sequ\xc3\xaancia de microc\xc3\xb3digo. No entanto, o fato bem conhecido que a empresa empregava mais longos, por\xc3\xa9m menos ciclos de clock em rela\xc3\xa7\xc3\xa3o a muitos microprocessadores contempor\xc3\xa2neos foi devido a um design mais ass\xc3\xadncrono com menor subdivis\xc3\xa3o de ciclos de m\xc3\xa1quina interna. Isso \xc3\xa9 semelhante \xc3\xa0s m\xc3\xa1quinas de in\xc3\xadcio, mas n\xc3\xa3o para RISC._NEWLINE_Alguns processadores foram projetados especificamente para ter um conjunto muito pequeno de instru\xc3\xa7\xc3\xb5es - mas esses projetos s\xc3\xa3o muito diferentes dos desenhos cl\xc3\xa1ssicos RISC, para que eles tenham recebido outras denomina\xc3\xa7\xc3\xb5es, tais como computador instru\xc3\xa7\xc3\xa3o m\xc3\xadnima set (MISC), a Instru\xc3\xa7\xc3\xa3o Zero Set Computer (ZISC), um conjunto de instru\xc3\xa7\xc3\xb5es de computador (OISC), transporte acionado arquitetura (ATT), etc\n_START_SECTION_\nAlternativas\n_START_PARAGRAPH_\nRISC foi desenvolvida como uma alternativa ao que \xc3\xa9 hoje conhecido como CISC. Ao longo dos anos, outras estrat\xc3\xa9gias foram implementadas como alternativa para o RISC e CISC. Alguns exemplos s\xc3\xa3o a arquitetura VLIW, MISC, OISC, processamento paralelo maci\xc3\xa7o, matriz sist\xc3\xb3lica, computa\xc3\xa7\xc3\xa3o reconfigur\xc3\xa1vel, e o fluxo de dados.\n_START_SECTION_\nRISC inicial\n_START_PARAGRAPH_\nO primeiro sistema que hoje seria conhecido como RISC era o supercomputador CDC 6600, projetado em 1964, uma d\xc3\xa9cada antes que o termo foi inventado. O CDC 6600 tinha uma arquitetura load-store, com apenas dois modos de endere\xc3\xa7amento (Registrar e registrar constante imediato) e 74 opcodes (enquanto um Intel 8086 tem 400). O 6600 tinha onze unidades funcionais pipeline para aritm\xc3\xa9tica e l\xc3\xb3gica, al\xc3\xa9m de cinco unidades de carga e duas unidades de armazenamento, a mem\xc3\xb3ria tinha bancos m\xc3\xbaltiplos assim todas as unidades de armazenamento de carga poderiam operar ao mesmo tempo. O ciclo de clock base / taxa de emiss\xc3\xa3o de instru\xc3\xa7\xc3\xa3o foi de 10 vezes mais r\xc3\xa1pido que o tempo de acesso \xc3\xa0 mem\xc3\xb3ria. Jim Thornton e Seymour Cray projetou como um processador central de processamento de n\xc3\xbameros, apoiados por 10 computadores simples, chamados de "processadores perif\xc3\xa9ricos" para lidar com I / O e outras fun\xc3\xa7\xc3\xb5es do sistema operacional. Assim, o coment\xc3\xa1rio de brincadeira depois que a sigla RISC realmente significava " Realmente Inventado por Seymour Cray._NEWLINE_Outra m\xc3\xa1quina de armazenar carga inicial foi o minicomputador Data General Nova, projetada em 1968 por Edson de Castro. Tinha um conjunto de instru\xc3\xa7\xc3\xb5es RISC quase puro, muito semelhante ao dos processadores ARM de hoje, por\xc3\xa9m, n\xc3\xa3o foi citado como tendo influenciado os designers ARM, embora Novas estavam em uso na Universidade de Cambridge, Laborat\xc3\xb3rio de Inform\xc3\xa1tica no in\xc3\xadcio de 1980._NEWLINE_A primeira tentativa de fazer um chip baseado em RISC CPU era um projeto da IBM, que come\xc3\xa7ou em 1975. Nomeando ap\xc3\xb3s o edif\xc3\xadcio onde funcionou o projeto, o trabalho levou \xc3\xa0 fam\xc3\xadlia de processadores IBM 801, que foi amplamente utilizado no interior de hardware da IBM. O 801 acabou por ser produzida em uma \xc3\xbanica forma de chip como o ROMP, em 1981, que era para \'Pesquisa OPD [Office Products Division] micro processador. Como o nome indica, este processador foi projetado para "mini" tarefas, e quando a IBM lan\xc3\xa7ou o IBM RT-PC baseado no projeto em 1986, o desempenho n\xc3\xa3o era aceit\xc3\xa1vel. No entanto, o 801 inspirado v\xc3\xa1rios projectos de investiga\xc3\xa7\xc3\xa3o, incluindo novos na IBM que acabaria por levar \xc3\xa0 sua rede el\xc3\xa9ctrica._NEWLINE_A maioria dos projetos p\xc3\xbablicos RISC, no entanto, foram os resultados dos programas de universidade de pesquisa executado com financiamento do Programa de VLSI DARPA. O Programa de VLSI, hoje praticamente desconhecido, levou a um grande n\xc3\xbamero de avan\xc3\xa7os no design de chips, fabrica\xc3\xa7\xc3\xa3o, gr\xc3\xa1ficos e at\xc3\xa9 mesmo um computador._NEWLINE_Projeto UC Berkeley RISC come\xc3\xa7ou em 1980 sob a dire\xc3\xa7\xc3\xa3o de David Patterson e Carlo H. Lantejoula, com base no ganho de desempenho atrav\xc3\xa9s da utiliza\xc3\xa7\xc3\xa3o de pipelining e um uso agressivo de uma t\xc3\xa9cnica conhecida como registro de janelas. Em uma CPU normal tem um pequeno n\xc3\xbamero de registros, e um programa pode usar qualquer registro a qualquer momento. Em uma CPU com o registro de Janelas, h\xc3\xa1 um grande n\xc3\xbamero de registros, por exemplo, 128, mas os programas podem usar apenas um pequeno n\xc3\xbamero deles, por exemplo, 8, a qualquer momento. Um programa que limita-se a 8 registros por procedimento pode fazer chamadas de procedimento muito r\xc3\xa1pido: A chamada simplesmente move a janela "para baixo" por 8, para o conjunto de 8 registros utilizados por esse procedimento, e o retorno move a janela traseira. (Em um CPU normal, a maioria das chamadas deve poupar pelo menos os valores poucos registros \'para a pilha, a fim de utilizar esses registos como espa\xc3\xa7o de trabalho, e restaurar os valores de retorno)._NEWLINE_O projeto RISC entregou o processador RISC-I em 1982. Composta de apenas 44.420 transistores (em compara\xc3\xa7\xc3\xa3o com as m\xc3\xa9dias de cerca de 100 mil em projetos novos CISC da \xc3\xa9poca) RISC eu tinha apenas 32 instru\xc3\xa7\xc3\xb5es, e ainda completamente superado qualquer outro projeto de chip \xc3\xbanico. Eles seguiram para o transistor 40.760, de 39 anos instru\xc3\xa7\xc3\xb5es RISC-II, em 1983, que decorreu ao longo de tr\xc3\xaas vezes mais r\xc3\xa1pido que RISC-I._NEWLINE_Na mesma \xc3\xa9poca, John L. Hennessy come\xc3\xa7ou um projeto semelhante chamado MIPS na Universidade de Stanford em 1981. MIPS centrou-se quase inteiramente sobre o gasoduto, certificando-se que poderia ser executado como "completa" poss\xc3\xadvel. Embora pipelining j\xc3\xa1 estava em uso em outros projetos, v\xc3\xa1rias caracter\xc3\xadsticas do chip MIPS fez seu pipeline muito mais r\xc3\xa1pido. O mais importante, e talvez chato, desses recursos foi a exig\xc3\xaancia de que todas as instru\xc3\xa7\xc3\xb5es de ser capaz de concluir em um ciclo. Essa exig\xc3\xaancia permitiu que o pipeline para ser executado em taxas de dados muito maior (n\xc3\xa3o houve necessidade de atrasos induzidos) e \xc3\xa9 respons\xc3\xa1vel por muito do desempenho do processador. No entanto, tamb\xc3\xa9m teve o efeito colateral negativo de elimina\xc3\xa7\xc3\xa3o de muitas instru\xc3\xa7\xc3\xb5es potencialmente \xc3\xbateis, como uma multiplica\xc3\xa7\xc3\xa3o ou uma divis\xc3\xa3o._NEWLINE_Nos primeiros anos, os esfor\xc3\xa7os RISC eram bem conhecidos, mas confinado aos laborat\xc3\xb3rios universit\xc3\xa1rios, que havia criado. O esfor\xc3\xa7o de Berkeley tornou-se t\xc3\xa3o conhecido que acabou se tornando o nome de todo o conceito. Muitos na ind\xc3\xbastria de inform\xc3\xa1tica criticou que os benef\xc3\xadcios de desempenho foram pouco prov\xc3\xa1vel que se traduzem em ajustes do mundo real, devido \xc3\xa0 diminui\xc3\xa7\xc3\xa3o da efici\xc3\xaancia da mem\xc3\xb3ria de v\xc3\xa1rias instru\xc3\xa7\xc3\xb5es, e que essa foi a raz\xc3\xa3o que ningu\xc3\xa9m estava usando. Mas a partir de 1986, todos os projetos de pesquisa RISC come\xc3\xa7aram a entregar os produtos.\n_START_SECTION_\nRISC posterior\n_START_PARAGRAPH_\nA pesquisa de Berkeley n\xc3\xa3o estava diretamente comercializada, mas o projeto RISC-II foi usado pela Sun Microsystems para desenvolver o SPARC, pela Pyramid tecnologia para desenvolver sua linha de m\xc3\xa1quinas de gama m\xc3\xa9dia, multi-processador, e em quase todas as outras empresas, alguns anos depois. Foi o uso da Sun de um chip RISC em suas novas m\xc3\xa1quinas, que demonstrou que os benef\xc3\xadcios do RISC eram reais, e as suas m\xc3\xa1quinas rapidamente ultrapassou a concorr\xc3\xaancia e, essencialmente, assumiu o mercado de workstations inteiro._NEWLINE_John Hennessy deixou Stanford (temporariamente) para comercializar o projeto MIPS, come\xc3\xa7ando a companhia conhecida como MIPS Computer Systems. Seu primeiro projeto foi uma segunda gera\xc3\xa7\xc3\xa3o de chips MIPS conhecido como o R2000. projetos MIPS passou a se tornar um dos chips RISC mais utilizada quando foram inclu\xc3\xaddos na PlayStation e Nintendo 64 consoles de jogos. Hoje eles s\xc3\xa3o um dos processadores mais comuns embutidos em uso para aplica\xc3\xa7\xc3\xb5es high-end._NEWLINE_IBM aprendeu com o fracasso RT-PC e passou a projetar o RS/6000 com base na sua nova arquitetura POWER. Ela, ent\xc3\xa3o, mudou seu sistema AS/400 existentes para chips POWER, e encontrou para sua surpresa que, mesmo o conjunto de instru\xc3\xa7\xc3\xb5es muito complexas correu consideravelmente mais r\xc3\xa1pido. Power tamb\xc3\xa9m iria encontrar-se em movimento "para baixo" na escala para produzir o desenho PowerPC, o que elimina muitos dos "IBM apenas" instru\xc3\xa7\xc3\xb5es e criou uma aplica\xc3\xa7\xc3\xa3o de um \xc3\xbanico chip. Hoje, o PowerPC \xc3\xa9 um dos CPUs mais comumente usados para aplica\xc3\xa7\xc3\xb5es automotivas (alguns carros t\xc3\xaam mais de 10 deles no interior). Foi tamb\xc3\xa9m o CPU utilizado em m\xc3\xa1quinas Apple Macintosh 1994-2006. (A partir de fevereiro de 2006, a Apple mudou sua linha de produ\xc3\xa7\xc3\xa3o principal para processadores Intel x86)._NEWLINE_Quase todos os outros fabricantes rapidamente se juntou. Do Reino Unido esfor\xc3\xa7os de pesquisa, resultou na transputer INMOS, a Acorn Archimedes e do Advanced RISC Machine line, que \xc3\xa9 um enorme sucesso hoje. Empresas com projetos existentes CISC tamb\xc3\xa9m rapidamente se juntaram \xc3\xa0 revolu\xc3\xa7\xc3\xa3o. Intel lan\xc3\xa7ou o i860 e i960 pelo final dos anos 1980, embora n\xc3\xa3o tenham sido muito bem sucedida. Motorola construiu um novo projeto chamado de 88.000 em homenagem ao seu famoso CISC 68000, mas viu quase nenhum recurso, e, eventualmente, abandonou e se juntou a IBM para produzir o PowerPC. A AMD lan\xc3\xa7ou o seu 29000, que viria a se tornar o mais popular de projeto RISC do in\xc3\xadcio de 1990._NEWLINE_Hoje a grande maioria de todas as CPUs de 32 bits em uso s\xc3\xa3o CPUs RISC e microcontroladores. t\xc3\xa9cnicas de projeto RISC oferece pot\xc3\xaancia mesmo em tamanhos pequenos, e assim tornou-se dominante para a baixa pot\xc3\xaancia processadores de 32 bits. Sistemas embarcados s\xc3\xa3o, de longe o maior mercado de processadores: enquanto que uma fam\xc3\xadlia pode possuir um ou dois PCs, telefones de seu carro (s), celulares e outros dispositivos que podem conter um total de dezenas de processadores embarcados. RISC tamb\xc3\xa9m tinha tomado conta do mercado de esta\xc3\xa7\xc3\xb5es de trabalho maior para muito dos anos 90 (at\xc3\xa9 a retomada pelo baixo custo de solu\xc3\xa7\xc3\xb5es baseadas em PC). Ap\xc3\xb3s o lan\xc3\xa7amento do Sun SPARCstation os outros vendedores se apressaram para concorrer com solu\xc3\xa7\xc3\xb5es RISC pr\xc3\xb3pria. O mercado hoje servidor high-end \xc3\xa9 quase totalmente RISC , E o 1 \xc2\xba lugar entre os supercomputadores a partir de 2008 [atualiza\xc3\xa7\xc3\xa3o] \xc3\xa9 realizada pelo sistema da IBM Roadrunner, que usa processadores Power Architecture baseado Cell para oferecer parte de seu poder de computa\xc3\xa7\xc3\xa3o, embora muitos outros supercomputadores usam processadores x86 CISC vez.\n_START_SECTION_\nBenef\xc3\xadcios Decrescentes\n_START_PARAGRAPH_\nAo longo do tempo, as melhorias nas t\xc3\xa9cnicas de fabrica\xc3\xa7\xc3\xa3o de chips t\xc3\xaam melhorado o desempenho de forma exponencial, de acordo com a lei de Moore, enquanto melhorias na arquitetura foram relativamente pequenas. implementa\xc3\xa7\xc3\xb5es modernas CISC t\xc3\xaam implementado muitas das melhorias introduzidas pelo desempenho RISC, tais como transfer\xc3\xaancia de um \xc3\xbanico clock de instru\xc3\xa7\xc3\xb5es simples. Compiladores tamb\xc3\xa9m se tornaram mais sofisticados e s\xc3\xa3o mais capazes de explorar complexos, bem como as instru\xc3\xa7\xc3\xb5es simples sobre arquiteturas CISC, muitas vezes com cuidado otimizar tanto a sele\xc3\xa7\xc3\xa3o de instru\xc3\xa7\xc3\xa3o e da instru\xc3\xa7\xc3\xa3o e da aquisi\xc3\xa7\xc3\xa3o de dados em dutos e caches. A distin\xc3\xa7\xc3\xa3o RISC CISC borrou significativamente na pr\xc3\xa1tica.\n_START_SECTION_\nPr\xc3\xaamio Turing 2017\n_START_PARAGRAPH_\nOs pesquisadores John L. Hennessy e David A. Patterson foram laureados com o Pr\xc3\xaamio Turing 2017 devido \xc3\xa0 suas contribui\xc3\xa7\xc3\xb5es na \xc3\xa1rea de Arquitetura de computadores, especificamente por causa da pesquisa deles sobre a arquitetura RISC.'