OpenCL nel Trading - pagina 5

[MetaQuotes]

6. Superscalare e VLIW

6. Superscalare e VLIW

Il video esplora il modo in cui i processori utilizzano l'esecuzione superscalare per rilevare ed estrarre il parallelismo tra le istruzioni binarie per migliorare le prestazioni. Discute l'importanza della logica di controllo nell'identificare i casi in cui le istruzioni possono essere eseguite simultaneamente, ad esempio con una mancanza di dipendenze tra di loro. Il video introduce anche due esempi di design del processore, superscalare e VLIW, con quest'ultimo che sposta la responsabilità di rilevare le dipendenze ai compilatori, generando lunghe istruzioni da eseguire in parallelo. Sebbene VLIW riduca il controllo del tempo di esecuzione, i punti inutilizzati nella lunga parola dell'istruzione possono comunque causare uno spreco nell'unità di esecuzione.

• 00:00:00 In questa sezione, il video spiega come i processori utilizzano l'esecuzione superscalare per migliorare le prestazioni complessive nei programmi con istruzioni binarie. I programmatori si affidano a processori ben progettati per eseguire correttamente i loro programmi, quindi la responsabilità ricade sul processore per identificare ed estrarre il parallelismo dalle istruzioni per aumentare le prestazioni. Il video fornisce un esempio di un grafico delle dipendenze tra istruzioni e, sebbene esistano dipendenze tra determinate istruzioni, i processori possono eseguirne altre contemporaneamente a causa della mancanza di dipendenze tra di esse. È compito della logica di controllo all'interno del processore identificare queste istanze ed eseguire le istruzioni nel modo più efficiente possibile per massimizzare le prestazioni.
  
  
• 00:05:00 In questa sezione, il video discute due esempi di progetti architetturali nei processori: superscalare e VLIW. Il primo esempio mostra come il processore può rilevare le dipendenze tra le istruzioni e programmarle di conseguenza per risparmiare tempo. Il video evidenzia anche la possibilità di esecuzione speculativa per istruzioni di filiale. Il secondo esempio discute il progetto VLIW, che sposta la responsabilità di rilevare le dipendenze ai compilatori. Il compilatore genera lunghe parole di istruzione comprendenti più istruzioni che possono essere eseguite in parallelo, semplificando la progettazione del processore.
  
  
• 00:10:00 In questa sezione viene spiegato il concetto di parola di istruzione molto lunga (VLIW). Ciò consente di raggruppare più istruzioni in una lunga parola di istruzione, che viene recuperata e decodificata insieme. Il VLIW trasferisce la responsabilità ai compilatori di scoprire opportunità per l'esecuzione di istruzioni contemporaneamente prima che il programma venga eseguito e riduce la necessità di controlli di runtime. Tuttavia, se ci sono punti vuoti nella lunga parola di istruzione, l'unità di esecuzione potrebbe comunque subire degli sprechi.

[MetaQuotes]

7. SIMD e multithreading hardware

7. SIMD e multithreading hardware

Il video spiega due modi per affrontare le sfide del parallelismo: Single Instruction, Multiple Data (SIMD) e hardware multithreading (SMT). SIMD consente alle istruzioni hardware di essere eseguite in parallelo su più elementi di dati, semplificando la programmazione e la logica di decodifica. SMT sfrutta il parallelismo a livello di thread eseguendo contemporaneamente flussi di istruzioni indipendenti, richiedendo file di registro aggiuntivi e un'attenta condivisione della cache. Il video illustra anche l'implementazione della pianificazione dei thread con suddivisione temporale, in cui i thread occupano a turno il percorso dati del processore in modalità round-robin, riducendo la latenza e consentendo a più thread di accedere contemporaneamente a unità di calcolo e sistemi di memoria. In definitiva, il processore può ospitare tutti i thread necessari, anche se l'aumento delle prestazioni potrebbe non essere così significativo su un processore a thread singolo.

