OpenCL nel Trading - pagina 9

[MetaQuotes]

EECE.6540 Heterogeneous Computing (University of Massachusetts Lowell) - 46. Concetti di base FPGA

46. Concetti di base FPGA

Questo video illustra i concetti di base degli FPGA (Field Programmable Gate Array). A differenza delle CPU, gli FPGA possono essere programmati per adattarsi a risorse hardware specifiche, il che significa che sono altamente personalizzabili. Il video discute l'importanza della latenza nella progettazione dei circuiti e come può essere bilanciata massimizzando f max. Introduce il concetto di progettazione della pipeline per aumentare la frequenza con cui è possibile eseguire un calcolo, oltre a discutere i percorsi dei dati e i percorsi di controllo in un circuito. Infine, il video discute l'occupazione del circuito in un FPGA e come la diminuzione delle bolle e l'aumento dell'occupazione possono aumentare f max.

• 00:00:00 In questa sezione, apprendiamo i concetti di base degli array di gate programmabili sul campo (FPGA) e in che modo differiscono dalle altre architetture di processori. A differenza delle CPU, gli FPGA non hanno un percorso dati fisso e possono essere programmati per adattarsi a risorse hardware specifiche per ospitare diversi numeri di registri, logica computazionale e le loro connessioni, rendendoli altamente personalizzabili. Gli FPGA contengono vari componenti, come logica adattiva, blocchi RAM, blocchi DSP e switch di routing programmabili, che possono essere collegati per implementare diversi design. Inoltre, la frequenza operativa massima di un FPGA è determinata dal ritardo di propagazione fisica della logica combinatoria, che influisce sulla latenza e sulla velocità operativa del circuito.
  
  
• 00:05:00 In questa sezione viene spiegato il concetto di latenza e la sua importanza nella progettazione dei circuiti. La latenza è il tempo impiegato da un circuito per completare una o più operazioni e può essere misurata in tempo o in cicli di clock. Abbassare la latenza è di solito l'obiettivo, ma deve essere attentamente bilanciato con la massimizzazione di f max. Viene fornito un esempio di un progetto ottimizzato per la latenza e uno ottimizzato per f max tramite l'uso della pipeline. Viene sottolineata l'importanza dei registri dei gasdotti per interrompere lunghi percorsi critici e migliorare la velocità.
  
  
• 00:10:00 In questa sezione, il video spiega il concetto di progettazione della pipeline e come aumenta la frequenza con cui è possibile eseguire un calcolo. Utilizzando un registro pipeline, il ritardo può essere ridotto, consentendo velocità di clock più elevate e un aumento del throughput. Il video introduce quindi l'idea di percorso dati e percorso di controllo in un circuito, dove il percorso dati è la catena di registri e la logica combinatoria che esegue il calcolo, e il percorso di controllo è tutto il resto al di fuori del percorso dati che controlla il funzionamento del circuito . Varie logiche vengono aggiunte al percorso di controllo per il controllo del flusso di handshaking, il controllo del loop e il controllo del ramo, tra gli altri, e l'occupazione viene utilizzata per definire il rapporto di inizializzazione del percorso dei dati in un circuito.
  
  
• 00:15:00 In questa sezione, il relatore spiega il concetto di occupazione del circuito in un FPGA. Il circuito ha diversi registri, uno dei quali è un registro valido che determina se i dati di input sono validi o meno. L'obiettivo è ridurre le bolle nel circuito per aumentare l'occupazione riducendo al minimo le bolle nell'intero circuito. Ogni ciclo viene conteggiato per vedere come vengono utilizzate le risorse e le porzioni non occupate nel circuito sono chiamate bolle. Diminuendo le bolle e aumentando l'occupazione, la f max può essere aumentata.

[MetaQuotes]

47. Analisi del progetto (I): analisi delle prime immagini FPGA

47. Analisi del progetto (I): analisi delle prime immagini FPGA

Questa sezione del video si concentra sul processo di analisi delle prime immagini FPGA per un progetto DPC++. Il relatore spiega i passaggi coinvolti, come la compilazione del programma, la generazione del binario FPGA e l'esecuzione della profilazione. Il video include una demo su come generare report e interpretare i vari pannelli informativi forniti nei report. Il relatore analizza anche le prime immagini FPGA di un modulo b2 e discute i vari blocchi logici, i loop, l'unità di carico e il fattore di srotolamento. Discutono anche di come la progettazione di una funzione del kernel può avere un impatto significativo sulla progettazione interna su FPGA e forniscono esempi di come i loop interni ed esterni possono essere srotolati per aumentare il throughput. Gli esempi illustrano la flessibilità del linguaggio di programmazione ad alto livello nell'influenzare le risorse hardware dell'FPGA.

• 00:00:00 In questa sezione del video, il relatore discute il processo di analisi di un progetto DPC++, concentrandosi in particolare sull'analisi delle prime immagini FPGA. Ciò comporta diversi passaggi come la compilazione del programma in un emulatore FPGA per garantire la correttezza funzionale, la generazione del binario FPGA, l'esecuzione su una scheda caratteristica e l'esecuzione del profilo per determinare le prestazioni di runtime. La seconda fase prevede la generazione di report e la ricerca di colli di bottiglia prima di rivedere il progetto, se necessario. Il video include una demo su come generare report e analizzarli in un browser e spiega come interpretare i vari pannelli informativi e riepiloghi forniti nei report.
  
  
• 00:05:00 In questa sezione, il relatore fornisce una panoramica dello strumento di analisi del progetto e delle sue funzionalità. Spiegano come il pannello di utilizzo delle risorse visualizza le informazioni sulle risorse che verranno utilizzate dal progetto e come il pannello dei visualizzatori di sistema consente agli utenti di visualizzare diversi componenti del progetto, come componenti di memoria e pipe. Il visualizzatore di grafici all'interno del pannello dei visualizzatori di sistema mostra un elenco dei componenti utilizzati nella progettazione e il modo in cui sono interconnessi. L'oratore dimostra anche come gli utenti possono ingrandire i singoli moduli per visualizzare i segmenti corrispondenti nel codice sorgente.
  
  
• 00:10:00 In questa sezione, il relatore analizza le prime immagini FPGA di un modulo b2 e discute i vari blocchi logici e loop che compongono il progetto. Spiegano anche l'uso dell'unità di carico per caricare i dati dal componente di memoria e il fattore di srotolamento per aumentare l'efficienza delle operazioni di loop. Il relatore confronta anche i progetti parallel 4 e single task e consiglia di utilizzare single task per i progetti FPGA per ottimizzare l'accesso alla memoria.
  
  
• 00:15:00 In questa sezione, il relatore discute di come la progettazione di una funzione del kernel possa avere un impatto significativo sulla progettazione interna dell'FPGA. L'oratore fornisce esempi di come i loop interni ed esterni possono essere srotolati per utilizzare le risorse hardware dell'FPGA, aumentando così il throughput. Gli esempi illustrano la flessibilità del linguaggio di programmazione ad alto livello nell'influenzare le risorse hardware dell'FPGA.

[MetaQuotes]

48. DPC++ FPGA Design Analysis (II): Runtime Profiling

48. DPC++ FPGA Design Analysis (II): Runtime Profiling

In questo video, il relatore discute il processo di analisi delle prestazioni di runtime di un programma utilizzando strumenti che raccolgono dati sulle prestazioni aggiungendo registri di strumenti di profilatura ai flussi di bit FPGA. Dimostrano come compilare per il profiling e interpretare i risultati del profiling collettivo utilizzando il profiler dinamico Intel FPGA con contatori delle prestazioni aggiunti dall'utente. Mostrano come il profiler V2 visualizza le funzioni del kernel e gli eseguibili utilizzati per analizzare i risultati del profilo di runtime e come identificare i colli di bottiglia delle partizioni e ottimizzarli. L'esempio utilizzato è un kernel di modifica della matrice che ha avuto molti accessi alla memoria globale, che è stato ottimizzato utilizzando la memoria locale per ridurre la comunicazione con la memoria globale e migliorare l'efficienza della progettazione.

