Sto cercando un comando che mi darebbe le stesse informazioni di:

cat /proc/cpuinfo 

Ad eccezione della GPU (tipo di chip e memoria, frequenza).

Questo tipo di informazioni non è standard e gli strumenti che userete per raccoglierle variano ampiamente.

Il comando glxinfofornirà tutte le informazioni OpenGL disponibili per il processore grafico, incluso il nome del fornitore, se i driver sono installati correttamente.

Per ottenere informazioni sulla velocità di clock, non esiste uno strumento standard.

• Per le GPU ATI / AMD, aticonfig --odgcrecupera le frequenze e aticonfig --odgtrecupera i dati di temperatura.
• Per le GPU NVIDIA, il nvclockprogramma recupererà le stesse informazioni.

Non sono a conoscenza di uno strumento equivalente per i driver open source o per Intel o altre GPU.

Altre informazioni sull'hardware possono essere recuperate dagli strumenti lspcie lshw.

Non conosco un equivalente diretto, ma lshw dovrebbe darti le informazioni che desideri, prova:

sudo lshw -C display

(funziona anche senza sudoma le informazioni potrebbero essere meno complete / accurate)

È inoltre possibile installare il pacchetto lshw-gtkper ottenere una GUI.

Un post sul blog incentrato sul lavoro svolto dalla riga di comando è qui:

http://www.cyberciti.biz/faq/howto-find-linux-vga-video-card-ram/

Scopri l'ID del dispositivo:

 lspci | grep ' VGA ' | cut -d" " -f 1
03:00.0

È quindi possibile utilizzare lspcinuovamente questo output con , formando due comandi nidificati

lspci  -v -s  $(lspci | grep ' VGA ' | cut -d" " -f 1)

Se hai più di 1 scheda GPU, prova invece questo comando equivalente:

lspci | grep ' VGA ' | cut -d" " -f 1 | xargs -i lspci -v -s {}

Uscita dal mio sistema:

03:00.0 VGA compatible controller: NVIDIA Corporation G98 [Quadro NVS 295] (rev a1) (prog-if 00 [VGA controller])
    Subsystem: NVIDIA Corporation Device 062e
    Flags: bus master, fast devsel, latency 0, IRQ 24
    Memory at f6000000 (32-bit, non-prefetchable) [size=16M]
    Memory at ec000000 (64-bit, prefetchable) [size=64M]
    Memory at f4000000 (64-bit, non-prefetchable) [size=32M]
    I/O ports at dc80 [size=128]
    [virtual] Expansion ROM at f7e00000 [disabled] [size=128K]
    Capabilities: <access denied>
    Kernel driver in use: nvidia

EDIT: puoi evitarlo <access denied>avviando consudo

Quindi, (prefetchable) [size=64M)indica che ho una scheda NVIDIA da 64 MB. Tuttavia, non lo so, è piuttosto 256 MB. Perché? Vedi sotto.

Per sapere come ottenere il massimo da informazioni e prestazioni, leggi un articolo estremamente completo sul Wiki di Arch-Linux

https://wiki.archlinux.org/index.php/NVIDIA

Per gli utenti nvidia , iniziare con

nvidia-smi

(Funziona con i driver Nvidia installati, ma non con i sistemi che eseguono il driver open-source 'nouveau').

Produzione

Thu Dec 19 10:54:18 2013       
+------------------------------------------------------+                       
| NVIDIA-SMI 5.319.60   Driver Version: 319.60         |                       
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  Quadro NVS 295      Off  | 0000:03:00.0     N/A |                  N/A |
| N/A   73C  N/A     N/A /  N/A |      252MB /   255MB |     N/A      Default |
+-------------------------------+----------------------+----------------------+

+-----------------------------------------------------------------------------+
| Compute processes:                                               GPU Memory |
|  GPU       PID  Process name                                     Usage      |
|=============================================================================|
|    0            Not Supported                                               |
+-----------------------------------------------------------------------------+

Questo indica che ho una scheda grafica GDDR3 da 256 MB.

Al momento, non so come ottenerlo per le GPU Intel e AMD / ATI.

Esegui google-chromee vai all'URL about:gpu. Se Chrome ha capito come usare OpenGL, otterrai informazioni estremamente dettagliate sulla tua GPU.

Poiché hai specificato un comando come catper la CPU, questo è quindi l'equivalente per le GPU. Specificamente per le schede Nvidia. Non richiede alcun software tranne il driver del dispositivo Nvidia per essere caricato.

Il percorso qui funziona per le carte che ho. Ma il tuo può essere diverso come altri hanno sottolineato nei commenti.

1a GPU