• 00:00:00 In questa sezione viene spiegato il concetto di SIMD (Single Instruction Multiple Data), in cui le istruzioni hardware possono essere utilizzate per l'esecuzione parallela di operazioni su più elementi di dati. SIMD semplifica la programmazione e la logica di decodifica, in quanto è sufficiente programmare un'unica istruzione per applicare la stessa operazione a ogni elemento dei dati. L'uso di SIMD è vantaggioso se il problema da risolvere comporta un significativo parallelismo dei dati, altrimenti potrebbe non essere una soluzione efficiente. Inoltre, viene spiegata la somiglianza tra SIMD e calcolo vettoriale, in cui le istruzioni vettoriali possono essere utilizzate su dati sparsi in diverse parti della memoria per eseguire operazioni virtuali.
  
  
• 00:05:00 In questa sezione, il video spiega come utilizzare il multi-threading hardware o il multi-threading simultaneo (SMT) per sfruttare il parallelismo a livello di thread. Mettendo più programmi o thread sullo stesso processore, diversi flussi di istruzioni possono essere eseguiti contemporaneamente se sono indipendenti l'uno dall'altro. Il multi-threading hardware può essere utile per macchine di grandi dimensioni e singole CPU, in quanto consente la facile estrazione di istruzioni da due thread indipendenti. Tuttavia, ciò richiede file di registro aggiuntivi e un'attenta considerazione di come le cache vengono condivise tra i diversi thread.
  
  
• 00:10:00 In questa sezione del video, il relatore discute su come mantenere occupata l'unità logica aritmetica (ALU) implementando la pianificazione dei thread con suddivisione temporale. Questo metodo consente ai thread di occupare a turno il percorso dati del processore in modalità round-robin, il che riduce significativamente la latenza pianificando più thread. Eseguendo l'istruzione successiva durante l'attesa di un thread bloccato, questo metodo consente l'utilizzo simultaneo di unità di calcolo e sistemi di memoria da parte di più thread. In definitiva, il risultato è che non ci sono perdite di tempo e il processore può ospitare tutti i thread necessari. Tuttavia, le prestazioni di un singolo thread su un processore single-thread potrebbero non essere migliorate tanto quanto su un processore multi-thread.

[MetaQuotes]

8. Architettura del processore multicore

8. Architettura del processore multicore

Questo video spiega l'architettura dei processori multicore e i loro vantaggi, come più core che operano in modo indipendente e condividono alcuni componenti, mentre ogni core ha la propria pipeline e cache di dati. L'importanza della gerarchia della cache nel colmare il divario di velocità tra il microprocessore e l'accesso alla memoria è evidenziata utilizzando più livelli di cache che sfruttano la località temporale e spaziale. Il video tocca anche il design system-on-chip, che combina diverse unità funzionali e interfacce in un singolo chip per ridurre i costi e il fattore di forma. Nel complesso, il video fornisce un'utile introduzione alla complessità e ai compromessi coinvolti nella progettazione di processori multicore.

• 00:00:00 In questa sezione impariamo a conoscere i processori multicore ei loro vantaggi rispetto ai processori single-core. I processori multicore hanno più core, che operano in modo indipendente e condividono alcuni componenti come il recupero delle istruzioni, la decodifica e gli scheduler a virgola mobile. Tuttavia, ogni core ha la propria pipeline e la propria cache di dati di livello 1. I processori multicore richiedono protocolli di coerenza della cache per garantire che i dati archiviati in ciascuna cache siano coerenti con i dati nella memoria principale. System-on-chip è un'altra opzione di progettazione in cui più elementi vengono combinati in un unico dispositivo sullo stesso chip per ridurre i costi e il fattore di forma. Ha molte diverse unità di funzioni dedicate e interfacce collegate al resto del chip tramite un'interconnessione unship.
  
  
• 00:05:00 In questa sezione, il relatore spiega il concetto di gerarchia della cache in un'architettura di processore multicore. Il motivo principale per utilizzare la cache è colmare il divario di velocità tra il microprocessore e l'accesso alla memoria, che funzionano a frequenze diverse e hanno capacità di archiviazione diverse. Le cache di livello 1, livello 2 e livello 3 vengono utilizzate per colmare il divario e sfruttano rispettivamente la località temporale e spaziale dell'accesso a un piccolo numero di istruzioni o dati in un breve periodo o l'accesso a posizioni vicine. Le cache sono organizzate utilizzando blocchi, che vengono spostati tra i livelli di memoria, consentendo al processore di sfruttare la località temporale e spaziale.

[MetaQuotes]

9. Architettura GPU

9. Architettura GPU