• 00:00:00 In questa sezione, il relatore discute l'analisi delle prestazioni di runtime di un programma. Spiegano come utilizzare gli strumenti per raccogliere i dati sulle prestazioni aggiungendo i registri degli strumenti di profilazione ai flussi di bit FPGA. Il profiler dinamico Intel FPGA viene utilizzato con i contatori delle prestazioni aggiunti dall'utente per raccogliere i dati sulle prestazioni del kernel. I dati sulle prestazioni vengono archiviati in un file denominato profile.mall alla fine dell'esecuzione e viene generato un file json per consentire al profiler Intel v2 di leggere i file. Entrambi i file sono necessari quando si carica la cartella dei risultati nel toolkit Intel Retune. L'importazione dei dati dalla directory è importante durante il caricamento dei dati in v2.
  
  
• 00:05:00 In questa sezione, i relatori dimostrano come compilare per la profilazione e interpretare i risultati della profilazione collettiva. Mostrano come il profiler V2 visualizza le funzioni del kernel e gli eseguibili usati per analizzare i risultati del profiling di runtime. Il pannello mostra le funzioni di funzionamento della memoria e le operazioni di loop, il loro tempo, la percentuale di stallo, l'occupazione, il tempo di inattività, la percentuale di attività, la dimensione del trasferimento dei dati e la larghezza di banda media. La parte inferiore del pannello mostra in modo più dettagliato l'utilizzo dell'FPGA e altre metriche per l'occupazione della larghezza di banda della memoria globale. Mostrando le statistiche dettagliate, i progettisti possono comprendere i singoli kernel e le loro funzioni, il che li aiuta a ottimizzare e migliorare i loro progetti.
  
  
• 00:10:00 In questa sezione del video, il relatore spiega come identificare i colli di bottiglia delle partizioni e ottimizzarli. L'esempio utilizzato è un kernel di modifica della matrice che ha molti accessi alla memoria globale, risultando in 15,57 GB di trasferimento dati. Il design del kernel è legato alla memoria e la soluzione consiste nell'ottimizzare l'accesso alla memoria utilizzando la memoria locale per ridurre la comunicazione con la memoria globale e migliorare l'efficienza del design. Questa ottimizzazione sarà discussa nella prossima lezione.

[MetaQuotes]

EECE.6540 Calcolo eterogeneo (Università del Massachusetts Lowell) - 49. Esempi OpenCL

49. Esempi OpenCL (I)

Il video di YouTube "OpenCL Examples (I)" copre l'implementazione della moltiplicazione di matrici utilizzando cicli nidificati nella programmazione C e la sua implementazione come kernel OpenCL. Il docente spiega come utilizzare due livelli di cicli nidificati per il calcolo del prodotto scalare dell'elemento risultante nella matrice e come ogni elemento di output della matrice C viene trattato come un elemento di lavoro separato in OpenCL. Il video copre anche i passaggi necessari per preparare il kernel OpenCL per l'esecuzione e recuperare la matrice risultante da un dispositivo a un host, nonché impostare le dimensioni del gruppo di lavoro ed eseguire il kernel con argomenti del kernel modificati. Inoltre, viene fornito un codice di esempio per la moltiplicazione di matrici e il relatore dimostra il processo per ottenere ID dispositivo e piattaforma su Mac OS e creare un oggetto programma su piattaforme diverse. Infine, il video spiega la gestione del buffer, tracciando le risorse allocate sul lato host e le risorse OpenCL utilizzate e fornisce un semplice esempio di kernel di moltiplicazione.

Questo video illustra vari esempi di utilizzo di OpenCL, tra cui la moltiplicazione di matrici, la rotazione delle immagini e il filtraggio delle immagini. Per la rotazione dell'immagine, il relatore spiega come scomporre il problema utilizzando la decomposizione dell'input e dimostra la funzione del kernel utilizzata per identificare la posizione originale e nuova di ciascun pixel. Per il filtraggio delle immagini, il relatore discute il concetto di creazione di oggetti immagine sul lato del dispositivo e l'uso del campionatore OpenCL per definire come accedere all'immagine. Presentano anche un'implementazione di esempio della funzione di convoluzione dell'immagine con due cicli for nidificati. Il video si conclude con una dimostrazione dell'utilizzo di OpenCL per eseguire un filtro di convoluzione su un'immagine e verificare i risultati.

