Estoy buscando un comando que me dé la misma información que:

cat /proc/cpuinfo 

Excepto por la GPU (tipo de chip y memoria, frecuencia).

Ese tipo de información no es estándar, y las herramientas que utilizará para recopilarla varían ampliamente.

El comando glxinfole proporcionará toda la información de OpenGL disponible para el procesador de gráficos, incluido el nombre del proveedor, si los controladores están instalados correctamente.

Para obtener información sobre la velocidad del reloj, no existe una herramienta estándar.

• Para las GPU ATI / AMD, aticonfig --odgcobtendrá las velocidades de reloj y aticonfig --odgtobtendrá los datos de temperatura.
• Para las GPU NVIDIA, el nvclockprograma obtendrá la misma información.

No conozco una herramienta equivalente para los controladores de código abierto o para Intel u otras GPU.

Se puede obtener otra información sobre el hardware de las herramientas lspciy lshw.

No conozco un equivalente directo, pero lshw debería darle la información que desea, intente:

sudo lshw -C display

(que también funciona sin sudopero la información puede ser menos completa / exacto)

También puede instalar el paquete lshw-gtkpara obtener una GUI.

Una publicación de blog que se centra en el trabajo realizado en la línea de comandos está aquí:

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

Averigüe la identificación del dispositivo:

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

Luego puede usar esta salida lspcinuevamente, formando dos comandos anidados

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

Si tiene más de 1 tarjeta GPU, pruebe este comando equivalente en su lugar:

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

Salida de mi 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

EDITAR: Puedes evitarlo <access denied>iniciando consudo

Entonces, (prefetchable) [size=64M)indica que tengo una tarjeta NVIDIA de 64 MB. Sin embargo, no lo hago, es más bien 256 MB. ¿Por qué? Vea abajo.

Para ver cómo aprovechar al máximo la información y el rendimiento, lea un artículo extremadamente completo en el Wiki de Arch-Linux

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

Para usuarios de nvidia , comience con

nvidia-smi

(Esto funciona con los controladores Nvidia instalados, pero no con sistemas que ejecutan el controlador 'nouveau' de código abierto).

Salida

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                                               |
+-----------------------------------------------------------------------------+

Esto indica que tengo una tarjeta gráfica GDDR3 de 256 MB.

En este momento, no sé cómo obtener esto para las GPU Intel y AMD / ATI.

Ejecute google-chromey navegue a la URL about:gpu. Si Chrome ha descubierto cómo usar OpenGL, obtendrá información extremadamente detallada sobre su GPU.

Debido a que especificó un comando como catpara CPU, este es el equivalente para GPU. Específicamente para tarjetas Nvidia. No requiere ningún software, excepto el controlador del dispositivo Nvidia para cargarse.

El camino aquí funciona para las cartas que tengo. Pero el tuyo puede diferir como otros han señalado en los comentarios.

1ª 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

2da 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

Para tarjetas Nvidia, escriba

nvidia-smi -q

clinfo

sudo apt-get install clinfo
clinfo

es el análogo de glxinfopero para OpenCL.

nvidia-settings

Mezcla el tiempo de ejecución con información estática.

Más detalles: ¿Cómo verifico si Ubuntu está usando mi tarjeta gráfica NVIDIA?

Creo que la mejor opción para esto es neofetch .

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

Esto da una salida como esta:

Pantalla de bienvenida de Conky o Terminal

Utilizo dos métodos para mostrar automáticamente la información de nVidia GPU e Intel iGPU:

• Conky muestra dinámicamente información de GPU en tiempo real
• ~/.bashrc muestra información de la GPU cada vez que se abre el terminal

Pantalla en tiempo real Conky

Este ejemplo utiliza Conky para mostrar las estadísticas actuales de GPU (nVidia o Intel) en tiempo real. Conky es un monitor de sistema liviano popular entre muchos entusiastas de Linux.

La pantalla cambia dependiendo de si arrancó después de prime-select intelo prime-select nvidia.

Intel iGPU

• Intel iGPU muestra como Skylake GT2 HD 530 iGPUcon la frecuencia actual
• La frecuencia mínima es 350MHz y la máxima es 1050MHz

GPU nVidia

• La GPU nVidia se muestra como GeForce GTX970Mcon la frecuencia y temperatura actuales de la GPU
• Se muestran la versión del controlador, el estado P y la versión del BIOS
• Se muestra la carga de GPU, el uso de RAM, el consumo de energía y la frecuencia de RAM

Código Conky

Aquí está el script Conky relevante para Intel iGPU y nVidia GPU:

#------------+
# 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 Pantalla de bienvenida del terminal

Este ejemplo se modifica ~/.bashrcpara mostrar información en una pantalla de inicio cada vez que se abre el terminal o cada vez que escribe . .bashrcen el indicador de comandos del shell.

Además de la neofetchrespuesta anterior, hay una screenfetchque se ve mucho mejor (IMO). Además, otra respuesta menciona que no sabe cómo incluir iGPU y esto lo hace:

Para obtener más información sobre la configuración, consulte: ¿ Pantalla de inicio de terminal con tiempo, calendario, hora e información del sistema?

En resumen, solo para la sección inferior con pantalla de Ubuntu que contiene información de GPU (segunda última línea) use:

sudo apt install screenfetch
screenfetch

Deberá colocar el screenfetchcomando en la parte inferior de su ~/.bashrcarchivo para que aparezca cada vez que abra el terminal.