L'unità di elaborazione accelerata (APU) è un processore eterogeneo con core a basso consumo e unità GPU tutte sullo stesso chip. Le GPU hanno un gran numero di core shader che possono essere programmati con istruzioni e le loro cache sono generalmente non coerenti, rendendo il loro design più semplice e consentendo prestazioni molto più elevate quando molti core operano contemporaneamente. AMD e Nvidia utilizzano unità di calcolo di piccole dimensioni per supportare l'operazione su più parti di dati contemporaneamente e dispongono di file di registro di grandi dimensioni per supportare il cambio di contesto rapido. Il relatore spiega anche come gestire il flusso di controllo nell'architettura GPU, in particolare nella gestione delle istruzioni di ramo che potrebbero produrre risultati non validi, ma i programmatori non devono preoccuparsi molto di questi problemi perché i fornitori di processori hanno già fornito la logica di controllo nell'hardware. Nel complesso, le GPU sono processori popolari per carichi di lavoro complessi nel mercato moderno, in particolare nel campo dell'intelligenza artificiale e dell'apprendimento automatico.

• 00:00:00 In questa sezione, impareremo a conoscere l'unità di elaborazione accelerata (APU), che è un tipico processore eterogeneo costituito da core a basso consumo utilizzati per l'elaborazione, la gestione e la configurazione general-purpose del sistema e unità GPU, tutto sullo stesso chip. L'APU ha un tipico core x86 con due livelli di cache, mentre i core della GPU sono diversi e non x86, con un'archiviazione dei dati locale inferiore considerata memoria privata. La proprietà della memoria è visibile in un diagramma, che mostra le posizioni, l'accessibilità e le dimensioni della memoria, con la memoria privata più piccola della memoria locale e molto più piccola della memoria globale. Gli attuali processori per laptop di Intel o AMD hanno in genere un numero limitato di core per uso generico, memoria integrata e un'unità di elaborazione grafica su chip.
  
  
• 00:05:00 In questa sezione, apprendiamo l'architettura della GPU e come viene utilizzata nel campo dell'intelligenza artificiale e dell'apprendimento automatico. Le GPU hanno un gran numero di processori, chiamati core shader, che possono essere programmati con istruzioni. Possono accedere alla memoria GPU ad alta velocità che è diversa dal sottosistema di memoria di un processore generico e le loro cache sono generalmente non coerenti. Le GPU non utilizzano il protocollo di coerenza della cache per garantire la coerenza, il che rende il design più semplice e consente prestazioni molto più elevate quando molti core operano contemporaneamente. Nel complesso, le GPU sono un processore popolare per carichi di lavoro complessi nel mercato moderno.
  
  
• 00:10:00 In questa sezione, apprendiamo come AMD e Nvidia utilizzano piccole unità di calcolo dotate di hardware cmd per supportare l'operazione su più dati contemporaneamente. Entrambi i fornitori hanno cmd larghi 16 e possono raggruppare gli elementi di lavoro in gruppi più grandi e mapparli a batch diversi a seconda del chip e dei parametri di configurazione. Inoltre, dispongono di file di registro di grandi dimensioni per supportare il cambio di contesto rapido ed entrambi i fornitori hanno una combinazione di cache di livello uno automatica e scratchpad gestito dall'utente, che è fortemente supportato da un'elevata larghezza di banda per supportare operazioni veloci sulle rispettive memorie private. Infine, tocchiamo brevemente il flusso di controllo e il concetto di esecuzione di più dati con un'istruzione e come le istruzioni di ramo causino una certa deviazione nei percorsi di esecuzione, richiedendo un modo per ridurre al minimo la quantità di calcolo eseguita su dati non validi.
  
  
• 00:15:00 In questa sezione, il relatore spiega come gestire il flusso di controllo nell'architettura GPU, in particolare nella gestione delle istruzioni di ramo che possono produrre risultati non validi. Per gestire questo problema, le corsie cmd possono essere mascherate per scartare alcuni calcoli, sebbene ciò possa influire negativamente sulle prestazioni. Un altro problema che dobbiamo affrontare quando si utilizza la tecnologia SIMT (Single Instruction Multiple Threads) è la divergenza tra i thread del software, che può sprecare cicli di calcolo se non gestiti correttamente. Fortunatamente, i programmatori OpenCL non devono preoccuparsi molto di questi problemi perché i produttori di processori hanno già fornito la logica di controllo nell'hardware.

[MetaQuotes]

10. Interni FPGA

10. Interni FPGA