• 00:00:00 In questa sezione, il docente introduce la moltiplicazione di matrici, un classico esempio di calcolo, e spiega come può essere implementata dai cicli nidificati nella programmazione C. Spiegano anche il calcolo del prodotto scalare dell'elemento risultante nella matrice, che è il prodotto di una riga della matrice A e di una colonna della matrice B. La lezione spiega che i due livelli di cicli nidificati possono essere eseguiti indipendentemente e possono essere eseguiti in modo casuale.
  
  
• 00:05:00 In questa sezione viene discusso il concetto di oggetto di lavoro e come può essere applicato per implementare la moltiplicazione di matrici nel kernel OpenCL. Ogni elemento di output della matrice C viene trattato come un elemento di lavoro separato e, con l'aiuto di elementi di elaborazione FPGA o GPU, è possibile mappare un intervallo bidimensionale di elementi di lavoro ad altri cicli for nell'implementazione hardware. Per implementare la moltiplicazione di matrici, viene definita una funzione del kernel chiamata "semplice moltiplicazione" con un elenco di argomenti, che richiede tutte le matrici di input necessarie e le loro dimensioni. Il corpo della funzione kernel utilizza gli ID globali per calcolare la posizione bidimensionale dell'elemento di lavoro e inizializza la somma per calcolare l'elemento risultante della matrice C.
  
  
• 00:10:00 In questa sezione, il relatore spiega la funzione del kernel per la moltiplicazione di matrici utilizzando il framework di programmazione OpenCL. La funzione del kernel utilizza un'operazione di prodotto scalare e un ciclo for per scorrere gli elementi del vettore riga da a e il vettore colonna da B. Gli indici per la matrice di input bidimensionale vengono calcolati utilizzando i numeri di riga e i numeri di colonna per trovare l'elemento destro nel vettore riga e nel vettore colonna. Una volta calcolato il prodotto scalare, l'elemento risultante viene assegnato all'elemento corrispondente in C. Viene discusso anche l'ambiente per il calcolo, che dipende dalla piattaforma e implica la comprensione delle risorse disponibili e dei parametri importanti nella piattaforma.
  
  
• 00:15:00 In questa sezione, il relatore delinea i passaggi necessari per preparare un kernel OpenCL al lavoro, a partire dalla creazione di un contesto e di una coda di comandi per istanziare i kernel. Quindi, i dati di input vengono preparati allocando i buffer sul lato host, copiando i dati dalla memoria dell'host alla memoria del dispositivo e inviando il kernel. Il programma quindi attende il completamento del kernel per raccogliere i risultati leggendo la memoria del dispositivo. L'applicazione openCL ha due livelli: il livello piattaforma e il livello runtime, e il programma del kernel deve essere compilato in un file binario che può essere eseguito sul dispositivo acceleratore, un FPGA o una GPU. Questi passaggi differiscono a seconda del dispositivo e la compilazione di un binario PG può richiedere ore, mentre la compilazione GPU è spesso rapida.
  
  
• 00:20:00 In questa sezione, il video illustra come configurare l'ambiente per la programmazione OpenCL. Il primo passaggio prevede l'ottenimento dell'ID piattaforma, che viene eseguito con la funzione CL get platform IDs che restituisce il numero di piattaforme disponibili nel sistema. Successivamente, il video spiega come ottenere un dispositivo specifico all'interno della piattaforma in base alle preferenze dell'utente e come creare un contesto OpenCL, che è l'involucro di tutte le risorse come code di comando e buffer. Il tutorial consiglia di controllare il valore restituito per garantire il successo dell'operazione.
  
  
• 00:25:00 In questa sezione, il video spiega come creare e spostare i dati dalle matrici di input B e C e dalla matrice di output C, dichiarando i buffer e utilizzando le funzioni API OpenCL. Presumono che le matrici A, B e C siano già state dichiarate come array di tipo float e memorizzano i dati nello spazio degli indirizzi lineare nella memoria fisica. Il video mostra come utilizzare la funzione CL create buffer per dichiarare i buffer per le matrici A e B e la funzione CL Inc you write buffer per copiare i dati iniziali dalle matrici A e B nei buffer creati, che risiedono sul dispositivo. Il passaggio successivo consiste nell'allocare lo spazio per la matrice C, che viene dichiarata come buffer di sola scrittura della memoria CL poiché il dispositivo vi scrive i risultati del calcolo.
  
  
• 00:30:00 In questa sezione del video di YouTube "OpenCL Examples (I)", il relatore spiega il processo di recupero dei risultati da un dispositivo e copia della matrice risultante dal buffer C a un host. Viene mostrata la definizione dell'API C, con una spiegazione dei cinque argomenti per la creazione di un buffer, inclusi contesto, flag, dimensioni, puntatore host e valore restituito. Il relatore passa poi a spiegare il terzo passo importante nel programma OpenCL, che è la compilazione del kernel, utilizzando un semplice processo di compilazione per dispositivi FPGA. Il processo prevede la creazione e la costruzione di un programma e la selezione della giusta funzione del kernel dal codice sorgente. Infine, il relatore discute come inizializzare gli argomenti del kernel prima di eseguire il programma del kernel, utilizzando l'API OpenCL CL set kernel argument.
  
  
• 00:35:00 In questa sezione, l'oratore discute il processo di inizializzazione degli argomenti del kernel, l'impostazione delle dimensioni dei gruppi di lavoro, l'esecuzione del kernel e l'ottenimento dei risultati in un programma OpenCL. L'utente deve utilizzare l'API "CL create kernel" e specificare la dimensione e il valore dell'argomento del kernel, utilizzando un puntatore al valore effettivo. Il relatore sottolinea l'importanza di impostare accuratamente gli indici degli argomenti e di modificarli per ogni riga durante il copia e incolla. Le dimensioni del gruppo di lavoro locale e globale devono essere impostate per il numero di elementi di lavoro e gruppi di lavoro. Infine, il buffer CL unito viene utilizzato per leggere il buffer di output nella memoria dell'host, indicando i requisiti di sincronizzazione per una corretta esecuzione.
  
  
• 00:40:00 In questa sezione, il relatore introduce un esempio di moltiplicazione di matrici utilizzando OpenCL. Il codice sorgente per l'esempio di moltiplicazione di matrici è costituito da diversi file, incluso il programma lato host, il programma del kernel e un makefile per aiutare a compilare il progetto. Il programma lato host è scritto in C e include librerie standard e file di intestazione specifici per il framework OpenCL. L'esempio include matrici di input e dichiarazioni per variabili, incluso il numero di piattaforme e dispositivi, il contesto, il programma OpenCL e il kernel OpenCL. Il relatore spiega anche come compilare il codice sorgente del kernel e descrive le dimensioni delle matrici di input e la risultante matrice di output.
  
  
• 00:45:00 In questa sezione del video, il relatore mostra come ottenere ID dispositivo e piattaforma per OpenCL su Mac OS. Chiamando varie funzioni OpenCL come ottenere ID piattaforma e creare code di comando, l'oratore crea un contesto OpenCL e compila il programma. Spiegano inoltre che il codice mostrato supporta sia Mac OS che un SDK OpenCL e segnalerà un errore se viene eseguito su una piattaforma diversa.
  
  
• 00:50:00 In questa sezione, il video mostra come creare un oggetto programma utilizzando OpenCL su diverse piattaforme. Su Mac OS, l'oggetto programma viene creato da un file di codice sorgente del kernel, mentre su Altera FPGA OpenCL SDK, viene creato da un file binario generato tramite compilazione. Una volta che l'oggetto programma è stato creato, il programma kernel può essere compilato e la specifica funzione del kernel può essere selezionata da quell'oggetto programma. Alla fine di questa sezione, gli oggetti e le funzioni necessarie sono pronti per la sezione successiva del programma.
  
  
• 00:55:00 In questa sezione, il video illustra il processo di gestione del buffer, inclusa l'allocazione di un buffer per memorizzare i risultati della matrice e l'utilizzo di CL create buffer per creare buffer sul lato del dispositivo. Il video evidenzia anche l'importanza di controllare il valore di ritorno del CL in Q e il range colonnel per garantire un'esecuzione corretta, soprattutto quando si utilizzano FPGA. Inoltre, il video spiega il processo di verifica dei risultati stampando le risorse allocate sul lato host e le risorse OpenCL utilizzate e fornisce un semplice esempio di kernel di moltiplicazione in cui vengono utilizzati sette argomenti per eseguire operazioni di prodotto scalare tramite iterazioni.
  
  
• 01:00:00 In questa sezione del video, il relatore spiega due esempi di utilizzo di OpenCL. Il primo è la moltiplicazione di matrici. Il programma elabora due matrici e moltiplica i loro elementi corrispondenti per memorizzare il risultato in una terza matrice. Il secondo esempio è la rotazione dell'immagine, in cui il programma ruota i pixel di un'immagine in base a determinate formule. Queste formule tengono conto delle coordinate originali e nuove di ciascun pixel e dell'angolo di rotazione.
  
  
• 01:05:00 In questa sezione, il relatore discute come suddividere un problema di rotazione dell'immagine in problemi più piccoli utilizzando la scomposizione dell'input. Spiegano che le informazioni sui pixel dell'immagine verranno copiate in una nuova posizione attraverso calcoli indipendenti delle dimensioni x e y. I gruppi di lavoro vengono assegnati per calcolare la nuova posizione di ciascun pixel utilizzando il suo ID globale. Il relatore descrive inoltre in dettaglio come determinare i gruppi e le dimensioni degli elementi di lavoro e la funzione del kernel necessaria per completare questa operazione. L'obiettivo è creare un metodo più efficiente e scalabile per i calcoli della rotazione delle immagini.
  
  
• 01:10:00 In questa sezione, il presentatore video spiega come utilizzare OpenCL per ruotare un'immagine. La funzione del kernel viene utilizzata per identificare la posizione originale di un pixel, calcolare la nuova posizione del pixel utilizzando i parametri di rotazione, verificare il controllo dei confini per garantire che le nuove coordinate rientrino nella dimensione dell'immagine originale e copiare le informazioni sui pixel dalla posizione originale alla nuova sede. Il codice include anche binding C++ per l'API OpenCL e passaggi per interrogare piattaforme, acquisire dispositivi e dichiarare buffer per spostare i dati dalla memoria host al buffer del dispositivo. Il buffer di sola lettura viene creato anche per garantire la sicurezza dei dati originali.
  
  
• 01:15:00 In questa sezione, il relatore spiega i passaggi necessari per eseguire una rotazione dell'immagine utilizzando OpenCL. Innanzitutto, l'immagine originale deve essere copiata in un buffer immagine. Quindi, il kernel viene compilato ed eseguito inizializzando il buffer di destinazione e impostando gli argomenti corretti del kernel, comprese le dimensioni dell'immagine originale ei parametri di rotazione. Il kernel viene eseguito con la dimensione del gruppo di lavoro globale e la dimensione del gruppo di lavoro locale. Infine, il risultato viene riletto sull'host utilizzando il buffer di lettura in Q. Il relatore mostra anche il codice sorgente di esempio per la rotazione delle immagini, che include file di intestazione, funzioni di utilità, ID di piattaforma e dispositivo, code di comando, oggetti del programma e del kernel e buffer di input/output per le immagini originali e ruotate.
  
  
• 01:20:00 In questa sezione, il video illustra il processo di rotazione di un'immagine utilizzando OpenCL. L'host legge l'immagine in formato BMP e la converte in un array di numeri in virgola mobile memorizzati nel buffer dell'immagine di input. Il buffer di output sull'host viene creato e inizializzato con numeri casuali. La piattaforma viene interrogata per trovare i dispositivi sulla piattaforma e creare un contesto e una coda di comando. Vengono creati gli oggetti programma e kernel e vengono creati i buffer lato dispositivo per memorizzare l'immagine originale e ruotata. L'immagine originale viene copiata nel buffer sul lato del dispositivo e vengono impostati gli argomenti del kernel. Il kernel viene eseguito istanziandolo con le dimensioni del gruppo di lavoro globale e locale. Il valore restituito viene verificato per garantire che il kernel sia stato eseguito correttamente.
  
  
• 01:25:00 In questa sezione, il relatore fornisce una panoramica della rotazione dell'immagine utilizzando OpenCL. Dopo aver completato il kernel, i dati di output vengono riletti nell'host utilizzando il puntatore alla memoria globale sul lato del dispositivo e viene fornito un buffer host per memorizzare l'immagine. La formattazione BMP è coinvolta nel processo e una funzione di utilità chiamata write BMP float viene utilizzata per creare un nuovo file BMP che mostra il risultato. La funzione del kernel è descritta in dettaglio, dove i puntatori del buffer di destinazione e di origine vengono passati insieme alle dimensioni dell'immagine e ai parametri di rotazione. Viene utilizzata la formula per il calcolo delle nuove coordinate di ciascun pixel e viene applicato un controllo del contorno prima di copiare le informazioni sui pixel dalla posizione originale alla nuova posizione. Il processo è dimostrato con un esempio di rotazione dell'immagine di un gatto di 45 gradi.
  
  
• 01:30:00 In questa sezione, il relatore spiega il concetto di filtraggio delle immagini utilizzando OpenCL. Descrive il processo di utilizzo di un filtro 3x3 per moltiplicare e sommare i valori dei pixel vicini per ottenere il nuovo valore dei pixel filtrati. Sottolinea inoltre la necessità di prestare attenzione quando si tratta di pixel vicino al confine che hanno meno pixel vicini per applicare il filtro. Il relatore mostra quindi diversi tipi di filtri immagine che possono essere applicati a un'immagine originale utilizzando OpenCL. Successivamente, presenta un esempio di implementazione della funzione di convoluzione dell'immagine con due cicli for nidificati che attraversano ogni pixel dell'immagine e un terzo ciclo che attraversa gli elementi nel filtro.
  
  
• 01:35:00 In questa sezione, il relatore parla della struttura dei dati immagine in OpenGL, che è un tipo opaco mantenuto come struttura multidimensionale e utilizzato per i tipi di dati immagine. A differenza dei tipi interi o puntatori, le immagini non possono essere visualizzate direttamente attraverso i punti in un dispositivo e i relativi valori in pixel possono essere specificati come valori float o interi. La creazione di oggetti immagine sul lato del dispositivo consente alle unità di calcolo OpenCL di leggere e scrivere nuovi pixel sugli oggetti immagine ed è utile per sequenze di istruzioni lunghe e ottimizzate specifiche per l'elaborazione dei dati delle immagini o i processori grafici. Il relatore spiega anche come creare un buffer dell'immagine di origine, un oggetto immagine di output e un filtro copiando i dati dell'immagine e del filtro sul dispositivo utilizzando API come CL Write Image e CL Create Buffer.
  
  
• 01:40:00 In questa sezione, il relatore introduce il concetto di campionatore OpenCL, che è un oggetto utilizzato per descrivere come accedere a un'immagine. Il campionatore viene creato utilizzando la funzione API che prende il contesto come argomento e definisce se le coordinate saranno normalizzate o meno. Viene definita anche la modalità di indirizzamento, che gestisce il modo in cui vengono gestite le coordinate dell'immagine quando sono fuori portata. La modalità di filtraggio specifica il filtro che deve essere applicato quando le coordinate cadono tra i pixel. Viene inoltre introdotta una funzione del kernel denominata convolution, che accetta oggetti immagine 2D in input e in output, un filtro float costante per memorizzare i valori del filtro e l'oggetto sampler. La funzione del kernel legge gli elementi di dati dall'oggetto immagine e restituisce un vettore di quattro numeri in virgola mobile per eseguire l'aritmetica sui dati dell'immagine.
  
  
• 01:45:00 In questa sezione, il relatore spiega come eseguire operazioni su vettori in virgola mobile utilizzando un vettore in virgola mobile a quattro elementi. Eseguono il processo di inizializzazione dell'indice del filtro, la dichiarazione delle variabili per le coordinate a due elementi, l'iterazione delle righe del filtro e il calcolo delle coordinate in due dimensioni. Il pixel viene letto dall'oggetto immagine utilizzando la funzione read image F e moltiplicato per il valore del pixel del filtro, con il valore aggiornato memorizzato nell'immagine di output. Infine, l'immagine viene riletta utilizzando una funzione CL ink you read image.
  
  
• 01:50:00 In questa sezione viene discusso il codice per OpenCL Examples (I), che fornisce filtri da utilizzare nell'elaborazione delle immagini. Il programma assegna dimensioni e valori diversi a ciascun tipo di filtro e utilizza funzioni di supporto per inizializzare i valori del filtro e leggere i dati dell'immagine BMP da un file. L'individuazione della piattaforma e del dispositivo viene eseguita prima di creare le immagini di input e output, nonché il buffer del filtro. Una volta inizializzato, il campionatore imposta il modo in cui verranno elaborati i pixel che escono dal limite prima di eseguire il kernel con i parametri di filtro appropriati. La dimensione globale è impostata sul numero di colonne e righe nell'immagine.
  
  
• 01:55:00 In questa sezione, l'oratore dimostra un esempio di utilizzo di OpenCL per eseguire un filtro di convoluzione su un'immagine. Il processo prevede l'impostazione di un kernel che elabora l'intera immagine e utilizza una dimensione locale di 8 per 8 elementi di lavoro in un gruppo in una dimensione di dati. L'immagine di output viene archiviata sul lato del dispositivo e può essere riletta nell'host utilizzando l'immagine di lettura CL. I risultati vengono quindi confrontati con un'immagine di riferimento filtrata generata eseguendo il filtro sul lato host. Le due immagini sono visivamente identiche, verificando i risultati. Infine, vengono liberate le risorse sia sul lato host che sul lato dispositivo.