> cat /proc/driver/nvidia/gpus/0/information
Model:       GeForce GTX 680
IRQ:         24
GPU UUID:    GPU-71541068-cded-8a1b-1d7e-a093a09e9842
Video BIOS:      80.04.09.00.01
Bus Type:    PCIe
DMA Size:    40 bits
DMA Mask:    0xffffffffff
Bus Location:    0000:01.00.0

2a GPU

> cat /proc/driver/nvidia/gpus/1/information
Model:       GeForce GTX 580
IRQ:         33
GPU UUID:    GPU-64b1235c-51fc-d6f1-0f0e-fa70320f7a47
Video BIOS:      70.10.20.00.01
Bus Type:    PCIe
DMA Size:    40 bits
DMA Mask:    0xffffffffff
Bus Location:    0000:08.00.0

Per le schede Nvidia, digitare

nvidia-smi -q

clinfo

sudo apt-get install clinfo
clinfo

è l'analogo di glxinfoma per OpenCL.

nvidia-settings

Mescola il runtime con alcune informazioni statiche.

Maggiori dettagli: Come posso verificare se Ubuntu sta usando la mia scheda grafica NVIDIA?

Credo che l'opzione migliore per questo sia il neofetch .

# Get neofetch
sudo add-apt-repository ppa:dawidd0811/neofetch
sudo apt update
sudo apt get neofetch
# Run neofetch
neofetch

Questo dà un output come questo:

Schermata iniziale Conky o Terminal

Uso due metodi per visualizzare automaticamente le informazioni GPU nVidia e Intel iGPU:

• Conky visualizza dinamicamente le informazioni sulla GPU in tempo reale
• ~/.bashrc visualizza le informazioni sulla GPU ogni volta che si apre il terminale

Conky display in tempo reale

In questo esempio viene utilizzato Conky per visualizzare in tempo reale le statistiche GPU (nVidia o Intel) correnti. Conky è un monitor di sistema leggero popolare tra molti appassionati di Linux.

Il display cambia a seconda che sia stato avviato dopo prime-select intelo prime-select nvidia.

Intel iGPU

• Intel iGPU mostra come Skylake GT2 HD 530 iGPUcon la frequenza corrente
• La frequenza minima è 350MHz e la massima è 1050MHz

GPU nVidia

• La GPU nVidia si presenta come GeForce GTX970Mcon la frequenza e la temperatura della GPU corrente
• Vengono visualizzati la versione del driver, lo stato P e la versione del BIOS
• Vengono visualizzati il ​​carico della GPU, l'utilizzo della RAM, il consumo di energia e la frequenza della RAM

Codice Conky

Ecco lo script Conky pertinente per Intel iGPU e GPU nVidia:

#------------+
# Intel iGPU |
#------------+
${color orange}${hr 1}${if_match "intel" == "${execpi 99999 prime-select query}"}
${color2}${voffset 5}Intel® Skylake GT2 HD 530 iGPU @${alignr}${color green}${execpi .001 (cat /sys/class/drm/card1/gt_cur_freq_mhz)} MHz
${color}${goto 13}Min. Freq:${goto 120}${color green}${execpi .001 (cat /sys/class/drm/card1/gt_min_freq_mhz)} MHz${color}${goto 210}Max. Freq:${alignr}${color green}${execpi .001 (cat /sys/class/drm/card1/gt_max_freq_mhz)} MHz
${color orange}${hr 1}${else}
#------------+
# Nvidia GPU |
#------------+
${color2}${voffset 5}${execpi .001 (nvidia-smi --query-gpu=gpu_name --format=csv,noheader)} ${color1}@ ${color green}${execpi .001 (nvidia-smi --query-gpu=clocks.sm --format=csv,noheader)} ${alignr}${color1}Temp: ${color green}${execpi .001 (nvidia-smi --query-gpu=temperature.gpu --format=csv,noheader)}°C
${color1}${voffset 5}Ver: ${color green}${execpi .001 (nvidia-smi --query-gpu=driver_version --format=csv,noheader)} ${color1} P-State: ${color green}${execpi .001 (nvidia-smi --query-gpu=pstate --format=csv,noheader)} ${alignr}${color1}BIOS: ${color green}${execpi .001 (nvidia-smi --query-gpu=vbios_version --format=csv,noheader)}
${color1}${voffset 5}GPU:${color green}${execpi .001 (nvidia-smi --query-gpu=utilization.gpu --format=csv,noheader)} ${color1}Ram:${color green}${execpi .001 (nvidia-smi --query-gpu=utilization.memory --format=csv,noheader)} ${color1}Pwr:${color green}${execpi .001 (nvidia-smi --query-gpu=power.draw --format=csv,noheader)} ${alignr}${color1}Freq: ${color green}${execpi .001 (nvidia-smi --query-gpu=clocks.mem --format=csv,noheader)}
${color orange}${hr 1}${endif}