Questo video illustra l'architettura e le caratteristiche dei gate array programmabili sul campo (FPGA). Gli FPGA hanno una logica programmabile, che consente loro di essere riprogrammati per adattarsi a nuove funzionalità e hanno accesso diretto ai dati attraverso enormi quantità di input e output (I/O). La struttura della tabella di ricerca negli FPGA consiste in più livelli di multiplexer che possono essere programmati per definire funzioni logiche. Gli FPGA utilizzano registri programmabili che possono essere utilizzati per contatori, registri a scorrimento, macchine a stati e funzioni DSP. Ogni blocco rettangolare sul chip rappresenta un Logic Array Block (LAB), con ciascun LAB contenente dieci Adaptive Logic Modules (ALM). Gli FPGA sono utilizzati in settori come dispositivi di consumo, automotive, strumentazione medica, comunicazione e trasmissione.

• 00:00:00 In questa sezione vengono introdotte le basi degli FPGA, inclusa la loro logica programmabile che può essere riprogrammata per accogliere nuove funzionalità e il loro accesso diretto ai dati attraverso enormi quantità di I/O. I vantaggi degli FPGA sono la loro comoda connessione a componenti di memoria e coprocessori, funzionalità sostituibili senza la necessità di sostituire l'hardware e la loro ubiquità in settori come dispositivi di consumo, automotive, strumentazione medica e comunicazione e trasmissione. L'architettura degli FPGA include la tabella di ricerca, che può essere programmata per definire le funzioni logiche, e altre parti importanti come i registri di riporto ei moduli logici adattativi che verranno discussi nelle sezioni successive.
  
  
• 00:05:00 In questa sezione del video, il presentatore spiega la struttura di una tabella di ricerca negli FPGA, che consiste in più livelli di multiplexer con ingressi selezionabili. Gli input della tabella di ricerca possono essere utilizzati per creare una funzione logica combinatoria arbitraria. Il video poi discute i registri programmabili, che sono elementi di archiviazione negli FPGA utilizzati per contatori, registri a scorrimento, macchine a stati e funzioni DSP. Questi registri hanno un segnale di clock tipicamente pilotato da un clock globale e possono essere restituiti alla tabella di ricerca. Inoltre, il video spiega come gli elementi logici e i moduli logici adattivi sono collegati tramite segnali a catena
  e trasportare bit e come l'input ai registri può provenire da elementi logici precedenti.
  
  
• 00:10:00 In questa sezione impareremo come organizzare gli elementi logici all'interno di un chip FPGA. Ogni blocco rettangolare sul chip rappresenta un Logic Array Block (LAB), con ciascun LAB contenente dieci Adaptive Logic Modules (ALM). Ogni ALM è costituito da unità aritmetiche, interconnessioni locali e connessioni di registrazione, oltre a risorse dedicate e una tabella di ricerca adattiva per l'organizzazione flessibile degli input e la generazione di output specifici. Inoltre, disponiamo di interconnessioni di righe e colonne che possono connettere LAB specifici e il routing scala linearmente a seconda della densità del dispositivo. Infine, abbiamo blocchi di memoria incorporati che supportano diversi tipi di strutture di memoria, come RAM a porta singola o doppia, memoria di sola lettura o piccole porzioni di strutture di memoria chiamate eMLAB.
  
  
• 00:15:00 In questa sezione, apprendiamo le diverse funzionalità degli FPGA, inclusi i blocchi di elaborazione del segnale digitale (DSP) e i componenti di ingresso/uscita (IO). I blocchi DSP sono utili per implementare funzioni di elaborazione del segnale come trasformazioni FFT e operazioni di moltiplicazione e accumulo ad alte prestazioni. Gli FPGA possono anche comunicare con vari componenti IO, consentendo l'abilitazione, il controllo e la terminazione dell'output. La logica dell'elemento IO include pin bidirezionali e controllo del segnale di abilitazione dell'uscita e il percorso di uscita genera i valori A e B attraverso il segnale di clock. Se invece il controllo dell'uscita è disabilitato, i segnali di ingresso passano attraverso il registro di ingresso.
  
  
• 00:20:00 In questa sezione sugli interni FPGA, viene evidenziata l'importanza dei segnali di clock insieme all'uso di pin di clock di ingresso dedicati per supportare le operazioni FPGA. Vengono discussi anche i ricetrasmettitori ad alta velocità, utili per implementare protocolli di segnale più complessi negli FPGA, senza la necessità di complesse elaborazioni e condizionamenti del segnale. Viene anche spiegato l'uso dei PLL per generare diversi segnali di clock da utilizzare in tutto il dispositivo con uno skew minimo, insieme all'uso della tecnologia delle celle SRAM e delle tabelle di ricerca per configurare bit programmabili che controllano la connettività dei segnali di ingresso e uscita. Il video copre anche i metodi utilizzati per programmare FPGA utilizzando W prom esterno, Cpl D o una CPU per controllare le sequenze di programmazione e l'uso di una speciale connessione JTAG hardware per ulteriori diagnosi e debug.
  
  
• 00:25:00 In questa sezione vengono discussi il design e le caratteristiche di un FPGA (Field-Programmable Gate Array). La maggior parte dell'area in un FPGA è costituita dai blocchi dell'array logico che possono essere collegati tramite interconnessioni di righe e colonne. Altri blocchi includono PR, ricetrasmettitori e un controller di memoria che può essere collegato a diversi componenti di memoria. Un FPGA PJ area 10g X viene utilizzato come esempio con 1 milione di elementi logici, 1,7 milioni di registri, 54.000 blocchi di memoria con 22 bit ciascuno, 1.518 blocchi DSP, ricetrasmettitori da 367,4 gigabit al secondo, due blocchi PCIe rigidi, 492 pin IO generali e 12 controller di memoria. Il vantaggio degli FPGA è l'elevata densità per creare funzioni complesse, l'integrazione di più funzioni, l'accesso a diversi standard e funzionalità IO e l'accesso diretto ai dati in un chip.