[MetaQuotes]

Un confronto tra SYCL, OpenCL, CUDA e OpenMP per la classificazione dei vettori di supporto massivamente paralleli ( WOCL / SYCLcon 2022 )

Un confronto tra SYCL, OpenCL, CUDA e OpenMP per la classificazione dei vettori di supporto massivamente paralleli

Il video confronta le prestazioni di SYCL, OpenCL, CUDA e OpenMP su diverse piattaforme hardware per la classificazione di macchine vettoriali a supporto massivamente parallelo. Il relatore spiega la parallelizzazione della moltiplicazione matrice-vettore con un'implementazione chiamata Parallel Fibonacci, che supporta l'esecuzione multigpu, ma solo la classificazione binaria e calcoli densi. L'hardware utilizzato per i test include GPU Nvidia A100 e RTX 380, GPU AMD Radeon Pro 7 e CPU Intel Core E9-10-09020X. I risultati mostrano che CUDA è il backend più veloce per le GPU Nvidia, mentre OpenCL è il backend più veloce per le CPU. SYCL è user-friendly, mentre Hipsicle è più veloce di DPC++ e OpenCL per un uso economico. Inoltre, il relatore discute il lavoro futuro, come l'analisi delle prestazioni sugli FPGA, l'aggiunta del supporto per i sistemi distribuiti tramite MPI e l'utilizzo di calcoli di precisione mista e hardware speciale di apprendimento automatico come i tensor core di NVIDIA.

