1 / 38

Programmazione di un processore riconfigurabile Mario Toma

Programmazione di un processore riconfigurabile Mario Toma. Architettura. Estensione dell’Instruction Set. Register File. ….. pgaload ….. ….. ….. pgaop $3,$4,$5 …... …... Add $8, $3. Configuration Memory. 4x32-bit input data da Reg File 2x32-bit output data a Reg File. ….

lisbet
Télécharger la présentation

Programmazione di un processore riconfigurabile Mario Toma

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Programmazione di un processore riconfigurabile Mario Toma

  2. Architettura

  3. Estensione dell’Instruction Set Register File ….. pgaload ….. ….. ….. pgaop $3,$4,$5 …... …... Add $8, $3 Configuration Memory

  4. 4x32-bit input data da Reg File 2x32-bit output data a Reg File … PiCoGA Control Unit INPUT CONNECT BLOCK SWITCH BLOCK … … … … RLC INPUT LOGIC INPUT CONNECT BLOCK LUT 16x2 LUT 16x2 Configuration bus … 12 global lines to/from Reg File Loop-back OUTPUT CONNECT BLOCK OUTPUT LOGIC, REGISTERS EN … CARRY CHAIN PiCoGA control unit signals Descrizione della PiCo-Cell

  5. RLC: Schema a blocchi

  6. Blocco di gestione delle uscite Dalle LUT X[1:0] Y[1:0]

  7. Funzionalità di base di un RLC • Due funzioni logiche indipendenti, 4 ingressi e 2 uscite D A B C 2 2 2 2 • Esempio: 4 porte logiche elementari (AND,OR,XOR) INPUT LOGIC C1 C0 B0 D1 D0 B1 A1 A0 LUT 4:2 LUT 4:2 2 2 OUTPUT LOGIC Z3 Z2 Z1 Zo Z[3:2] Z[1:0]

  8. Funzionalità di base di un RLC • Una funzione con 4 ingressi e 4 uscite B A 2 2 • Esempio: moltiplicatore di operandi a 2 bit INPUT LOGIC B A 2 2 LUT 4:2 LUT 4:2 X 2 2 OUTPUT LOGIC 4 Z[3:2] Z[1:0] Z

  9. Funzionalità di base di un RLC • Una funzione con 5 ingressi e 2 uscite B A C 2 2 1 • Esempio: multiplexing tra coppie di bit INPUT LOGIC A B LUT 4:2 LUT 4:2 2 2 SEL 2 2 2 OUTPUT LOGIC Z Z[1:0]

  10. Funzionalità di base di un RLC • Una funzione con 6 ingressi e 1 uscita B A C1 C0 2 2 1 1 • Esempio: multiplexer 4:1 INPUT LOGIC B1 B0 A1 A0 LUT 4:2 LUT 4:2 C[1:0] 1 Z OUTPUT LOGIC Z

  11. Sommatore ad 8 bit • Prima LUT: calcolo della somma (ipotesi che carry-in=0) • Seconda LUT: calcolo del carry (con carry-in=0 e con carry-in=1) • Se carry-in=1 al risultato viene sommato 1 (a valle della LUT)

  12. Catena del carry Look-ahead: carry-out viene calcolato per entrambi i possibili valori di carry-in ingresso Operandi in ingresso LUT per il calcolo del carry-out In azzurro i blocchi utilizzati RLC omogenei, ma posizioni pari e dispari sono programmati diversamente Percorso critico

  13. Memoria • Memoria di 256 locazioni da 8 bit (256x8) • Utilizzate 3 righe del PiCoGA LUT 6:1 MUX 4:1

  14. Accumulatore • Cella elementare di un accumulatore A Feed-back interno all’RLC per evitare il ritardo introdotto dal routing 2 INPUT LOGIC LUT CARRY LUT SUM Registro contenente il risultato parziale (stato interno) 2 2 Carry-out Carry-in CARRY CHAIN + Come inizializzare lo stato interno? REG

  15. Inizializzazione stato interno • Si possono distinguere 4 modalità di inizializzazione, tutte supportate dal PiCoGA • Il segnale ‘INIT’ è generato dall’ Unità di Controllo

  16. Data in Data Flow Graph PiCoGAControlUnit Mapping Mapping Pga_op2 Data out Esecuzione Pipeline del PiCoGA Pga_op1

  17. Latenza ed Issue Delay • Latenza: tempo (in numero di cicli di clock) tra l’inizio di una pga-op e la produzione dei risultati • Issue delay: tempo minimo che deve intercorrere tra due pga-op consecutive • Latenza dipende dal percorso critico (Nodi 1-4-5-6 → Latenza = 4) • Issue delay dipende dalle dipendenze di dato. Es: nodo 3 non può elaborare per due cicli consecutivi (il suo risultato serve sia a 4 che a 5 in due cicli diversi). Issue delay = 2 1 2 3 4 5 6

  18. Func. 1 Func. 2 Func. 3 Func. 4 Func. n Region Partitioning Configuration Cache PiCoGA Attraverso l’istruzione di pga-load una configurazione viene caricata nel PiCoGA Funzioni caricate possono elaborare concorrentemente Le risorse del PiCoGA possono essere partizionate tra più funzioni

  19. Func. 1 Func. 2 Func. 3 Func. 4 Func. n Array multi-contesto PiCoGA Configuration Cache Mentre un piano esegue un altro viene riconfigurato → nessun overhead di riconfigurazione Region partitioning + multi-contesto → fino a 16 pga-op memorizzabili nel PiCoGA 4 “piani” di configurazione memorizzati nel PiCoGA, uno dei quali elabora 1 ciclo di clock per passare da un piano all’altro

  20. Sorgente C Profiling Estrazione dei kernel duri Configurazione PiCoGA Simulazione software Codice eseguibile Metodologia di Sviluppo Algoritmi

  21. File.exe ASSEMBLER SCHEDULER C COMPILER LINKER ASSEMBLER File.c SOFTWARE SIMULATOR PROFILER Compilazione per XiRisc • Tool software per generare l’eseguibile per XiRisc • Profiler: tool per stimare i tempi di esecuzione

  22. Profiling • Si visualizza il numero di cicli di esecuzione associati ad ogni riga di codice C

  23. Descrizione di una Pga-op • Problema: descrivere come programmare le RLC e le interconnessioni • Obiettivo: descrizione ad alto livello, che non richieda una conoscenza dettagliata dell’hardware • Soluzione: si utilizza un linguaggio pseudo-C, il Griffy-C • Sintassi compatibile con ANSI-C • Operatori C (somma, shift) corrispondono a configurazioni hardware

  24. Linguaggio C semplificato: Corrispondenza fra istruzione C ed elemento di libreria (modulo) istanziato Estensioni al linguaggio C: Supporto variabili di dimensioni non standard Supporto flag di overflow Possibilità di definire tabelle di verità (LUT) Griffy-C

  25. - - MUX Dal Griffy-C al Mapping #pragma fpga differenza_assoluta 0x11 4 1 2 dataout datain1 datain2 { unsigned char diff1, diff2; char cond; #pragma attrib cond SIZE=1 diff1 = datain1 - datain2; diff2 = datain2 - datain1;cond = diff1 < 0; dataout = cond ? diff2 : diff1;} #pragma end

  26. Codice di riferimento …. char RowA[64], RowB[64]; …. for(i=0;i<16;i++) { if(MEM[i]>0) for(j=4*i;j<4*(i+1);j++) { a=RowA[j]; b=RowB[j]; dif=a-b; acc+=dif; } else for(j=4*i;j<4*(i+1);j++) { a=RowA[j]; b=RowB[j]; m=a+b/2; if (m>max) max=m; } } Esempio Codice per XiRisc …. unsigned long RowA[16], RowB[16]; …. for(i=0;i<16;i++) { if(MEM[i]>0) pgaop1(RowA[i],RowB[i],acc); else pgaop2(RowA[i],RowB[i],max); }

  27. Codice di riferimento char RowA[64], RowB[64]; 1 acc=0; 1 max=0; 184 for(i=0;i<16;i++) { 176 if(MEM[i]>0) 0 for(j=4*i;j<4*(i+1);j++) { 0a=RowA[j]; 0 b=RowB[j]; 0 dif=a-b; 0 acc+=dif; } 0 else 1296 for(j=4*i;j<4*(i+1);j++) { 512 a=RowA[j]; 512 b=RowB[j]; 576 m=a+b/2; 384 if (m>max) max=m; } 0 } Esempio: Profiling • Codice per XiRisc • unsigned long RowA[16], RowB[16]; • acc=0; • 1 max=0; • 184 for(i=0;i<16;i++) { • 176 if(MEM[i]>0) • 0 pgaop1(RowA[i],RowB[i],acc); • 0 else • 304 pgaop2(RowA[i],RowB[i],max); • } Totale: 3649 cicli Totale: 673 cicli Speed-up: 5.4x

  28. Pga-op1: Mapping • Si sfruttano parallelismo e pipelining • Latenza: 4 • Issue delay: 1

  29. Pga-op2: Mapping • Latenza: 6 • Issue delay:3 • Occupazione: • 6 righe • 40 RLC

  30. Pga-op2: Mapping ottimizzato • Latenza: 6 • Issue delay:1 • Occupazione: • 6 righe • 56 RLC

  31. DES(Data encryption Standard) Algoritmo con operazioni bit-level Processori tradizionali poco efficienti Funzione non-lineare f mappabile su PiCoGA

  32. DES: Round f La chiave è unica durante la cifratura. Possono essere precalcolate le 16 chiavi utilizzate ad ogni round Riordinamento di bit: non coinvolge gli RLC ma solo il routing 8 tabelle di sostituzione (64 entry da 8 bit) Implementabile con 64 RLC

  33. DES: Data Flow Graph

  34. DES: Mapping • Espansione e permutazione iniziale eseguita dal routing • Permutazione finale richiede una riga • 4 righe, latenza=3 cicli, issue delay=1 ciclo

  35. DES: Codice C unsigned long key_sp[8][64]; unsigned long f(unsigned long r, char *subkey) { unsigned long *spp; unsigned long rval, rt; int er; subkey += 7; er = ((int) r << 1) | ((r & 0x80000000) ? 1 : 0); spp = &key_sp[7][0]; rt = (unsigned long) r >> 3; rval |= spp[((int) rt ^ *subkey--) & 0x3f]; spp -= 64; ….. spp -= 64; rt >>= 4; rval |= spp[((int) rt ^ *subkey--) & 0x3f]; spp -= 64; rt >>= 4; rt |= (r & 1) << 5; rval |= spp[((int) rt ^ *subkey) & 0x3f]; return rval; } • Routine si traduce con 106 instruzioni assembler (RISC) • Mappabile con una sola pga-op • Nessuna corrispondenza diretta tra codice C e Data Flow Graph

  36. Esercizio • Realizzazione di un sommatore di 8 elementi, ciascuno rappresentato da 8 bit, sull'architettura riconfigurabile XiRisc. • Scrivere il codice C relativo all'implementazione tradizionale (puramente software) • Effettuare mapping su PiCoGA del sommatore, stimando la latenza • Riscrivere il codice C con l'opportuno inserimento delle pga-op • Fornire una stima dello speed-up ottenibile • Ipotesi semplificativa: • Non considerare l'overflow sui risultati intermedi

  37. Soluzione software { char a[8]; char sum,sum1,sum2,sum3; char sum4, sum5, sum6; sum1=a[0]+a[1]; sum2=a[2]+a[3]; sum3=a[4]+a[5]; sum4=a[6]+a[7]; sum5=sum1+sum2; sum6=sum3+sum4; sum=sum5+sum6; } Soluzione esercizio: Codici C Soluzione su XiRisc { char a[8]; char sum; pga-op( (int) sum, ((int *)a)[0], ((int *)a)[1]); }

  38. Soluzione esercizio: mapping

More Related