[MetaQuotes]

11. Memoria OpenCL su un sistema GPU

11. Memoria OpenCL su un sistema GPU

L'istruttore spiega la mappatura della memoria OpenCL sulla GPU AMD e i diversi livelli di memoria in un sistema GPU. Il dispositivo di calcolo dispone di un processore di comandi che gestisce le direttive alle unità di calcolo, che funzionano come core con più corsie SIMD, file di registro privati e memoria privata. Il programma del kernel ha lo scopo di fornire lavori autonomi che consentano di utilizzare tutti i core disponibili e ridurre la latenza di accesso alla memoria. L'oratore menziona anche il concetto di intensità aritmetica, che si riferisce al rapporto tra calcolo e movimento dell'asse di memoria, e come dovrebbe essere alto per evitare che la larghezza di banda della memoria della GPU sia il fattore limitante.

• 00:00:00 In questa sezione, il relatore discute OpenCL in relazione all'architettura hardware di diversi processori, concentrandosi in particolare sulla GPU AMD. Il diagramma mostra la memoria globale, la memoria costante e la memoria locale, con il kernel a sinistra che rappresenta il kernel OpenCL utilizzato durante la progettazione di un programma parallelo di dati. Ogni gruppo di lavoro esegue un sottoinsieme del calcolo basato sui dati, con la memoria locale locale al gruppo di lavoro e condivisa con le unità di esecuzione all'interno del processore. Gli elementi di lavoro all'interno del gruppo di lavoro sono il calcolo effettivo eseguito, ciascuno con il proprio set di dati.
  
  
• 00:05:00 In questa sezione, l'istruttore discute come la memoria OpenCL è mappata alla GPU AMD e i diversi livelli di memoria su un sistema GPU. Il dispositivo di calcolo dispone di un processore di comandi che pianifica le istruzioni per le unità di calcolo, che dispongono di cache di livello 1 e condividono una cache di livello 2 e sono connesse alla memoria globale. L'unità computer funziona come un nucleo, con più corsie SIMD e file di registro privati, chiamati GPR, che costituiscono la memoria privata. Ci si aspetta che il programma del kernel fornisca pezzi di lavoro indipendenti, che dovrebbero essere il maggior numero possibile per occupare tutti i core disponibili, e questi pezzi dovrebbero consentire il cambio di contesto hardware per ridurre al minimo la latenza di accesso alla memoria. Il kernel dovrebbe anche avere un'elevata intensità aritmetica per fare un uso efficiente dell'hardware.
  
  
• 00:10:00 In questa sezione, il relatore discute il concetto di intensità romantica che è essenzialmente il rapporto tra il calcolo e il movimento dell'asse della memoria. L'obiettivo è avere operazioni matematiche sugli accessi alla memoria il più alto possibile per evitare di essere limitati dalla larghezza di banda della memoria.

[MetaQuotes]

12. OpenCL Esempio: moltiplicazione di matrici

12. OpenCL Esempio: moltiplicazione di matrici