• 00:00:00 In questa sezione del video, il relatore introduce un confronto tra diversi linguaggi di programmazione parallela, tra cui SYCL, OpenCL, CUDA e OpenMP, con particolare attenzione al loro utilizzo per la classificazione SVM (Massively Parallel Support Vector Machine) su hardware multivendor. Il relatore introduce la macchina vettoriale di supporto e delinea il suo utilizzo nell'apprendimento automatico supervisionato per la classificazione binaria. Tuttavia, le macchine vettoriali di supporto convenzionali hanno un problema in quanto risolvono un problema di programmazione quadratico convesso in modo sequenziale. Per risolvere questo problema, l'oratore utilizza la formulazione della macchina vettoriale di supporto dei minimi quadrati, che riduce il problema alla risoluzione di un sistema di equazioni lineari. L'oratore discute anche i dettagli di implementazione della loro libreria, che si chiama Parallel Fibonacci.
  
  
• 00:05:00 In questa sezione, l'oratore spiega il PLSS VM che è scritto nel moderno C++. Utilizzando un singolo parametro di modello, è possibile passare da tipi a virgola mobile a precisione singola a doppia precisione. Il relatore parla anche della parallelizzazione della moltiplicazione matrice-vettore nell'algoritmo CG, in quanto è la parte computazionalmente più estesa dell'algoritmo. Hanno implementato quattro diversi backend (OpenMP, CUDA, OpenCL, Signal) e supportato l'esecuzione multigpu. Tuttavia, attualmente sono supportati solo la classificazione binaria e i calcoli densi e non supportano la classificazione multiclasse per impostazione predefinita. Inoltre, il backend OpenMP si discosta notevolmente dalle altre implementazioni e per i backend GPU (CUDA, OpenCL e SYCL) hanno implementato un CG e lo utilizzano per tutti e tre i backend per ridurre la duplicazione del codice e potenziali bug.
  
  
• 00:10:00 In questa sezione del video viene spiegato l'hardware utilizzato e la metodologia per i test. L'attenzione si concentra su quattro diverse piattaforme, vale a dire le GPU Nvidia A100 e RTX 380, la GPU AMD Radeon Pro 7 e la CPU Intel Core E9-10-09020X, e i risultati per questi sono discussi. Vengono esaminati il ridimensionamento N-point per le GPU Nvidia A100 e RTX 380 e il ridimensionamento dei punti dati e delle funzionalità per la GPU AMD Radeon Pro 7 e si è riscontrato che i tempi di esecuzione aumentano in modo simile con il numero di punti dati su entrambe le GPU NVIDIA GPU. Tra questi, Cuda risulta essere il backend più veloce seguito da OpenCL e il modello roofline generato con il calcolo N-site ha mostrato che le formulazioni gerarchiche del kernel tendono ad essere più legate alla memoria rispetto alle loro controparti ND-range. Nel complesso, i tempi di autonomia per AMD sono superiori a quelli per NVIDIA.
  
  
• 00:15:00 In questa sezione, il video illustra il confronto delle prestazioni di SYCL, OpenCL, CUDA e OpenMP su diverse piattaforme hardware. Le GPU Nvidia non hanno mostrato alcun aumento del tempo di esecuzione e il backend più veloce è stato OpenCL. Tuttavia, la GPU AMD ha avuto prestazioni peggiori del previsto, probabilmente a causa della mancata messa a punto delle dimensioni dei blocchi. La CPU Intel Core E9 aveva un comportamento simile alle GPU Nvidia, con OpenCL come backend più veloce. DPC++ è stato il più veloce ad eccezione di piccoli set di dati in cui OpenMP era più veloce. La formulazione del kernel gerarchico DPC++ era più lenta della sua controparte indie su tutte le piattaforme hardware, indicando un potenziale di ottimizzazione. Infine, l'overhead di compilazione cheat di OpenCL è stato più veloce sulle GPU Nvidia e più lento sulla GPU Intel Iris Xe Max, ma con il caching integrato, l'overhead può essere ridotto nelle successive esecuzioni.
  
  
• 00:20:00 In questa sezione della trascrizione, il relatore discute i risultati dei loro test su vari linguaggi di programmazione parallela e framework per il targeting di hardware di diversi fornitori, come NVIDIA, AMD e Intel. Notano che se hai solo bisogno di scegliere come target le GPU NVIDIA, CUDA è ancora l'opzione migliore, poiché ha avuto le prestazioni più veloci nei loro test. Per il targeting solo delle CPU, OpenMP è un buon inizio, anche se non ha avuto le migliori prestazioni nei loro test. Se devi scegliere come target hardware di fornitori diversi, si consiglia OpenCL o SYCL, sebbene SYCL sia migliore se stai implementando un nuovo algoritmo da zero perché è più intuitivo. Hipsicle è l'opzione migliore per un utilizzo economico e più veloce di DPC++ e OpenCL su GPU e prevede di ottimizzare il proprio backend OpenMP e indagare su altre implementazioni di segnali come ComputeCPP in futuro.
  
  
• 00:25:00 In questa sezione, il relatore conclude il video discutendo il lavoro futuro e i miglioramenti all'implementazione della classificazione dei vettori di supporto utilizzando vari framework di calcolo parallelo. Hanno in programma di studiare le prestazioni su hardware diverso come FPGA, aggiungere il supporto per i sistemi distribuiti tramite MPI ed esplorare l'impatto dell'utilizzo di calcoli di precisione mista e hardware speciale di apprendimento automatico come i tensor core di NVIDIA. Ritengono che questi miglioramenti aumenteranno la velocità e l'efficienza della loro implementazione su set di dati più grandi.

[MetaQuotes]

Raggiungere un C++ ancora più ricco nei kernel OpenCL con l'uso di libclcxx ( WOCL / SYCLcon 2022 )

Raggiungere un C++ ancora più ricco nei kernel OpenCL con l'uso di libclcxx

Il video illustra l'uso di libclcxx per consentire l'integrazione delle librerie C++ nello sviluppo del kernel open source. Il progetto integra i tratti di tipo, una libreria essenziale per la meta programmazione in C++, con l'obiettivo di esporre più funzionalità C++ agli sviluppatori. Il video mostra come la libreria dei tratti di tipo può ottimizzare le prestazioni dei kernel OpenCL attraverso la sua capacità di manipolare lo spazio degli indirizzi e i tipi di vettore. Il video incoraggia gli sviluppatori a sperimentare con la libreria e contribuire a ridurre i cicli di sviluppo ottenendo la massima compatibilità con C++. La libreria fornisce la documentazione sull'ossigeno in uno stile simile alle pagine di riferimento C++, facilitando agli sviluppatori la navigazione attraverso le nuove funzionalità.

• 00:00:00 In questa sezione, Stulova di Anastasia discute l'uso di lipclcxx per consentire l'uso delle librerie C++ nello sviluppo del kernel open source. Sebbene C++ per il linguaggio del kernel OpenCL abbia funzionalità C++, manca il supporto della libreria, il che rende importante affrontare la limitazione presentata. Di conseguenza, è stato creato il progetto leap clcxx, integrando lipcxcxx, con l'obiettivo di esporre più funzionalità C++ agli sviluppatori del kernel open source. Inoltre, Tulva sostiene che i typetrait sono una libreria essenziale per facilitare completamente la meta programmazione in C++ ed estende lo spazio dei nomi std per fornire specializzazioni per i tratti esistenti aggiungendo nuovi tratti per il tipo di vettore a celle aperte, tra gli altri. La nuova libreria fornisce la documentazione sull'ossigeno in uno stile simile alle pagine di riferimento C++, facilitando agli sviluppatori la navigazione attraverso le nuove funzionalità.
  
  
• 00:05:00 In questa sezione, il video illustra come l'uso della libreria dei tratti di tipo può migliorare le prestazioni dei kernel OpenCL, in particolare per quanto riguarda lo spazio degli indirizzi e gli scambi di vettori. Il video fornisce esempi che dimostrano come la libreria può essere utilizzata per creare una funzione modello per diversi tipi di puntatore e come la rimozione dello spazio degli indirizzi dal tipo può risolvere i problemi nell'ambiente OpenCL. Inoltre, il video mostra come l'inclusione di scambi di dimensioni vettoriali può rendere i calcoli più efficienti e mette in evidenza come l'implementazione di algoritmi di riduzione può essere adattata per tipi di vettori. Nel complesso, l'uso di commerci di tipi nei kernel OpenCL può portare a una programmazione C++ ancora più ricca.
  
  
• 00:10:00 In questa sezione, il relatore spiega come definire la funzione add alarms nei kernel OpenCL utilizzando la dimensione del vettore come condizione. Chiariscono che per diverse dimensioni vettoriali viene scelta un'implementazione diversa e se il tipo passato non è un tipo vettoriale, verrà restituito un elemento dal buffer. Il relatore invita inoltre gli sviluppatori a sperimentare e contribuire ad ottenere la massima compatibilità con C++ per ridurre i cicli di sviluppo. Richiedono feedback su funzionalità mancanti o bug e incoraggiano a partecipare a una discussione su un problema esistente nella pagina del progetto.

[MetaQuotes]

SYCL oltre OpenCL: l'architettura, lo stato attuale e la direzione futura di hipSYCL ( IWOCL / SYCLcon 2020 )

SYCL oltre OpenCL: l'architettura, lo stato attuale e la direzione futura di hipSYCL

Il progetto hipSYCL è un'implementazione open source di SYCL che si rivolge alle GPU attraverso il modello di programmazione HIP anziché OpenCL. Consiste in un componente del compilatore, un'interfaccia falce e un runtime sicuro. Il compilatore sicuro identifica i kernel, gestisce l'allocazione della memoria locale e implementa un meccanismo di segnalazione. La funzione dispatch crea elementi specifici basati su kernel forniti dall'utente e le funzioni ottimizzate possono essere definite con rock prim. La direzione futura è consentire più back-end e rimuovere le restrizioni sul modello di compilazione statica. Il modello di invio delle operazioni sta passando a un invio in batch per una maggiore velocità effettiva delle attività e hipSYCL è interoperabile a livello di codice sorgente, consentendo la combinazione e la corrispondenza con hip e CUDA. Trattandosi di un progetto open-source, i contributori sono i benvenuti.