~/.bashrc Schermata iniziale del terminale

Questo esempio modifica ~/.bashrcper visualizzare informazioni su una schermata iniziale ogni volta che si apre il terminale o ogni volta che si digita . .bashrcal prompt della shell.

Oltre a neofetchrispondere in precedenza, c'è quello screenfetchche sembra molto più bello (IMO). Inoltre un'altra risposta menziona che non sa come elencare iGPU e questo lo fa:

Per i dettagli sulla configurazione, consultare: Schermata iniziale del terminale con Meteo, Calendario, Ora e Sysinfo?

In sintesi, solo per la sezione inferiore con display Ubuntu contenente informazioni GPU (seconda ultima riga) utilizzare:

sudo apt install screenfetch
screenfetch

Ti consigliamo di mettere il screenfetchcomando in fondo al tuo ~/.bashrcfile per farlo apparire ogni volta che apri il terminale.

Giusto per trovare le basi, secondo https://wiki.debian.org/NvidiaGraphicsDrivers#NVIDIA_Proprietary_Driver ,

lspci | grep VGA

Se hai bisogno di maggiori dettagli, vedi la risposta di @ knb a questa stessa domanda.

Questo non è poi così complesso Per modello e memoria, ecco un 1 liner che funziona per ogni scheda video su cui l'ho testato indipendentemente dal produttore (Intel, AMD, NVIDIA):

GPU=$(lspci | grep VGA | cut -d ":" -f3);RAM=$(cardid=$(lspci | grep VGA |cut -d " " -f1);lspci -v -s $cardid | grep " prefetchable"| cut -d "=" -f2);echo $GPU $RAM

GPU = Tutto questo bit fa è prendere il 3 ° campo dall'uscita 'lspci' filtrata tramite 'grep' per VGA che corrisponde al chip video.

RAM = Tutto questo bit fa è impostare una variabile cardiduguale al primo campo di output dalla lspcicorrispondenza "VGA" e lo alimenta come richiesta di -voutput dettagliato lspciper quel -sdispositivo specifico , filtrando ulteriormente l'output grepper la stringa "prefetchable" in quanto contiene la memoria sulla scheda stessa (notare lo spazio precedente in quanto non vogliamo corrispondere a "non prefetchable" nel nostro output.

Per la frequenza di clock sulla grafica integrata Intel (testato su I3 e I5)

esegui il comando sudo find /sys -type f -name gt_cur* -print0 | xargs -0 cat Questo si tuffa nell'albero / sys per individuare il file gt_cur_freq_mhz che sul mio I3 è /sys/devices/pci0000:00/0000:00:02.0/drm/card0/gt_cur_freq_mhze stampa il contenuto. che nel mio caso sotto carico estremamente leggero è 350come in 350 MHz che corrisponde alla frequenza minima trovata in /sys/devices/pci0000:00/0000:00:02.0/drm/card0/gt_min_freq_mhze durante il funzionamento glxgearse glmark2risulta 1050come in 1050 MHz che corrisponde alla frequenza massima trovata in/sys/devices/pci0000:00/0000:00:02.0/drm/card0/gt_max_freq_mhz

Per le frequenze di clock sulle schede nvidia:

nvidia-smi -stats -d procClkcorrisponde al clock della GPU nvidia-smi -stats -d memClkcorrisponde al clock della memoria.