Questo video introduce la moltiplicazione di matrici come esempio di programmazione OpenCL. Il relatore dimostra come il codice C viene scritto per creare cicli indipendenti che possono attraversare righe e colonne della matrice. Vengono discussi gli elementi di lavoro e come possono essere mappati agli elementi della matrice in OpenCL. Viene spiegata un'implementazione del kernel, coprendo gli argomenti della funzione del kernel, come viene chiamata e il suo corpo. L'oratore mostra come la matrice di input viene memorizzata in un array a dimensione singola utilizzando i numeri di riga e di indice per calcolare gli indici. In definitiva, la funzione kernel calcola il prodotto scalare per produrre l'elemento nella matrice di output. Viene enfatizzato l'approccio lineare alla memorizzazione delle matrici nella memoria fisica.

• 00:00:00 In questa sezione, apprendiamo la moltiplicazione di matrici come esempio di programmazione OpenCL. La moltiplicazione di matrici è un classico esempio di power computing che è stato utilizzato in molte applicazioni diverse. L'implementazione richiede cicli nidificati, con il requisito che il numero di colonne della matrice A deve essere uguale al numero di righe della matrice B. Questo perché ogni elemento risultante nella matrice C è il prodotto scalare di un vettore riga di A con un vettore colonna di B. Vediamo come viene scritto il codice C per implementare l'operazione e come i cicli funzionano in modo indipendente, permettendoci di passare attraverso ogni riga o colonna della matrice C risultante in modo casuale.
  
  
• 00:05:00 In questa sezione viene introdotto il concetto di elementi di lavoro e viene spiegato come gli elementi di lavoro possono essere mappati agli elementi della matrice in OpenCL. Gli elementi di lavoro possono essere creati per ogni elemento di output di una matrice da calcolare in modo indipendente e, pertanto, possono essere mappati a elementi di lavoro con intervallo bidimensionale. Viene anche discussa l'implementazione del kernel per la moltiplicazione di matrici in OpenCL, dove vengono spiegati gli argomenti per la funzione kernel e come chiamarla dalla funzione principale, e viene presentato il corpo della funzione kernel. La funzione kernel calcola il prodotto scalare di un vettore riga e un vettore colonna per calcolare ogni elemento della matrice di output.
  
  
• 00:10:00 In questa sezione, il relatore spiega il processo di moltiplicazione delle matrici utilizzando il linguaggio di programmazione OpenCL. L'idea principale è memorizzare la matrice di input bidimensionale in un array a dimensione singola utilizzando il numero di riga e il numero di indice per calcolare l'indice giusto per trovare l'elemento giusto per eseguire l'operazione del prodotto scalare. La funzione kernel inizializza la variabile somma con 0 e scorre il vettore riga di A e il vettore colonna di B per calcolare il prodotto scalare, assegnando infine il risultato all'elemento corrispondente in C. Questi passaggi illustrano come utilizzare i numeri di riga e colonna per calcolare gli indici in modo lineare, essenziale per memorizzare la matrice nella memoria fisica.

[MetaQuotes]

13. Struttura di un programma OpenCL (parte 1)

13. Struttura di un programma OpenCL (parte 1)

Nel video "Struttura di un programma OpenCL (parte 1)", viene spiegato il processo di creazione di un'applicazione OpenCL. Il programma deve prima interrogare la piattaforma OpenCL per comprenderne le risorse e creare un contesto OpenCL e una coda di comando. I buffer vengono quindi creati per lo scambio di dati tra l'host e la memoria del dispositivo e il programma del kernel viene compilato in un file binario per l'esecuzione sul dispositivo. Il video prosegue spiegando come creare buffer di sola lettura e sola scrittura, allocare spazio per le matrici di output e copiare i risultati nell'host. Viene sottolineata l'importanza di controllare le chiamate API per l'esecuzione corretta.