• 00:00:00 In questa sezione, il relatore discute la motivazione alla base del progetto hipSYCL, che è un'implementazione SYCL open source che si rivolge direttamente alle GPU attraverso il modello di programmazione HIP invece di utilizzare OpenCL. L'obiettivo è ottimizzare il codice e semplificare l'utilizzo di profiler e debugger forniti dal fornitore, evitando l'attrito di adozione che può verificarsi con altri modelli di programmazione. Il relatore confronta anche hipSYCL con altre soluzioni disponibili per l'interoperabilità SYCL e CUDA, ponendo hipSYCL all'estremità dell'interoperabilità CUDA della scala grazie al suo utilizzo del modello di programmazione HIP.
  
  
• 00:05:00 In questa sezione, il video spiega come funziona hipSYCL e i suoi tre componenti principali: un componente del compilatore, un'interfaccia a falce e un runtime sicuro. Il componente compilatore consente al compilatore di comprendere sia CUDA che falce, rendendo possibile l'interoperabilità a livello di codice sorgente. Il runtime sicuro si occupa della gestione dei dati e della pianificazione delle attività, mentre l'interfaccia a falce è costituita da classi e funzioni nello spazio dei nomi a falce. Inoltre, il video menziona che la falce è una soluzione flessibile che può essere utilizzata per creare implementazioni che coprano tutti i possibili casi d'uso. Per indirizzare gli acceleratori, è necessario un componente del compilatore dedicato, che identifichi i kernel e li compili per l'acceleratore.
  
  
• 00:10:00 In questa sezione del video, il relatore spiega come funziona il compilatore sicuro in hipSYCL. Spiegano che il compilatore deve identificare i kernel e determinare quale codice deve essere inviato al dispositivo, quindi gestire il modo in cui i kernel vengono allocati nella memoria locale. Anche la funzione diagnostica specifica della falce è menzionata come una priorità per lo sviluppo futuro. L'oratore spiega che l'utilizzo del componente del compilatore hip secure è relativamente semplice con l'uso di un wrapper del compilatore chiamato Cycle CC, che nasconde la complessità coinvolta, come l'invocazione e il collegamento del compilatore correttamente, e come impostare i percorsi di inclusione. Discutono di come invocare i kernel richieda un po' di inganno e spiegano come si fa. Inoltre, il meccanismo di segnalazione al momento che utilizza Coroutine e gli eventi Hip viene utilizzato in hipSYCL per l'elaborazione dinamica fuori ordine, ma viene discusso il lato negativo di questo.
  
  
• 00:15:00 In questa sezione, il relatore discute come la funzione dispatch viene utilizzata per creare un elemento specifico basato sul kernel fornito dall'utente e come il parallelo for e secure può essere implementato istanziando la funzione dispatch con il kernel fornito dall'utente nocciolo. Tuttavia, inizialmente, tutto il codice viene passato come codice host, dove il kernel fornito dall'utente è un lambda host e non può essere richiamato direttamente, quindi aggiungono un attributo fittizio chiamato kernel HIP, che verrà sostituito solo da un clic appropriato su l'attributo una volta completata l'analisi iniziale e il plug-in hipSYCL ha preso il sopravvento. Raggiungono buone prestazioni di memoria sia per hipSYCL che per CUDA e, utilizzando hipSYCL, possono ottenere l'interoperabilità hip e CUDA a livello di codice sorgente.
  
  
• 00:20:00 In questa sezione, il relatore discute come implementare una riduzione ottimizzata utilizzando il prim rock con epsilon. Suggeriscono di definire una funzione ottimizzata con la piattaforma macro zip secure cuda o fianchi una buona piattaforma rockem, contrassegnata come host e dispositivo. Se si esegue la compilazione per la piattaforma di destinazione, viene chiamata la funzione ottimizzata, mentre in caso contrario viene chiamata una funzione di fallback. L'oratore spiega che le librerie ottimizzate dal fornitore come rock prim ottengono prestazioni più veloci perché hanno una maggiore conoscenza dell'hardware di destinazione e sebbene hipSYCL sia ancora pre-conformità e manchi di alcune funzionalità come immagini e interoperabilità a stato aperto, è ancora utilizzabile per davvero -applicazioni mondiali. Tuttavia, una caduta parallela organizzata sul pacchetto CPU è lenta a causa di un problema con le implementazioni del ciclo di libreria puro.
  
  
• 00:25:00 In questa sezione, il relatore discute le differenze di prestazioni utilizzando la forma parallela di base o la forma parallela gerarchica rispetto all'utilizzo della forma parallela nd range con hipSYCL su una CPU. Quest'ultimo si traduce in un'enorme perdita di prestazioni perché richiede l'avvio di tante minacce quanti sono gli elementi di lavoro in ciascun gruppo di lavoro. L'oratore parla quindi della direzione futura di hipSYCL, ovvero creare un nuovo runtime che consenta l'attivazione simultanea di backend arbitrari e rimuova le restrizioni relative al modello di compilazione statica. Stanno inoltre passando a una mappatura end-to-end in cui n ciclico utilizza la mappa su M code back-end per ottimizzare l'utilizzo dell'hardware. Inoltre, ci sarà una netta separazione tra il nuovo runtime e l'interfaccia SYCL esistente per semplificare la manutenzione e la sperimentazione.
  
  
• 00:30:00 In questa sezione, il relatore discute i miglioramenti apportati al modello di presentazione delle operazioni in hipSYCL. Stanno passando da un modello di invio basato su segnale a un modello di invio in batch, in cui la segnalazione al runtime che le cose sono state completate avviene solo una volta per batch di operazioni, consentendo una maggiore velocità effettiva delle attività. Il relatore spiega il processo in cui le operazioni vengono sottoposte e poi elaborate dal deck builder, che le raccoglie e le ordina. Lo scheduler del mazzo quindi assegna segnali di esecuzione alle operazioni, che poi vanno agli esecutori back-end per eseguire il kernel e determinare quali operazioni di sincronizzazione sono necessarie. La stima dei costi di questa configurazione torna quindi allo schedulatore del mazzo per ottimizzare ulteriormente o inviare le operazioni così come sono. Il relatore fornisce anche informazioni su come ottenere hipSYCL attraverso i repository dei pacchetti e gli script di installazione.
  
  
• 00:35:00 In questa sezione viene spiegato che hipSYCL è un'implementazione di SICL per CPU, GPU video e GPU AMD. È basato su API di fornitori di basso livello hip e CUDA, il che lo rende interoperabile a livello di codice sorgente. Ciò consente agli sviluppatori di combinare e abbinare hip e CUDA, rendendolo adatto a una gamma di HPC e altri casi d'uso che richiedono l'accesso alle più recenti ottimizzazioni hardware di basso livello o librerie ottimizzate dal fornitore. Inoltre, consente la creazione di percorsi di codice altamente ottimizzati per hardware specifico e le prestazioni del kernel dovrebbero essere alla pari con hip o CUDA regolari. Essendo un progetto open source, i contributori sono sempre i benvenuti e le persone interessate possono saperne di più sulla pagina GitHub.

[MetaQuotes]

SYCL: il futuro è aperto, parallelo ed eterogeneo (Core C++ 2022 )

SYCL: il futuro è aperto, parallelo ed eterogeneo

In questo video sulla programmazione SYCL, il relatore sottolinea la necessità di aumentare il livello di astrazione per aumentare la produttività e attrarre più sviluppatori, poiché i modelli complessi richiedono una maggiore potenza di calcolo, soddisfatta dai sistemi di accelerazione. Viene sottolineata l'importanza della portabilità del software e di OneAPI, in quanto consente ai dispositivi di lavorare su CPU, GPU e altri dispositivi. Vengono inoltre discussi i vantaggi di SYCL, un modello di programmazione aperto, parallelo ed eterogeneo, con il relatore che evidenzia le numerose risorse e strumenti online disponibili per ottimizzare il codice e migliorare le prestazioni. L'oratore incoraggia gli spettatori a visitare oneapi.io e il loro canale YouTube per risorse e supporto.