Solo para encontrar los conceptos básicos, de acuerdo con https://wiki.debian.org/NvidiaGraphicsDrivers#NVIDIA_Proprietary_Driver ,

lspci | grep VGA

Si necesita más detalles que eso, consulte la respuesta de @ knb a esta misma pregunta.

Esto realmente no es tan complejo Para el modelo y la memoria, aquí hay un 1 liner que funciona para cada tarjeta de video en la que lo he probado, independientemente del fabricante (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 = Todo lo que hace este bit es tomar el tercer campo de la salida 'lspci' filtrada a través de 'grep' para VGA que corresponde al chip de video.

RAM = Todo lo que hace este bit es establecer una variable cardidigual al primer campo de salida de lspci"VGA" coincidente y lo alimenta como una solicitud de -vsalida detallada de lspciese -sdispositivo específico , filtrando aún más la salida por grepla cadena "prefetchable" ya que contiene la memoria en la tarjeta en sí (tenga en cuenta el espacio anterior, ya que no queremos que coincida con "no prefetchable" en nuestra salida.

Para frecuencia de reloj en gráficos integrados Intel (Probado en I3 e I5)

ejecute el comando sudo find /sys -type f -name gt_cur* -print0 | xargs -0 cat Esto se sumerge en el árbol / sys para localizar el archivo gt_cur_freq_mhz que en mi I3 es /sys/devices/pci0000:00/0000:00:02.0/drm/card0/gt_cur_freq_mhze imprime el contenido. que en mi caso bajo una carga extremadamente ligera es 350como en 350 MHz que corresponde a la frecuencia mínima encontrada en /sys/devices/pci0000:00/0000:00:02.0/drm/card0/gt_min_freq_mhzy cuando se ejecuta glxgearsy glmark2resulta 1050como en 1050 MHz que corresponde a la frecuencia máxima encontrada en/sys/devices/pci0000:00/0000:00:02.0/drm/card0/gt_max_freq_mhz

Para tarifas de reloj en tarjetas nvidia:

nvidia-smi -stats -d procClkcorresponde al reloj de la GPU nvidia-smi -stats -d memClkcorresponde al reloj de la memoria.

Nota: No puedo probar lo anterior ya que mi confiable GeForce 210 no es compatible y esto solo funciona en Kepler o en las GPU más nuevas, como lo indica `nvidia-smi -stats --help '

Actualmente no tengo ninguna solución para la frecuencia de reloj en las tarjetas AMD y no tengo el hardware disponible para realizar pruebas. Sin embargo, diré que, a mi leal saber y entender, lo aticonfigmencionado en la respuesta aceptada ya no existe y parece que nvclockno está disponible para nada desde que es confiable.

Si está ejecutando Ubuntu en un Chromebook con crouton, la única de las respuestas que funcionará será chrome://gpuen el navegador Chrome.

Si desea tener información simple, puede probar con gpustat . Es muy bueno y simple.

El autor da las siguientes instrucciones de instalación:

Instalar desde PyPI:

pip install gpustat 

Para instalar la última versión (rama maestra) a través de pip:

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

Si usted no tiene privilegios de root, intenta instalar en espacio de nombres de usuario: pip install --user. Tenga en cuenta que desde v0.4, gpustat.pyya no es un ejecutable de dependencia cero. Sin embargo, en casos excepcionales necesitará un solo script ejecutable (heredado), también puede intentar:

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

Bueno, esta respuesta asume que tienes un servidor con NVIDIA-GPU. Tienes tres formas:

1. Para obtener solo una breve idea: nvidia-smi

2. Para obtener una detallada uno: nvidia-smi -q. Obtendrá múltiples pantallas de información detallada si tiene más de 1 gpu.

3. Hacer un ls /proc/driver/nvidia/gpus/. Mostrará la ubicación del bus GPU como carpetas. Ahora, ejecute el siguiente comando para cada una de las ubicaciones del bus gpu. Rellene <gpu-id>con la ubicación del autobús:cat /proc/driver/nvidia/gpus/<gpu_id>/information

Para el Intel GMA950 (viene con EeePC en particular) puede ejecutar:

setpci -s 00:02.0 f0.b

que devolverá '00' para 200MHz, '01' para 250MHz o '03' para 400MHz. Es posible que pueda aplicar el mismo principio a otras tarjetas Intel.

Si tiene una tarjeta AMD Radeon, es posible que desee ejecutar los siguientes comandos

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

Debería informar algo como esto

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)

Para las GPU nvidia, el nvidia-smicomando es tu amigo. Mira man nvidia-smisi te gusta.

Para enumerar el uso de las GPU nvidia-smi -L( nvidia-smi --list-gpus), nvidia-smi -qproporcione información sobre la GPU y los procesos en ejecución.

Use lspci, lspci -vpara obtener información básica, vea aquí .

En mi caso, por ejemplo, una vez que corro lspciy tengo:

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

Para obtener toda la información sobre el procesador de gráficos, puede usar el siguiente comando según lo especificado por @greyfade.

> glxinfo

Sin embargo, si el programa glxinfono está instalado actualmente, puede instalarlo escribiendo:

> sudo apt install mesa-utils

También deberá habilitar el componente llamado universe. Una vez hecho esto, glxinfoenumerará todas las especificaciones relacionadas con el procesador de gráficos en ese entorno.

Si solo busca los nombres de las tarjetas de video en la máquina, simplemente use:

$ nvidia-smi --list-gpus

Para algunas GPU más nuevas, esto también enumera la memoria de cada dispositivo.