• 00:00:00 In questa sezione, il relatore spiega i passaggi per creare un'applicazione OpenCL. Innanzitutto, il programma deve interrogare la piattaforma OpenCL per comprendere le risorse disponibili sulla piattaforma, quindi creare un contesto OpenCL e una coda di comando, che è essenziale per le operazioni del buffer e l'avvio del kernel. I buffer vengono quindi creati per scambiare dati tra l'host e la memoria del dispositivo. Successivamente, il programma del kernel deve essere compilato in un file binario che può essere eseguito sul dispositivo acceleratore su un FPGA o su una GPU. Il processo di compilazione varia a seconda del dispositivo.
  
  
• 00:05:00 In questa sezione, il video illustra come configurare l'ambiente per creare la piattaforma e il dispositivo, creare un contesto e creare code di comandi per la programmazione OpenCL. Ciò comporta l'ottenimento dell'ID della piattaforma, che consente al programmatore di determinare il numero di piattaforme disponibili e allocare lo spazio per l'archiviazione. Il video prosegue spiegando come scegliere i dispositivi all'interno della piattaforma, ottenere informazioni sul dispositivo scelto, impostare gli argomenti appropriati e passare i valori di questi argomenti alla funzione kernel per istanziare il kernel. Infine, mostrano come copiare i risultati dal dispositivo alla memoria dell'host una volta completato il kernel.
  
  
• 00:10:00 In questa sezione, il video spiega come creare un contesto OpenCL e l'importanza dell'oggetto contesto nel legare insieme tutte le risorse necessarie per le operazioni OpenCL, come code di comandi e buffer. La trascrizione illustra come creare buffer di sola lettura e sola scrittura e come copiare i dati tra l'host e il dispositivo utilizzando i comandi CL ink e CL in Q write buffer. L'esempio utilizzato è la moltiplicazione di matrici, in cui le matrici A e B sono input e la matrice C è un output. Il video sottolinea l'importanza di verificare la riuscita delle chiamate API.
  
  
• 00:15:00 In questa sezione, il relatore spiega come allocare lo spazio per Matrix C, che è la matrice di output. Dicono che il buffer C sia dichiarato come memoria CL, che consente al dispositivo di scrivere i risultati al suo interno. Tuttavia, ciò non impedisce la lettura di questo buffer dal lato host, che è necessario per recuperare i risultati dal dispositivo e copiare la matrice risultante da qualche parte nell'host. L'oratore mostra la definizione completa dell'API buffer, che accetta cinque argomenti: contesto, flag, dimensione, puntatore host e valore restituito.

[MetaQuotes]

14. Struttura di un programma OpenCL (parte 2)

14. Struttura di un programma OpenCL (parte 2)

Il terzo passaggio nella programmazione OpenCL prevede la compilazione del kernel, che è diversa per i dispositivi FPGA poiché viene eseguita offline. Il programma di creazione CL con sorgente e C TX viene utilizzato per creare un programma, seguito dal programma di creazione CL per creare il programma in formato binario. La funzione del kernel corretta viene selezionata utilizzando il punto di ingresso appropriato e gli argomenti del kernel devono essere inizializzati utilizzando l'argomento del kernel set CL con il puntatore corretto. L'oratore entra nei dettagli sull'impostazione corretta degli argomenti nella moltiplicazione di matrici. Discutono quindi dell'impostazione delle dimensioni dei gruppi di lavoro locali e globali, dell'esecuzione del kernel e dell'ottenimento dei risultati utilizzando l'API CL nel buffer di coda. Infine, il relatore menziona brevemente gli eventi nella programmazione OpenCL.

• 00:00:00 In questa sezione viene discusso il terzo passaggio in un programma OpenCL, che prevede la compilazione del kernel. Questo processo è leggermente diverso per i dispositivi FPGA, poiché la compilazione viene eseguita offline. Supponendo che il codice sorgente del programma sia memorizzato in un buffer di caratteri, il programma di creazione CL con sorgente e C TX viene utilizzato per creare un programma e il programma di creazione CL viene utilizzato per creare il programma in binario. Successivamente, la funzione del kernel corretta viene selezionata dal codice sorgente creando un kernel utilizzando il punto di ingresso appropriato per la specifica funzione del kernel scelta. Una volta creato il kernel, gli argomenti del kernel devono essere inizializzati correttamente utilizzando l'argomento del kernel set CL, con un puntatore che punta al valore effettivo. Ad esempio, nella moltiplicazione di matrici, sette argomenti devono essere impostati correttamente, incluso il buffer di destinazione, la dimensione delle matrici e le due matrici di input.
  
  
• 00:05:00 In questa sezione, l'oratore parla dell'inizializzazione di più argomenti del kernel e sottolinea l'importanza di impostare correttamente gli indici di questi argomenti per evitare errori. Spiegano quindi come impostare le dimensioni dei gruppi di lavoro locali e globali, specificando il numero di elementi di lavoro in un gruppo e il numero di gruppi di lavoro. Infine, descrivono i passaggi per eseguire il kernel, inclusa la chiamata all'API OpenCL e l'ottenimento dei risultati dal dispositivo per ospitare la memoria utilizzando l'API CL nel buffer di coda. Il relatore menziona anche brevemente gli eventi e come possono essere utilizzati nella programmazione OpenCL, ma questo sarà discusso ulteriormente nelle lezioni successive.

[MetaQuotes]

15. Demo di moltiplicazione di matrici OpenCL