• 00:00:00 In questa sezione, il relatore discute la necessità di aumentare il livello di astrazione per aumentare la produttività e attrarre più sviluppatori. Man mano che i modelli diventano più complessi, la richiesta di potenza di calcolo aumenta rapidamente. L'oratore menziona il ninja gap, che si riferisce alla difficoltà di trovare e assumere esperti di livello inferiore come sviluppatori di assemblaggio o Cuda. Aumentare il livello di astrazione porta alla perdita di prestazioni, motivo per cui gli acceleratori AI come GPU e GAUDI sono necessari per soddisfare la crescente domanda di potenza di calcolo.
  
  
• 00:05:00 In questa sezione, il relatore discute la necessità di acceleratori per ottenere le prestazioni più veloci, ma osserva che un acceleratore non è sufficiente per coprire l'intera gamma di applicazioni. Sono richiesti sistemi eterogenei, che combinino CPU e acceleratori come acceleratori e CPU di tipo ASIC. Il relatore sottolinea l'importanza della portabilità del software e la capacità del codice di funzionare su qualsiasi macchina o dispositivo, indipendentemente dall'hardware utilizzato, senza la necessità di ricodificare, ricompilare o ricostruire per ogni piattaforma o sistema operativo. OneAPI è uno sforzo del settore per semplificare gli stack software, unificando librerie e strumenti per garantire la portabilità del software aperta, gratuita e cross-device, il che significa che gli stack software possono funzionare su CPU, GPU e altri dispositivi. OneAPI offre un toolkit di base che ha tutto il necessario per iniziare.
  
  
• 00:10:00 In questa sezione, il relatore discute la potenza dell'utilizzo del toolkit basato su OneAPI e il concetto del compilatore Data Policy++, progettato per aggiungere eterogeneità alle librerie C++. Utilizzando criteri predefiniti, puoi accedere facilmente alla CPU o alla GPU senza dover conoscere troppo i dettagli di livello inferiore su OpenCL o CUDA. Il compilatore offre la possibilità di controllare e disgiungere i ricordi che si trovano ovunque, gestire i codici di eccezione e creare calcoli paralleli.
  
  
• 00:15:00 In questa sezione del video, il relatore spiega che per avere buone capacità informatiche eterogenee, sono necessarie tre cose. Il primo è la capacità di scoprire il dispositivo e ottenere informazioni su di esso. È qui che l'altoparlante mostra un semplice pezzo di codice che rileva ed elenca tutti i dispositivi collegati al sistema. Il secondo requisito sono le informazioni sullo stato dei dispositivi in tempo reale, che consentono l'utilizzo e il monitoraggio della temperatura e consentono inoltre agli utenti di passare dalla CPU alla GPU. Il terzo requisito è la capacità di scambiare memoria in modo efficiente e senza soluzione di continuità tra il dispositivo e l'host, che si ottiene attraverso due modi principali in SYCL: buffer e memoria grafica unificata.
  
  
• 00:20:00 In questa sezione, il relatore spiega i vantaggi dell'utilizzo di SYCL, un modello di programmazione aperto, parallelo ed eterogeneo. Aggiungendo SYCL a C++, è possibile scrivere codice che può essere eseguito su più dispositivi, tra cui GPU, CPU, ARM e FPGA. L'oratore afferma che esistono numerose risorse online ed esempi su come far funzionare SYCL con più dispositivi. Intel Advisor è uno strumento consigliato dal relatore, che può aiutare a ottimizzare il codice e offre la possibilità di scaricare funzioni specifiche su una GPU. Il relatore sottolinea l'importanza dell'utilizzo di questo strumento, che può rendere il codice molto più veloce e migliorare le prestazioni complessive del programma.
  
  
• 00:25:00 In questa sezione, il relatore promuove l'utilizzo di SYCL come il modo più rapido per rendere disponibile il codice su più dispositivi di più fornitori e incoraggia gli spettatori a visitare il sito Web oneapi.io e il suo canale YouTube per risorse e supporto. Cita anche la possibilità che SYCL sia più veloce di CUDA in alcuni esempi, ma sottolinea che il vantaggio principale di SYCL è la sua portabilità, in quanto consente la codifica su un'unica piattaforma che può quindi essere eseguita su vari dispositivi, liberando la necessità di creare più decisioni di codifica per diversi dispositivi. Inoltre, il relatore si offre di rispondere a qualsiasi domanda e di fornire risorse, come i notebook Jupyter e l'accesso a Intel Devcloud, per aiutare gli utenti a iniziare con SYCL.

[MetaQuotes]

Accelerazione GPU in Python

Accelerazione GPU in Python

Il video spiega come ottenere l'accelerazione GPU nella programmazione Python sfruttando la potenza delle unità di elaborazione grafica, che possono fornire una velocità fino a 10 volte superiore con il parallelismo dei dati. Vengono brevemente introdotti i due standard per il GPU Computing, OpenCL e CUDA, e il video dimostra l'uso di Pi OpenCL e CUDA per la moltiplicazione di matrici in Python. Il relatore spiega l'uso della memoria globale e del kernel per la moltiplicazione di matrici e discute anche l'algoritmo utilizzato per calcolare un elemento nel prodotto matrice-matrice. Viene discusso il codice per l'accelerazione GPU in C e Python, con enfasi sulla comprensione delle rappresentazioni interne delle matrici e dell'allocazione della memoria. Gli esercizi della lezione forniscono una base per un'ulteriore esplorazione del GPU Computing.

