{"id":148,"date":"2009-01-10T03:40:55","date_gmt":"2009-01-10T02:40:55","guid":{"rendered":"http:\/\/www.oscene.net\/site\/?p=148"},"modified":"2009-01-10T03:40:55","modified_gmt":"2009-01-10T02:40:55","slug":"come-funziona-un-processore-arm","status":"publish","type":"post","link":"https:\/\/www.oscene.net\/it\/come-funziona\/come-funziona-un-processore-arm","title":{"rendered":"Come funziona un processore ARM"},"content":{"rendered":"

Introduzione<\/h3>\n

Le CPU con architettura ARM sono utilizzate in milioni di dispositivi embedded, come microcontrollori, router, schede wifi, telefoni cellulari, smartphones, palmari, console portatili (GameBoy Advance, Nintendo DS), lettori DVD\/DivX, lettori MP3\/MP4 e tanti altri…<\/p>\n

Per brevit\u00c3\u00a0 indicher\u00c3\u00b2 con ARM tutta la categoria, evitando di specificare ogni volta il tipo di processore, nonostante questa terminologia non sia corretta in tutti i casi. Infatti con il termine ARM si identificano tante cose, tra cui l’azienda che detiene i brevetti, il nome della microarchitettura, il nome del set di istruzioni a 32 bit.<\/p>\n

I processori ARM si differenziano dai pi\u00c3\u00b9 noti x86 (nda. i classici processori per PC) per diverse caratteristiche.<\/p>\n

Innanzitutto, la grossa distinzione \u00c3\u00a8 data dal tipo di architettura interna: i processori ARM sono di tipo RISC, mentre i processori x86 sono di tipo CISC. Rimando a Wikipedia per una descrizione dettagliata delle differenze tra i due tipi di architettura. Per i nostri scopi basta soltanto porre l’accento sul fatto che i processori di tipo RISC tendono a implementare istruzioni molto semplici, ma che vengono eseguite ad altissima velocit\u00c3\u00a0 (tipicamente 1 solo ciclo di clock), mentre i processori CISC generalmente implementano una vasta gamma di istruzioni complesse che richiedono anche diverse decine di cicli di clock per essere eseguite. Queste istruzioni complesse in genere servono a facilitare \u00c2\u00a0il compito del programmatore di compilatori, a discapito dell’efficienza e della semplicit\u00c3\u00a0 interna del chip.<\/p>\n

<\/p>\n

Caratteristiche generali<\/h3>\n

Set di istruzioni ortogonale<\/h4>\n

I processori ARM dispongono di 31 registri interni, ma in ogni momento sono visibili solo 16 di questi, che vengono selezionati in base alla modalit\u00c3\u00a0 di funzionamento (modalit\u00c3\u00a0 Utente, modalit\u00c3\u00a0 Interrupt, modalit\u00c3\u00a0 System, ecc…). Ciascuno di questi registri pu\u00c3\u00b2 essere utilizzato indifferentemente come registro sorgente o come registro destinazione di qualunque istruzione. Ad esempio \u00c3\u00a8 possibile eseguire una somma del contenuto dei registri 3 e 4 e inserire il risultato nel registro 2 in questo modo:<\/p>\n

add r2, r3, r4<\/pre>\n
Questa flessibilit\u00c3\u00a0 nell’uso dei registri consente la scrittura di programmi molto compatti. Infatti, a differenza di molte architetture CISC nelle quali ogni calcolo avviene su un singolo registro detto accumulatore<\/a>, il cuore delle architetture RISC, come quella ARM, risiede proprio nell’ortogonalit\u00c3\u00a0 del set di istruzioni<\/strong> che, seppur ridotto e semplificato, espone un’ampia flessibilit\u00c3\u00a0 al programmatore Assembly.\u00c2\u00a0<\/p>\n
Esecuzione condizionata<\/h4>\n
Un’altra caratteristica molto apprezzata dei processori ARM risiede nella cosiddetta esecuzione condizionata<\/strong>. Quasi tutte le istruzioni dei processori ARM possono essere accompagnate da un codice di controllo, chiamato condition code<\/strong>, che modifica l’esecuzione dell’istruzione alla quale viene applicato. L’utilit\u00c3\u00a0 dell’esecuzione condizionata si nota immediatamente esaminando questo frammento di codice:<\/p>\n
\/\/ Codice C\nif (a < b)\n{\n        a = a + b;\n}\nelse\n{\n        a = a - b;\n}<\/pre>\n
che in Assembly diventa:<\/p>\n
cmp Ra, Rb          ; confronta le due variabili\n                    ; settando dei flags interni\n                    ; in base al risultato\naddlt Ra, Ra, Rb    ; esegue la somma se LT (Less than)\nsubge Ra, Ra, Rb    ; esegue la sottrazione se GE (greater or equal)<\/pre>\n
da notare come in questo pezzo di codice non siano presenti salti, che invece sarebbero necessari per indirizzare il flusso di programma verso i rami di codice corretti, nel caso in cui mancasse la possibilit\u00c3\u00a0 di effettuare istruzioni condizionate.<\/p>\n
In questo esempio \u00c2\u00a0si mostra come in soli 3 cicli di clock l’architettura sia in grado di eseguire un confronto, un’operazione di somma e un’assegnazione…\u00c2\u00a0<\/p>\n
Il Barrel Shifter<\/h4>\n
Supponiamo di dover scrivere un pezzo di codice che esegua questa operazione:<\/p>\n
a = b + c \/ 32;<\/pre>\n
In questo caso dobbiamo effettuare una divisione per 32 (che corrisponde ad uno shift aritmetico a destra di 5 bit), una somma e un’assegnazione. In teoria sarebbero 3 istruzioni separate, ma grazie alla potenza dell’architettura ARM riusciamo a scrivere tutto questo in una sola istruzione, che viene eseguita in 1 singolo ciclo di clock, vediamo come:<\/p>\n
add Ra, Rb, Rc ASR#5    ; ASR sta per Arithmetic Shift Right\n                        ; #5 \u00c3\u00a8 il numero di bit per lo shift<\/pre>\n
Le estensioni DSP<\/h3>\n
Operazioni con saturazione<\/h4>\n
I processori ARM dalla versione ARMv5e in poi (come l’ARM946E-S presente nel Nintendo DS, in alcuni lettori MP3 Samsung e in moltissimi altri dispositivi) contengono alcune istruzioni votate al signal processing. Sono istruzioni che includono un controllo sulla saturazione del risultato e risultano molto utili nelle applicazioni multimediali come ad esempio mixer digitali, decoder MP3, filtri grafici come alpha blending, ecc…<\/p>\n
Ad esempio il seguente frammento di codice in C:<\/p>\n
a = b + c;\nif (a > MAXINT)\n{\n    a = MAXINT;\n}<\/pre>\n
viene reso in Assembly dalla singola istruzione:<\/p>\n
qadd Ra, Rb, Rc<\/pre>\n
Istruzioni SIMD<\/h4>\n
Processori pi\u00c3\u00b9 recenti, dalla versione ARMv6 in poi, inoltre hanno delle istruzioni ancora pi\u00c3\u00b9 potenti che risultano estremamente utili quando si lavora con immagini e suoni. Supponiamo ad esempio di dover implementare un filtro grafico che calcoli la somma dei valori RGBA tra 2 pixel (un esempio simile si potrebbe fare nel caso di un filtro audio digitale che debba mixare diverse sorgenti audio su un sistema multitraccia).
\nI dati di colore ci vengono presentati sotto forma di numeri interi a 32 bit, strutturati in questo modo:<\/p>\n
bit 0-7: canale R
\nbit 8-15: canale G
\nbit 16-23: canale B
\nbit 24-31: canale Alpha<\/p>\n
In C scriveremmo qualcosa del genere (per chi non avesse padronanza con gli operatori binari<\/a>, si rimanda al relativo articolo):<\/p>\n
int R,G,B,A;   \/\/ risultato\nint destinazione;\nint R1, R2, G1, G2, B1, B2, A1, A2; \/\/ operandi\nint colore1, colore2;\n\n\/\/ estraggo i canali dal primo pixel\nR1 = (colore1 & 0x000000FF) >> 0;\nG1 = (colore1 & 0x0000FF00) >> 8;\nB1 = (colore1 & 0x00FF0000) >> 16;\nA1 = (colore1 & 0xFF000000) >> 24;\n\n\/\/ estraggo i canali dal secondo pixel\nR2 = (colore2 & 0x000000FF) >> 0;\nG2 = (colore2 & 0x0000FF00) >> 8;\nB2 = (colore2 & 0x00FF0000) >> 16;\nA2 = (colore2 & 0xFF000000) >> 24;\n\n\/\/ calcolo il risultato\nR = R1 + R2;\nif (R > 255) R = 255; \/\/ il massimo valore consentito \u00c3\u00a8 255 per canale\nG = G1 + G2;\nif (G > 255) G = 255;\nB = B1 + B2;\nif (B > 255) B = 255;\nA = A1 + A2;\nif (A > 255) A = 255;\n\n\/\/ impacchetto nuovamente i canali nel pixel di destinazione\ndestinazione = (A << 24) | (B << 16) | (G << 8 ) | (R << 0);<\/pre>\n
Queste 16 righe di codice (che in realt\u00c3\u00a0 corrispondono a circa una quarantina di operazioni elementari), possono essere rese incredibilmente compatte in ARM:<\/p>\n
uqadd8 Rrisultato, Rcolore1, Rcolore2<\/pre>\n
questo calcolo estremamente complesso viene eseguito dal processore in un singolo ciclo di clock<\/strong>… sembra incredibile? \ud83d\ude42<\/p>\n
L’istruzione UQADD8 sostanzialmente effettua 4 somme da 8 bit in parallelo, una somma per ogni byte dei registri in ingresso, saturando i risultati al limite massimo per gli interi senza segno a 8 bit (cio\u00c3\u00a8 da 0 a +255). Esiste anche la variante QADD8 che effettua la saturazione con segno (quindi da -128 a +127)<\/p>\n
Multiply Accumulate<\/h4>\n
Un altro esempio di istruzione DSP-like \u00c3\u00a8 l’istruzione MLA (Multiply and Accumulate). Questa istruzione viene pesantemente utilizzata nei motori di rendering 3D e in numerose altre applicazioni che richiedono il calcolo di espressioni polinomiali della forma Y = A1 * X1 + A2 * X2 + … + An * Xn. Queste operazioni sono estremamente comuni quando si trattano vettori e matrici (un esempio classico \u00c3\u00a8 il calcolo di una matrice inversa o il calcolo di un prodotto scalare tra 2 vettori).<\/p>\n
Ad esempio questo frammento di codice in C:<\/p>\n
y = a1 * x1\u00c2\u00a0+ a2 * x2 + a3 * x3;<\/pre>\n
viene reso in Assembly da queste poche istruzioni<\/p>\n
mul R0, R1, R4\nmla R7, R2, R5, R0\nmla R0, R3, R6, R7<\/pre>\n
L’istruzione MUL \u00c3\u00a8 una normale istruzione di moltiplicazione, ciascuna delle istruzioni MLA successive eseguono il prodotto di due registri e sommano il risultato al contenuto del registro specificato nel primo parametro. Da notare come sia possibile specificare uno qualsiasi dei registri da R1 a R15 come parametri, i registri R13, R14 ed R15 sono utilizzati come registri speciali, rispettivamente come Stack Pointer<\/strong>, Link Register <\/strong>e Program Counter<\/strong>, quindi il loro utilizzo deve essere regolato in modo molto attento.<\/p>\n
Obiettivo: 1 istruzione \/ ciclo macchina<\/h3>\n
Spulciando i reference documents di ARM ci si accorge di un dettaglio importante: molte delle istruzioni pi\u00c3\u00b9 complesse (come le istruzioni Multiply-Accumulate) impiegano un certo numero di cicli di clock per essere eseguite (nel caso specifico l’istruzione MLA impiega 3 cicli macchina sul core ARM9E-S<\/strong>, pu\u00c3\u00b2 variare in altre implementazioni) ma, grazie a particolari tecniche, \u00c3\u00a8 possibile avvicinarsi al valore medio di 1 istruzione per ogni ciclo macchina.
\nCom’\u00c3\u00a8 possibile?<\/p>\n
Questo traguardo viene raggiunto tramite l’organizzazione interna dell’architettura, che si suddivide in subunit\u00c3\u00a0 funzionali costituendo una cosiddetta pipeline di esecuzione. Esistono diverse possibili implementazioni della pipeline, ne mostriamo una soltanto a titolo esemplificativo:<\/p>\n
\u00c2\u00a0<\/p>\n
\"5<\/a>
5 stage pipeline<\/p><\/div>\n
\u00c2\u00a0<\/p>\n
\u00c2\u00a0<\/p>\n
Le 5 fasi (stage) della pipeline sono: Fetch, Decode, Execute, Memory, Write.<\/p>\n