Nota: non sono in grado di testare quanto sopra poiché il mio affidabile GeForce 210 non è supportato e funziona solo su Kepler o GPU più recenti come indicato da `nvidia-smi -stats --help '

Al momento non ho soluzioni per la frequenza di clock sulle schede AMD e non ho l'hardware disponibile per i test. Dirò comunque che, per quanto ne so, la aticonfigmenzionata nella risposta accettata non esiste più e sembra che nvclocknon sia disponibile per nulla da quando si è fidato.

Se stai eseguendo Ubuntu su un Chromebook con crostino, l'unica delle risposte che funzionerà sarà chrome://gpunel browser Chrome.

Se desideri avere informazioni semplici, puoi provare gpustat . È molto buono e semplice.

L'autore fornisce le seguenti istruzioni di installazione:

Installa da PyPI:

pip install gpustat 

Per installare l'ultima versione (master branch) tramite pip:

pip install git+https://github.com/wookayin/gpustat.git@master 

Se non si dispone di privilegi di root, si prega di provare a installare il namespace utente: pip install --user. Si noti che dalla v0.4, gpustat.pynon è più un eseguibile a dipendenza zero. Tuttavia, in rari casi avrai bisogno di un singolo script eseguibile (legacy), puoi anche provare:

wget https://raw.githubusercontent.com/wookayin/gpustat/v0.3.2/gpustat.py -O ~/.local/bin/gpustat chmod +x ~/.local/bin/gpustat    # Assuming ~/.local/bin is in your $PATH

Bene, questa risposta presuppone che tu abbia un server con GPU NVIDIA. Hai tre modi:

1. Per farvi un'idea: nvidia-smi

2. Per ottenere una dettagliata uno: nvidia-smi -q. Otterrai più schermate di informazioni dettagliate se hai più di 1 gpu.

3. Fare un ls /proc/driver/nvidia/gpus/. Visualizzerà la posizione del bus GPU come cartelle. Ora, esegui il seguente comando per ciascuna delle posizioni del bus gpu. Riempi <gpu-id>con la posizione del bus:cat /proc/driver/nvidia/gpus/<gpu_id>/information

Per Intel GMA950 (in particolare con EeePC) puoi eseguire:

setpci -s 00:02.0 f0.b

che restituirà "00" per 200 MHz, "01" per 250 MHz o "03" per 400 MHz. Potresti essere in grado di applicare lo stesso principio ad altre schede Intel.

Se hai una scheda AMD Radeon, potresti voler eseguire i seguenti comandi

sudo update-pciids #optional command, requires internet
lspci -nn | grep -E 'VGA|Display'

Dovrebbe segnalare qualcosa del genere

00:01.0 VGA compatible controller [0300]: Advanced Micro Devices, Inc. [AMD/ATI] Wani [Radeon R5/R6/R7 Graphics] [1002:9874] (rev c5)
03:00.0 Display controller [0380]: Advanced Micro Devices, Inc. [AMD/ATI] Sun XT [Radeon HD 8670A/8670M/8690M / R5 M330 / M430 / R7 M520] [1002:6660] (rev ff)

Per le GPU nvidia, il nvidia-smicomando è tuo amico. Vedi man nvidia-smise ti piace.

Per elencare le GPU use nvidia-smi -L( nvidia-smi --list-gpus), nvidia-smi -qfornire informazioni sulla gpu e sui processi in esecuzione.

Usa lspci, lspci -vper ottenere informazioni di base vedi qui .

Nel mio caso per ex una volta che corro lspcie ho ottenuto:

dina@dina-X450LA:~$ lspci
00:02.0 VGA compatible controller: Intel Corporation Haswell-ULT Integrated Graphics Controller (rev 0b)
00:03.0 Audio device: Intel Corporation Haswell-ULT HD Audio Controller (rev 0b)
00:14.0 USB controller: Intel Corporation 8 Series USB xHCI HC (rev 04)
00:16.0 Communication controller: Intel Corporation 8 Series HECI #0 (rev 04)
00:1b.0 Audio device: Intel Corporation 8 Series HD Audio Controller (rev 04)
00:1c.0 PCI bridge: Intel Corporation 8 Series PCI Express Root Port 1 (rev e4)
00:1c.2 PCI bridge: Intel Corporation 8 Series PCI Express Root Port 3 (rev e4)
00:1c.3 PCI bridge: Intel Corporation 8 Series PCI Express Root Port 4 (rev e4)
00:1d.0 USB controller: Intel Corporation 8 Series USB EHCI #1 (rev 04)
00:1f.0 ISA bridge: Intel Corporation 8 Series LPC Controller (rev 04)
00:1f.2 SATA controller: Intel Corporation 8 Series SATA Controller 1 [AHCI mode] (rev 04)
00:1f.3 SMBus: Intel Corporation 8 Series SMBus Controller (rev 04)
02:00.0 Ethernet controller: Qualcomm Atheros QCA8171 Gigabit Ethernet (rev 10)
03:00.0 Network controller: Ralink corp. RT3290 Wireless 802.11n 1T/1R PCIe
03:00.1 Bluetooth: Ralink corp. RT3290 Bluetooth

Per ottenere tutte le informazioni sul processore grafico, è possibile utilizzare il comando seguente come specificato da @greyfade.

> glxinfo

Tuttavia, se il programma non glxinfoè attualmente installato, è possibile installarlo digitando:

> sudo apt install mesa-utils

Dovrai anche abilitare il componente chiamato universe. Fatto ciò, glxinfoelencherà tutte le specifiche relative al processore grafico in quell'ambiente.

Se stai cercando solo i nomi delle schede video sulla macchina, utilizza semplicemente:

$ nvidia-smi --list-gpus

Per alcune GPU più recenti, questo elenca anche la memoria di ciascun dispositivo.