• 00:00:00 In questa sezione, il video introduce il GPU Computing come un modo per ottenere il parallelismo dei dati e accelerare i programmi sfruttando la potenza delle unità di elaborazione grafica, che possono elaborare miliardi di operazioni in virgola mobile al secondo e fornire una velocità di un fattore di 10. Vengono brevemente introdotti i due standard per il GPU Computing, OpenCL e CUDA, con esempi di GPU di fascia alta come Kepler, Pascal e Volta di Nvidia. L'aspetto massicciamente parallelo del GPU computing è enfatizzato come un modo per mantenere la GPU occupata, con la pianificazione di un numero sufficiente di thread spesso richiesta. Il video menziona anche le potenziali applicazioni degli acceleratori hardware in campo scientifico e ingegneristico.
  
  
• 00:05:00 In questa sezione del video, il relatore discute l'evoluzione dell'accelerazione GPU, da Kepler che ha avuto un picco di prestazioni di un teraflop alla generazione attuale che supera i 7,9 teraflop. Il modello di programmazione del calcolo massivamente parallelo segue un approccio a dati multipli a singola istruzione e i dati sono divisi in blocchi di thread e ogni blocco esegue almeno un thread. Il relatore tocca il linguaggio di calcolo aperto che è uno standard aperto per la programmazione parallela e copre il calcolo multi-core e multi-threading oltre al calcolo GPU.
  
  
• 00:10:00 In questa sezione, il relatore discute l'uso di OpenCL e Pi OpenCL per l'accelerazione GPU in Python. OpenCL è uno standard generale originariamente supportato sulle schede grafiche NVIDIA, ma è stato abbandonato. Tuttavia, funziona bene sui MacBook poiché è stato avviato da Apple. Pi OpenCL semplifica la programmazione OpenCL riducendo il codice boilerplate e consentendo una maggiore concentrazione sul kernel. Supporta anche gli array NumPy, ma le strutture dati sono più limitate a causa del parallelismo dei dati. Il relatore dimostra l'uso di Pi OpenCL per la moltiplicazione di matrici su due matrici intere a scopo di test.
  
  
• 00:15:00 In questa sezione, il relatore spiega come le GPU possono essere utilizzate per la moltiplicazione di matrici in Python utilizzando OpenCL. Iniziano con l'importazione delle librerie necessarie, tra cui OpenCL e NumPy. L'oratore nota inoltre che la scheda grafica utilizzata non supportava l'aritmetica a 64 bit, quindi hanno optato per l'aritmetica in virgola mobile a 32 bit. Quindi definiscono le matrici, generano numeri interi casuali e cambiano il loro tipo in una matrice di flusso a 32 bit. L'oratore spiega quindi il codice boilerplate richiesto per definire le controparti delle matrici sul dispositivo e creare le code. Infine, il relatore definisce il kernel per la moltiplicazione di matrici, che viene compilato quando il programma viene eseguito, e mostra come moltiplicare le matrici sulla GPU.
  
  
• 00:20:00 In questa sezione, il relatore spiega il concetto di "globale" nel contesto dell'accelerazione GPU nella programmazione Python. Global indica che le matrici risiedono nella memoria globale della scheda grafica, fornendo a ogni thread l'accesso ai dati. Le dimensioni vengono passate come numeri interi brevi, con ogni thread che ha un numero di identificazione univoco. Il processo di moltiplicazione della matrice beneficia dell'accelerazione della GPU poiché quasi ogni parte può essere eseguita in modo indipendente tramite l'indicizzazione di righe e colonne della matrice. Le matrici sono memorizzate in C-wise, come un lungo array, e i puntatori determinano le loro posizioni in memoria.
  
  
• 00:25:00 In questa sezione, il relatore spiega l'algoritmo in C per calcolare un elemento nel prodotto matrice-matrice e la potenziale accelerazione per la moltiplicazione matrice-matrice, che generalmente è un'operazione cubica nelle dimensioni delle matrici. Tuttavia, con l'uso di GPU e lanci del kernel, l'operazione può essere semplificata in modo lineare, portando a una massiccia riduzione dei costi e con conseguenti accelerazioni significative. Il relatore menziona anche che mentre il modo più semplice per eseguire l'operazione è tramite Python e senza la necessità di compilare esplicitamente, gli algoritmi reali utilizzati nei supercomputer fanno uso di memorie condivise sulle GPU e un processo di compilazione che va oltre quanto discusso nel video. Il relatore sottolinea l'idea che PiCUDA e PiOpenCL consentano ai programmatori di sviluppare codice a un livello superiore, senza doversi preoccupare dei processi di compilazione e collegamento di livello inferiore.
  
  
• 00:30:00 In questa sezione, il video parla dell'installazione di CUDA per l'accelerazione GPU in Python. Per utilizzare CUDA, un utente deve disporre di una GPU NVIDIA e dei driver installati. La lezione esamina le istruzioni per verificare se il sistema è impostato correttamente e il presentatore osserva che la tecnica è un calcolo parallelo altamente interattivo. Il docente spiega che si possono ottenere buone prestazioni da un laptop di fascia alta con una buona scheda grafica. Il corso mostra quindi la moltiplicazione di matrici come esempio. Il presentatore osserva che in genere è necessario disporre di un programma in esecuzione sulla CPU e la GPU accelera solo le parti che richiedono un'elevata intensità di calcolo. Infine, la lezione discute l'allocazione della memoria per le matrici corrispondenti sulla GPU e l'inizializzazione delle matrici risultanti, affermando che le allocazioni con NumPy sono migliori di quanto lo sarebbero con C. Inoltre, in questa fase non è necessaria alcuna compilazione.
  
  
• 00:35:00 In questa sezione viene discusso il codice per l'accelerazione GPU in C. Le matrici in C sono memorizzate in modo riga per riga e il codice sfrutta questo fatto. La sintassi per l'avvio di blocchi di thread in una struttura bidimensionale viene utilizzata per calcolare in modo esplicito i thread. Viene utilizzato un ciclo con parentesi esplicite per evitare l'aritmetica dei puntatori. La funzione assume le dimensioni ei puntatori ai dati, che includono le matrici A e B per l'input e la matrice dei risultati C_gpu. La copia dalla memoria al dispositivo deve terminare prima della stampa e la copia dalla memoria al dispositivo host deve essere eseguita prima di stampare i dati perché la stampa all'interno delle funzioni all'interno delle funzioni del kernel eseguite dalla GPU potrebbe non essere possibile. Infine, la discussione termina affermando che pyCUDA è più recente di piOpenCL e PyCUDA.
  
  
• 00:40:00 In questa sezione, il relatore discute l'accelerazione della GPU in Python, che è orientata verso CUDA ma ha anche degli sforzi in corso per funzionare su altre GPU. Si occupa sia della compilazione che dell'esecuzione, rendendo le esecuzioni successive molto più veloci. È possibile sviluppare kernel GPU in Python rimanendo all'interno dell'ambiente di scripting; tuttavia, è necessario comprendere come funzionano le GPU e come le matrici sono rappresentate internamente utilizzando la sintassi C. Gli esercizi della lezione sono a tempo indeterminato e possono fornire una base per un secondo progetto che esplora il GPU Computing. Nel complesso, questa era una sezione introduttiva che mirava a dare un'idea di come i programmatori e gli sviluppatori di software possono sviluppare funzioni che girano sulla GPU.

[MetaQuotes]

Presentazione di lancio di OpenCL 3.0 (IWOCL / SYCLcon 2020)

OpenCL 3.0 Avvia la presentazione

Il lancio di OpenCL 3.0 è discusso in questo video, con particolare attenzione alla sua importanza per la programmazione parallela di basso livello nel settore. OpenCL 3.0 non aggiunge nuove funzionalità all'API, ma fornisce un riallineamento dell'ecosistema per consentire a OpenCL di raggiungere più sviluppatori e dispositivi. Il relatore discute anche dell'aggiunta di estensioni per i processori DSP light, della roadmap per funzionalità future e del crescente ecosistema di compilatori di linguaggi kernel open source che possono generare kernel spirit per OpenCL Vulcan. Il feedback degli utenti è incoraggiato per aiutare a finalizzare le specifiche mentre il gruppo di lavoro si prepara per la prima ondata di implementazioni nei prossimi mesi.

• 00:00:00 In questa sezione, Neil Travis di NVIDIA e del gruppo Khronos discute il lancio di OpenCL 3.0 e l'importanza dello standard per la programmazione parallela di basso livello nel settore. OpenCL è ampiamente utilizzato dai fornitori di GPU e sempre più utilizzato da applicazioni, motori e librerie. Il lancio di OpenCL 3.0 fornisce un riallineamento dell'ecosistema anziché aggiungere nuove funzionalità all'API con l'intento di consentire a OpenCL di raggiungere ancora più sviluppatori e dispositivi. OpenCL 3.0 rende facoltative tutte le funzionalità 2x oltre il punto, consentendo ai fornitori di concentrarsi sulla fornitura delle funzionalità di cui hanno bisogno per i propri clienti e ripristina l'opportunità di alzare il livello delle funzionalità di base.
  
  
• 00:05:00 In questa sezione, viene spiegato che OpenCL 3.0 è una nuova specifica che viene fornita con un'API unificata progettata per interrogare tutte le funzionalità OpenCL 2.x con estensioni aggiunte per i processori di luce DSP per trasferire dati 2D e 3D tra globale e memorie locali in modo flessibile e asincrono tramite transazioni Direct Memory Access (DMA). Sebbene OpenCL 3.0 non includa la specifica OpenCL C++, altre implementazioni sono incoraggiate a utilizzare il compilatore front-end open source C++ per OpenCL per generare kernel Spir-V mescolando OpenCL C con gran parte di C++17. La roadmap per OpenCL include la spedizione di nuove funzionalità come estensioni prima per l'adozione da parte del settore, consentendo loro di maturare e essere collaudate prima di inserirle in future specifiche di base. Il gruppo di lavoro OpenCL vede anche i profili come uno strumento vitale per bilanciare la flessibilità di implementazione con la portabilità delle applicazioni ed evitare la frammentazione per i mercati target.
  
  
• 00:10:00 In questa sezione, il relatore discute il crescente ecosistema di compilatori di linguaggio kernel open source, che include clang e lvm, che possono generare spirit kernel per OpenCL Vulcan o per un'ulteriore traduzione in shader da eseguire su altre API come come metallo. Ciò abiliterebbe le applicazioni OpenCL su piattaforme Apple senza la necessità di utilizzare i driver OpenCL. Il presentatore menziona anche il progetto OpenCL 12, che traduce i kernel spirit generati da LLVM utilizzando una pipeline di conversione open source in DXi L, consentendo ai compilatori di linguaggi di innovare indipendentemente dai runtime. La specifica per OpenCL 3 è provvisoria e il feedback degli utenti è incoraggiato per aiutare a finalizzare la specifica mentre il gruppo di lavoro si prepara per la prima ondata di implementazioni nei prossimi mesi.