Inizia con la distribuzione Intel® per GDB* su host del sistema operativo Linux*
Inizia a utilizzare la distribuzione Intel® per GDB* per il debug delle applicazioni. Segui le istruzioni riportate di seguito per configurare il debugger in modo che esegua il debug delle applicazioni con i kernel scaricati su dispositivi CPU e GPU.
Intel® Distribution per GDB* è disponibile come parte di Intel® oneAPI Base Toolkit. Per ulteriori informazioni sui toolkit oneAPI, visitare il pagina del prodotto.
Visitare il Note di rilascio pagina per informazioni su funzionalità chiave, nuove funzionalità e problemi noti.
Puoi usare un SYCL* sample, Array Transform, per iniziare con la distribuzione Intel® per GDB*. La sample non genera errori e illustra semplicemente le funzionalità del debugger. Il codice elabora gli elementi dell'array di input a seconda che siano pari o dispari e produce un array di output. Puoi usare la sample per eseguire il debug su CPU o GPU, specificando il dispositivo scelto tramite un argomento della riga di comando. Si noti tuttavia che il debug della GPU potrebbe richiedere due sistemi e una configurazione aggiuntiva per il debug remoto.
Prerequisiti
Se intendi eseguire il debug su GPU, installa i driver GPU più recenti e configura il tuo sistema per utilizzarli. Fare riferimento al Guida all'installazione dei toolkit Intel® oneAPI per il sistema operativo Linux*. Seguire le istruzioni Installa i driver della GPU Intel per installare i driver GPU corrispondenti al tuo sistema.
Inoltre, puoi installare un'estensione per Visual Studio Code* per il debug della GPU con Intel® Distribution per GDB*. Fare riferimento al Utilizzo di Visual Studio Code con la Guida ai toolkit Intel® oneAPI.
Configura il debugger della GPU
Per configurare il debugger GPU, devi disporre dell'accesso root.
NOTA Durante il debug del kernel, la GPU viene arrestata e l'output video non è disponibile sul computer di destinazione. Per questo motivo, non è possibile eseguire il debug della GPU dal sistema di destinazione se la scheda GPU del sistema viene utilizzata anche per l'output grafico. In questo caso, connettiti alla macchina tramite ssh.
1. Se miri a eseguire il debug su GPU, è necessario un kernel Linux che supporti il debug della GPU.
a. Segui le istruzioni su Software Intel® per funzionalità GPU generiche per scaricare e installare i driver necessari.
b. Abilita il supporto per il debug i915 nel kernel:
a. Aprire un terminale.
b. Apri il grub file in /etc/default.
c. Nel grumo file, trova la riga GRUB_CMDLINE_LINUX_DEFAULT=””.
d. Inserisci il seguente testo tra virgolette (""):
i915.debug_eu=1
NOTA Per impostazione predefinita, il driver GPU non consente l'esecuzione dei carichi di lavoro su una GPU per più di un certo periodo di tempo. Il driver elimina tali carichi di lavoro a esecuzione prolungata reimpostando la GPU per evitare blocchi. Il meccanismo di hangcheck del driver è disabilitato se l'applicazione è in esecuzione nel debugger. Se prevedi di eseguire lunghi carichi di lavoro di calcolo anche senza che sia collegato un debugger, valuta la possibilità di fare domanda GPU: disabilita Hangcheck aggiungendo
i915.enable_hangcheck=0
allo stesso riga GRUB_CMDLINE_LINUX_DEFAULT.
c. Aggiorna GRUB affinché queste modifiche abbiano effetto:
sudo aggiornamento-grub
d. Riavviare.
2. Configura il tuo ambiente CLI estraendo lo script setvars che si trova nella root dell'installazione del tuo toolkit.
Linux (sudo):
fonte /opt/intel/oneapi/setvars.sh
Linux (utente):
fonte ~/intel/oneapi/setvars.sh
3. Ambiente di installazione
Utilizzare le seguenti variabili di ambiente per abilitare il supporto del debugger per Intel® oneAPI Level Zero:
esporta ZET_ENABLE_PROGRAM_DEBUGGING=1
esporta IGC_EnableGTLocationDebugging=1
4. Controllo del sistema
Quando tutto è pronto, esegui il seguente comando per confermare che la configurazione del sistema è affidabile:
python3 /percorso/to/intel/oneapi/diagnostics/latest/diagnostics.py –filter debugger_sys_check -force
Un possibile output di un sistema ben configurato è il seguente:
…
Risultati dei controlli:
================================================== ===============================
Nome del controllo: debugger_sys_check
Descrizione: questo controllo verifica se l'ambiente è pronto per utilizzare gdb (Intel(R) Distribution for GDB*).
Stato del risultato: PASS
Debug trovato.
libipt trovato.
libiga trovata.
il debug i915 è abilitato.
Variabili ambientali corrette. =================================================== ================================
1 CONTROLLO: 1 PASSATO, 0 FALLITO, 0 AVVISI, 0 ERRORI
Uscita console file: /path/to/logs/diagnostics_filter_debugger_sys_check_force.txt output JSON file: /percorso/to/diagnostics/logs/diagnostics_filter_debugger_sys_check_force.json …
Compilare il programma con le informazioni di debug
Puoi usare la sample, Array Transform, per iniziare rapidamente con il debugger dell'applicazione.
1. Per ottenere la sample, scegliere uno dei seguenti modi:
- Utilizza l'interfaccia a riga di comando oneAPI Sampbrowser per selezionare Array Transform dalla categoria Getting Started.
- Scarica da GitHub*.
2. Passare a src del file sampil progetto:
cd array-trasforma/src
3. Compilare l'applicazione abilitando le informazioni di debug (flag -g) e disattivando le ottimizzazioni (flag -O0).
La disabilitazione dell'ottimizzazione è consigliata per un ambiente di debug stabile e accurato. Questo aiuta a evitare la confusione causata dalle modifiche al codice dopo le ottimizzazioni del compilatore.
NOTA Puoi ancora compilare il programma con l'ottimizzazione abilitata (flag -O2), che può essere utile se miri al debug dell'assieme GPU.
Puoi compilare il programma in diversi modi. Le opzioni 1 e 2 utilizzano la compilazione just-in-time (JIT), consigliata per eseguire il debug di sample. L'opzione 3 utilizza la compilazione anticipata (AOT).
- Opzione 1. Puoi usare CMake file per configurare e costruire l'applicazione. Fare riferimento al LEGGIMI della sample per le istruzioni.
NOTA Il CMake file provvisto della sample passa già i flag -g -O0.
- Opzione 2. Per compilare l'array-transform.cpp sample applicazione senza CMake file, emettere i seguenti comandi:
icpx -fsycl -g -O0 trasformazione-array.cpp -o trasformazione-array
Se la compilazione e il collegamento vengono eseguiti separatamente, mantenere i flag -g -O0 al passaggio del collegamento. Il passaggio del collegamento è quando icpx traduce questi flag da passare al compilatore del dispositivo in fase di esecuzione. Exampon:
icpx -fsycl -g -O0 -c array-transform.cpp
icpx -fsycl -g -O0 trasformazione-array.o -o trasformazione-array
- Opzione 3. È possibile utilizzare la compilazione AOT per evitare tempi di compilazione JIT più lunghi in fase di esecuzione. La compilazione JIT può richiedere molto più tempo per i kernel di grandi dimensioni nel debugger. Per utilizzare la modalità di compilazione in anticipo:
• Per il debug su una GPU:
Specifica il dispositivo che utilizzerai per l'esecuzione del programma. Per esample, -device dg2-g10 per Intel® Data Center GPU Flex 140 Graphics. Per l'elenco delle opzioni supportate e ulteriori informazioni sulla compilazione AOT, fare riferimento a Guida e riferimenti per gli sviluppatori del compilatore Intel® oneAPI DPC++.
Per esempioampon:
icpx -fsycl -g -O0 -fsycl-targets=spir64_gen -Xs “-device dg2-g10” array-transform.cpp -o arraytransform
La compilazione anticipata richiede il compilatore offline OpenCLTM (OC Compiler LOC). Per ulteriori informazioni, fare riferimento alla sezione "Installare OpenCLTM Offline Compiler (OCLOC)" del Guida all'installazione.
• Per il debug su una CPU:
icpx -fsycl -g -O0 -fsycl-targets=spir64_x86_64 trasformazione-array.cpp -o trasformazione-array
Avvia una sessione di debug
Avvia la sessione di debug:
1. Avviare Intel® Distribution per GDB* come segue:
trasformazione array gdb-oneapi
Dovresti vedere il prompt (gdb).
2. Per assicurarti che il kernel venga scaricato sul dispositivo corretto, procedi come segue. Quando esegui il comando run dal prompt (gdb), passa il file processore, GPU (processore di elaborazione dati) or acceleratore discussione:
- Per il debug sulla CPU:
eseguire cpu
Exampl'output:
[SYCL] Dispositivo in uso: [CPU Intel(R) Core(TM) i7-9750H a 2.60 GHz] da [Intel(R) OpenCL]- Per il debug sulla GPU:
eseguire gpu
Exampl'output:
[SYCL] Dispositivo utilizzato: [Intel(R) Data Center GPU Flex Series 140 [0x56c1]] da [Intel(R) LevelZero]- Per il debug sull'emulatore FPGA:
acceleratore di corsa
Exampl'output:
[SYCL] Utilizzo del dispositivo: [Intel(R) FPGA Emulation Device] da [Intel(R) FPGA Emulation Platform for OpenCL(TM) software]NOTA I parametri cpu, gpu e accelerator sono specifici dell'applicazione Array Transform.
3. Per uscire dalla distribuzione Intel® per GDB*:
esentato
Per comodità, i comandi comuni di Intel® Distribution per GDB* sono forniti nel file Foglio di riferimento.
Per eseguire il debug di Array Transform sample e saperne di più su Intel® Distribution per GDB*, esaminare gli scenari di debug di base utilizzando il file Esercitazione.
Saperne di più
| Documento | Descrizione |
| Tutorial: Debug con distribuzione Intel® per GDB* | Questo documento descrive gli scenari di base da seguire durante il debug di SYCL* e OpenCL con Intel® Distribution per GDB*. |
| Guida dell'utente di Intel® Distribution per GDB* | Questo documento descrive tutte le attività comuni che è possibile completare con Intel® Distribution per GDB* e fornisce i dettagli tecnici necessari. |
| Distribuzione Intel® per GDB* Note sulla versione | Le note contengono informazioni sulle funzionalità principali, sulle nuove funzionalità e sui problemi noti di Intel® Distribution per GDB*. |
| Pagina del prodotto oneAPI | Questa pagina contiene una breve introduzione sui toolkit oneAPI e collegamenti a risorse utili. |
| Scheda di riferimento Intel® Distribution per GDB* | Questo documento di una pagina descrive brevemente i prerequisiti e i comandi utili della distribuzione Intel® per GDB*. |
| Jacobi Sample | Questa piccola applicazione SYCL* ha due versioni: buggata e corretta. Usa la sample per eseguire il debug dell'applicazione con Intel® Distribution per GDB*. |
Avvisi e dichiarazioni di non responsabilità
Le tecnologie Intel potrebbero richiedere l'attivazione di hardware, software o servizi abilitati.
Nessun prodotto o componente può essere assolutamente sicuro.
I tuoi costi e risultati possono variare.
© Intel Corporation. Intel, il logo Intel e altri marchi Intel sono marchi di Intel Corporation o delle sue consociate. Altri nomi e marchi possono essere rivendicati come proprietà di altri.
Il presente documento non concede alcuna licenza (espressa o implicita, per preclusione o altro) su alcun diritto di proprietà intellettuale.
I prodotti descritti possono contenere difetti di progettazione o errori noti come errata che possono causare la deviazione del prodotto dalle specifiche pubblicate. Le errata caratterizzate correnti sono disponibili su richiesta.
Intel declina tutte le garanzie esplicite e implicite, incluse, a titolo esemplificativo, le garanzie implicite di commerciabilità, idoneità per uno scopo particolare e non violazione, nonché qualsiasi garanzia derivante dal corso delle prestazioni, dal modo di trattare o dall'uso commerciale.
OpenCL e il logo OpenCL sono marchi registrati di Apple Inc. utilizzati con autorizzazione di Khronos.
Documenti / Risorse
 |
distribuzione intel per GDB su host del sistema operativo Linux [pdf] Guida utente Distribuzione per GDB su Linux OS Host, GDB su Linux OS Host, Linux OS Host, OS Host, Host |