15. Demo di moltiplicazione di matrici OpenCL

Il video "OpenCL Matrix Multiplication Demo" spiega il processo di esecuzione di un esempio di moltiplicazione di matrici utilizzando il framework OpenCL. Include più file di codice sorgente come un programma C principale per il lato host, un programma kernel e un makefile. Il video copre diversi aspetti del framework OpenCL, ottenendo ID di piattaforma e dispositivo, creando un contesto OpenCL, oggetti del programma e del kernel, la gestione del buffer per l'host e la creazione e l'inizializzazione dei buffer sul dispositivo. Il presentatore mostra anche un kernel campione che esegue operazioni dot product e una demo del risultato finale su un motore di calcolo AMD Radeon pro 575.

• 00:00:00 In questa sezione, il relatore spiega come eseguire un esempio di moltiplicazione di matrici tramite OpenCL. L'esempio è costituito da diversi file di codice sorgente, incluso un programma C principale come programma lato host, un programma del kernel chiamato my kernel CL e un makefile per aiutare a compilare il progetto. Il programma principale include librerie standard, definizioni di macro per il framework OpenCL e dichiarazioni per matrici di input (matrice A e matrice B), nonché nome del dispositivo, identificatori di piattaforma e numeri di dispositivi. Il relatore descrive anche vari aspetti del framework OpenCL, come il contesto, il programma, il kernel e la lettura e la compilazione del codice sorgente. Inoltre, il relatore spiega l'importanza degli ID della piattaforma e del dispositivo, nonché delle dimensioni della matrice nel codice.
  
  
• 00:05:00 In questa sezione, il relatore discute il processo per ottenere gli ID della piattaforma e del dispositivo e creare il contesto OpenCL per la demo di moltiplicazione di matrici. Spiegano come viene restituito il conteggio della piattaforma e l'array viene allocato per memorizzare gli ID della piattaforma. Mostrano anche come ottenere gli ID dispositivo per un tipo specifico scelto e interrogarne il nome. Il video mostra come creare una coda di comando per ogni dispositivo e come compilare il programma OpenCL. Spiegano inoltre come utilizzare l'app open per aprire il file del codice sorgente del kernel e compilare il programma.
  
  
• 00:10:00 In questa sezione, il video spiega come creare un oggetto programma dal codice sorgente del kernel OpenCL. Questo processo è diverso su piattaforme diverse. Su Mac OS con supporto OpenCL nativo, è possibile creare un oggetto programma utilizzando il codice sorgente. Su Altera FPGA OpenCL SDK, tuttavia, la creazione di un oggetto programma implica la compilazione del kernel e la sua creazione dal risultato binario di quella compilazione utilizzando l'API specifica di Altera. Una volta creato l'oggetto programma, il video mostra come costruire il programma kernel e creare l'oggetto kernel. Infine, il video passa alla gestione del buffer sul lato host, dove viene allocato un buffer per memorizzare la matrice C risultante.
  
  
• 00:15:00 In questa sezione, il relatore spiega come creare e inizializzare i buffer sul lato del dispositivo per la moltiplicazione di matrici utilizzando OpenCL. Proseguono mostrando come impostare correttamente gli argomenti del kernel, inclusa l'impostazione delle dimensioni globali e locali dei gruppi di lavoro. Viene inoltre evidenziata l'importanza di verificare il valore di ritorno del CL. Il presentatore mostra quindi come leggere i risultati nella memoria dell'host, quindi liberare le risorse allocate sull'host e su OpenCL. Infine, mostrano un kernel di esempio, che usa get global ID per iterare attraverso la larghezza di una matrice, eseguire operazioni di prodotto scalare e memorizzare i risultati nell'elemento corrispondente nella matrice C.
  
  
• 00:20:00 In questa sezione, il relatore discute la costruzione del programma C principale e del programma CL di Mike Rinder. Per creare il programma lato host, gli utenti devono compilare un singolo file di programma C e, per il kernel, è possibile utilizzare il compilatore GPU per compilare il Micra che conosce il CL in un binario GPU. Dopo aver creato il programma sia sul lato host che sul lato dispositivo, gli utenti hanno un eseguibile denominato "main", insieme a diversi file binari disponibili per diverse versioni della GPU. Dopo aver eseguito questo file, il relatore mostra una piattaforma OpenCL con un motore di calcolo AMD Radeon pro 575 che ha un valore iniziale della matrice C con tutti gli elementi contenenti otto punti.