b'\n_START_ARTICLE_\nReduced instruction set computer\n_START_PARAGRAPH_\nReduced Instruction Set Computer (in acronimo RISC), nell\'elettronica digitale, indica un\'idea di progettazione di architetture per microprocessori che predilige lo sviluppo di un\'architettura semplice e lineare. Questa semplicit\xc3\xa0 di progettazione permette di realizzare microprocessori in grado di eseguire il set di istruzioni in tempi minori rispetto a una architettura CISC._NEWLINE_I pi\xc3\xb9 comuni processori RISC sono: AVR, PIC, ARM, DEC Alpha, PA-RISC, SPARC, MIPS, POWER e PowerPC.\n_START_SECTION_\nFilosofia di progetto RISC\n_START_PARAGRAPH_\nVerso la fine degli anni settanta ricercatori dell\'IBM (e di progetti analoghi) dimostrarono che la maggior parte dei modi di indirizzamento non venivano utilizzate nei programmi. Questo era dovuto alla diffusione dei compilatori che, sostituendosi all\'ottimizzazione a basso livello applicata dai programmatori, ignoravano i modi di indirizzamento pi\xc3\xb9 potenti per concentrarsi su quelli semplici. I compilatori di allora erano in grado di gestire solo le caratteristiche pi\xc3\xb9 semplici dei processori anche perch\xc3\xa9 allora la teoria dei compilatori era solo agli inizi. Comunque il mercato si stava muovendo con rapidit\xc3\xa0 verso l\'utilizzo sempre pi\xc3\xb9 massiccio dei compilatori, dato che i linguaggi ad alto livello permettevano di realizzare programmi con rapidit\xc3\xa0 riusando il codice in modo efficiente._NEWLINE_Gli studi dimostrarono che molte istruzioni esotiche venivano utilizzate molto raramente e a volte erano pi\xc3\xb9 lente del codice scritto con le istruzioni generiche. L\'esempio classico era l\'istruzione INDEX dei VAX: questa istruzione era pi\xc3\xb9 lenta di un loop implementato con le istruzioni comuni._NEWLINE_In quel periodo la velocit\xc3\xa0 delle CPU e delle memorie era simile, ma era evidente l\'incremento di velocit\xc3\xa0 dei processori e pertanto in futuro si avrebbe avuto un divario sempre maggiore tra la velocit\xc3\xa0 dei processori e il tempo di accesso delle memorie. Per ridurre il problema i progettisti pensarono di includere pi\xc3\xb9 registri e cache nei processori in modo da ridurre gli accessi alla memoria; i registri e la cache richiedevano molto spazio e allora si cerc\xc3\xb2 di recuperare spazio riducendo la complessit\xc3\xa0 dei processori._NEWLINE_Studi effettuati da informatici come Andrew Tanenbaum dimostrarono che le CPU prodotte allora erano molto sovradimensionate rispetto alle reali esigenze dei programmi. Tanenbaum dimostr\xc3\xb2 che il 98% delle costanti in un programma poteva essere memorizzato con parole di 13 bit sebbene la maggior parte delle CPU utilizzasse parole a multipli di 8 bit (8/16/24 ecc.) e quindi sprecassero spazio. Questi studi suggerirono di memorizzare le costanti nei bit non utilizzati del set di istruzioni, riducendo il numero degli accessi alla memoria; le costanti non verrebbero caricate dalla memoria o dai registri ma sarebbero state inglobate direttamente nel codice binario dell\'istruzione rendendo la CPU pi\xc3\xb9 veloce ed efficiente. Tuttavia questo approccio richiedeva istruzioni con codifiche corte e una lunghezza di parola di almeno 32 bit per poter aver a disposizione uno spazio ragionevole per le costanti._NEWLINE_Dato che nelle applicazioni reali la maggior parte del tempo viene dedicata all\'esecuzione di operazioni molto semplici, i ricercatori si concentrarono su queste operazioni comuni cercando di rendere la loro esecuzione il pi\xc3\xb9 veloce possibile. Visto che la massima velocit\xc3\xa0 di funzionamento delle unit\xc3\xa0 era limitata dal tempo necessario ad eseguire le istruzioni pi\xc3\xb9 lente e i modi di indirizzamento pi\xc3\xb9 esotici, si decise di eliminare le istruzioni e i modi di indirizzamento poco usati in modo da ottenere un set di istruzioni pi\xc3\xb9 snello contenente solo quelle istruzioni che effettivamente venivano richieste e che potevano essere ottimizzate per essere eseguite rapidamente, spesso in un solo ciclo di clock._NEWLINE_L\'obiettivo di ridurre le istruzioni port\xc3\xb2 alla creazione del nome Reduced Instruction Set Computing (elaborazione con set di istruzioni ridotto): un numero ridotto di istruzioni con metodi di accesso semplici e lineari che permetteva l\'utilizzo di soluzioni di tipo pipeline. L\'utilizzo di pipeline permette di realizzare microprocessori in grado di eseguire la maggior parte delle istruzioni in un ciclo di clock. In un\'architettura CISC \xc3\xa8 molto pi\xc3\xb9 difficile includere una pipeline dato che i molteplici metodi di indirizzamento complicano nettamente il funzionamento dell\'unit\xc3\xa0 e perci\xc3\xb2 a parit\xc3\xa0 di potenza di calcolo, un\'architettura CISC a pipeline richiede molti pi\xc3\xb9 transistor di una architettura RISC a pipeline._NEWLINE_L\'acronimo RISC ha portato spesso dei fraintendimenti. Molti leggendo "set di istruzioni ridotti" pensarono a un set di istruzioni menomato, inadeguato a  eseguire con semplicit\xc3\xa0 programmi complessi. Invece i processori RISC moderni sono spesso dotati di un set di istruzioni molto completo, ma non forniscono metodi di indirizzamento esotici o istruzioni utilizzate raramente. Ispirati dalla filosofia RISC, sono state sviluppate macchine basate su set di istruzioni minimali come le MISC, le OISC e le Transport Triggered Architectures, mentre alcune ricerche si sono mosse verso il Turing tarpit._NEWLINE_L\'approccio RISC ha il grande vantaggio della velocit\xc3\xa0 ma il suo principale svantaggio \xc3\xa8 l\'occupazione di memoria da parte del codice. Essendo presenti solo istruzioni relativamente semplici, il codice scritto per macchine RISC tende ad essere pi\xc3\xb9 grande del codice scritto per macchine CISC.\n_START_SECTION_\nPrimi RISC\n_START_PARAGRAPH_\nIl primo sistema al mondo che si pu\xc3\xb2 ritenere aderire alla filosofia RISC fu il supercomputer CDC 6600 sviluppato nel 1964 da Jim Thornton e Seymour Cray._NEWLINE_Thornton e Cray progettarono una CPU specializzata per eseguire calcoli (dotata di 74 opcode, un numero nemmeno paragonabile alle 400 opcode dell\'Intel 8086) e 10 processori periferici dedicati alla gestione dell\'I/O. Il CDC 6600 \xc3\xa8 dotato di un\'architettura load/store con solo due metodi di accesso. Il computer aveva 10 unit\xc3\xa0 funzionali aritmetiche/logiche pi\xc3\xb9 cinque unit\xc3\xa0 dedicate al caricamento e al salvataggio dei dati. La memoria era suddivisa in pi\xc3\xb9 banchi in modo da consentire alle unit\xc3\xa0 load/store di funzionare in parallelo. Il clock del processore era dieci volte il clock della memoria._NEWLINE_Un\'altra delle prime macchine load/store fu il minicomputer Data General Nova sviluppato nel 1968._NEWLINE_I progetti che portarono alle prime architetture che esplicitarono il concetto di processore RISC, comunque, furono svolti in seno alle universit\xc3\xa0 statunitensi che, utilizzando i fondi forniti dal DARPA per il programma VLSI, svilupparono molte innovazioni nel campo dell\'elettronica e della miniaturizzazione._NEWLINE_Il progetto Berkeley RISC inizi\xc3\xb2 nel 1980 sotto la direzione di David Patterson. Il progetto mirava ad ottenere elevate prestazioni tramite l\'uso di pipeline e di molti registri gestiti con la tecnica della register window. In una normale CPU vi erano un numero ridotto di registri (8 o 16 era un numero comune) che erano accessibili a tutto il programma. Nella CPU progettata dal gruppo di Patterson i registri erano 128, ma il programma poteva accedere in ogni momento solamente a 8 di questi. Questa organizzazione permetteva di realizzare delle chiamate di sistema o dei cambi di contesto molto rapidi. In una CPU classica una chiamata di sistema imponeva al processore di salvare i registri in memoria per permettere alla procedura di avere i registri liberi; nella CPU di Patterson basta spostare l\'indice della finestra per ottenere dei registri liberi senza salvare niente in memoria velocizzando notevolmente il tutto._NEWLINE_Il progetto RISC svilupp\xc3\xb2 il processore RISC-I nel 1982. Il processore era formato da 44.420 transistor, pochi rispetto agli oltre 100.000 utilizzati da alcuni CISC dell\'epoca. Il RISC-I era dotato di sole 32 istruzioni, ma era pi\xc3\xb9 veloce di qualsiasi processore a singolo chip dell\'epoca. Il suo successore, il RISC-II (1983), era addirittura pi\xc3\xb9 piccolo, aveva solo 40.760 transistor, 39 istruzioni ed era tre volte pi\xc3\xb9 rapido del RISC-I._NEWLINE_Nello stesso periodo John L. Hennessy inizi\xc3\xb2 un progetto simile chiamato MIPS alla Stanford University nel 1981. Il progetto MIPS si concentrava sul realizzare un processore ove la pipeline fosse sempre operativa. La pipeline era gi\xc3\xa0 in uso allora su alcuni processori, ma il progetto MIPS svilupp\xc3\xb2 molte soluzioni che sono diventate di uso comune. Per ottenere una pipeline sempre piena era necessario garantire che le operazioni fossero sempre completate in un solo ciclo di clock da tutte le unit\xc3\xa0 funzionali, quindi i progettisti decisero di eliminare dal processore tutte le istruzioni troppo lente anche se utili. Ad esempio il processore MIPS non prevedeva operazioni di moltiplicazione o divisione._NEWLINE_Il primo progetto di produrre una CPU su un singolo chip lo si deve all\'IBM, che nel 1975 inizi\xc3\xb2 un progetto che fu di ispirazione per i gruppi successivi. Il progetto di ricerca ha portato allo sviluppo del processore IBM 801. L\'801 venne prodotto su singolo chip nel 1981 con il nome di ROMP, un acronimo che indica Research (Office Products Division) Mini Processor. Come dice il nome, la CPU era progettata per svolgere compiti d\'ufficio; nel 1986 l\'IBM present\xc3\xb2 l\'IBM RT che non ebbe successo per le prestazioni non all\'altezza delle aspettative. Nonostante tutto il progetto 801 ispir\xc3\xb2 molti altri progetti di ricerca, incluso il progetto POWER della stessa IBM._NEWLINE_Durante quegli anni i lavori sulle architetture RISC erano molto diffusi all\'interno dei centri di ricerca. Il progetto svolto a Berkeley era talmente importante che spesso veniva utilizzato come sinonimo dell\'intero paradigma RISC. Molte aziende erano inizialmente restie a investire sull\'architettura RISC, dato che in un prodotto commerciale la ridotta efficienza della memoria avrebbe potuto compromettere le prestazioni dei processori. Comunque, nonostante alcune difficolt\xc3\xa0 iniziali, nel 1986 tutti i progetti RISC erano diventati prodotti commerciali e non si pu\xc3\xb2 negare che tutti i moderni processori RISC debbano molto al progetto del RISC-II.\n_START_SECTION_\nDescrizione\n_START_PARAGRAPH_\nL\'architettura RISC prevede un set esteso di istruzioni con metodi di indirizzamento complessi. Una definizione semplicistica dei microprocessori RISC parla di microprocessori con un set di istruzioni ridotto (semplificato) rispetto a quello dei classici processori CISC. La definizione attualmente pi\xc3\xb9 diffusa in ambito informatico parla di architettura load-store dato che le architetture RISC permettono di accedere alla memoria unicamente tramite delle istruzioni specifiche (load e store) che provvedono a leggere e scrivere i dati nei registri del microprocessore, mentre tutte le altre istruzioni manipolano i dati contenuti all\'interno dei microprocessori. Nei microprocessori CISC \xc3\xa8 l\'esatto opposto, praticamente tutte le istruzioni possono accedere ai registri o alla memoria utilizzando metodi di accesso anche molto sofisticati._NEWLINE_L\'idea che ha ispirato questa architettura \xc3\xa8 la constatazione che i progettisti hardware impiegavano molte risorse e molto tempo per realizzare metodi di accesso molto potenti che i programmatori in realt\xc3\xa0 ignoravano. Gli sviluppatori e i compilatori infatti tendevano a utilizzare le istruzioni e i metodi di indirizzamento pi\xc3\xb9 semplici ignorando tutti gli altri metodi e le istruzioni specializzate. Inoltre negli anni ottanta il divario tra la velocit\xc3\xa0 dei processori e delle memorie aumentava, perci\xc3\xb2 i progettisti iniziarono a studiare tecnologie che riducessero gli accessi alla memoria e aumentassero la velocit\xc3\xa0 dei processori; tuttavia queste tecnologie erano molto difficili da implementare con metodi di accesso alla memoria complessi.'