Estou procurando um comando que me dê as mesmas informações que:

cat /proc/cpuinfo 

Exceto pela GPU (tipo de chip e memória, frequência).

Esse tipo de informação não é padrão e as ferramentas que você usará para coletá-las variam muito.

O comando glxinfofornecerá todas as informações disponíveis do OpenGL para o processador gráfico, incluindo o nome do fornecedor, se os drivers estiverem instalados corretamente.

Para obter informações sobre a velocidade do relógio, não há ferramenta padrão.

• Para GPUs ATI / AMD, aticonfig --odgcbuscará as taxas de clock e aticonfig --odgtos dados de temperatura.
• Para GPUs NVIDIA, o nvclockprograma buscará as mesmas informações.

Não conheço uma ferramenta equivalente para os drivers de código aberto ou para a Intel ou outras GPUs.

Outras informações sobre o hardware podem ser obtidas nas ferramentas lspcie lshw.

Eu não sei de um equivalente direto, mas o lshw deve fornecer as informações que você deseja, tente:

sudo lshw -C display

(também funciona sem, sudomas as informações podem ser menos completas / precisas)

Você também pode instalar o pacote lshw-gtkpara obter uma GUI.

Uma postagem no blog com foco no trabalho realizado na linha de comando está aqui:

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

Descubra o ID do dispositivo:

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

Você pode usar essa saída lspcinovamente, formando dois comandos aninhados

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

Se você tiver mais de 1 placa GPU, tente este comando equivalente:

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

Saída do meu 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: Você pode evitar o <access denied>iniciando comsudo

Portanto, (prefetchable) [size=64M)indica que tenho uma placa NVIDIA de 64 MB. No entanto, não sei, são 256 MB. Por quê? Ver abaixo.

Para ver como obter o máximo de informações e desempenho, leia um artigo extremamente abrangente no Wiki do Arch-Linux

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

Para usuários da nvidia , comece com

nvidia-smi

(Isso funciona com os drivers da Nvidia instalados, mas não com os sistemas que executam o driver 'nouveau' de código aberto).

Resultado

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

Isso indica que eu tenho uma placa gráfica GDDR3 de 256 MB.

No momento, não sei como fazer isso para as GPUs Intel e AMD / ATI.

Execute google-chromee navegue para o URL about:gpu. Se o chrome descobriu como usar o OpenGL, você obterá informações extremamente detalhadas sobre sua GPU.

Como você especificou um comando como catpara as CPUs, isso é equivalente às GPUs. Especificamente para placas Nvidia. Ele não requer nenhum software, exceto o driver de dispositivo Nvidia para ser carregado.

O caminho aqui funciona para os cartões que tenho. Mas o seu pode diferir como outros apontaram nos comentários.

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

2 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 placas Nvidia, digite

nvidia-smi -q

clinfo

sudo apt-get install clinfo
clinfo

é o análogo de glxinfomas para OpenCL.

configurações da nvidia

Mistura o tempo de execução com algumas informações estáticas.

Mais detalhes: Como verifico se o Ubuntu está usando minha placa de vídeo NVIDIA?

Eu acredito que a melhor opção para isso é neofetch .

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

Isso fornece uma saída como esta:

Tela Splash Conky ou Terminal

Uso dois métodos para exibir automaticamente as informações da nVidia GPU e Intel iGPU:

• Conky exibe dinamicamente as informações da GPU em tempo real
• ~/.bashrc exibe informações da GPU cada vez que o terminal é aberto

Exibição em tempo real da Conky

Este exemplo usa o Conky para exibir as estatísticas atuais da GPU (nVidia ou Intel) em tempo real. Conky é um monitor de sistema leve, popular entre muitos entusiastas do Linux.

A exibição muda dependendo se você inicializou após prime-select intelou prime-select nvidia.

Intel iGPU

• O Intel iGPU mostra como Skylake GT2 HD 530 iGPUcom a frequência atual
• A frequência mínima é 350MHz e a máxima é 1050MHz

GPU nVidia

• A GPU nVidia mostra como GeForce GTX970Mna freqüência e temperatura atuais da GPU
• A versão do driver, estado P e versão do BIOS são exibidas
• A carga da GPU, o uso da RAM, o consumo de energia e a frequência da RAM são exibidos

Código Conky

Aqui está o script Conky relevante para Intel iGPU e 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 Tela inicial do terminal

Este exemplo é modificado ~/.bashrcpara exibir informações em uma tela inicial sempre que o terminal é aberto ou sempre que você digita . .bashrcno prompt do shell.

Além das neofetchrespostas anteriores, existe uma screenfetchque parece muito melhor (IMO). Além disso, outra resposta menciona que ele não sabe como listar o iGPU e faz isso:

Para detalhes sobre a configuração, consulte: Tela inicial do terminal com Tempo, Calendário, Hora e Sysinfo?

Em resumo, apenas para a seção inferior com a tela do Ubuntu contendo informações da GPU (segunda última linha), use:

sudo apt install screenfetch
screenfetch

Você deseja colocar o screenfetchcomando na parte inferior do seu ~/.bashrcarquivo para que ele apareça toda vez que você abrir o terminal.

Apenas para encontrar o básico, de acordo com https://wiki.debian.org/NvidiaGraphicsDrivers#NVIDIA_Proprietary_Driver ,

lspci | grep VGA

Se você precisar de mais detalhes, consulte a resposta de @ knb para essa mesma pergunta.

Isso realmente não é tão complexo. Para modelo e memória, aqui está um liner que funciona para todas as placas de vídeo em que eu testei, independentemente do 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 = Tudo o que esse bit faz é pegar o terceiro campo da saída 'lspci' filtrada via 'grep' para VGA, que corresponde ao chip de vídeo.

RAM = Tudo o que esse bit faz é definir uma variável cardidigual ao primeiro campo de saída lspcicorrespondente a "VGA" e alimenta isso como uma solicitação de -vsaída detalhada lspcidesse -sdispositivo específico , filtrando ainda mais a saída pela grepstring "prefetchable", pois ela contém a memória no próprio cartão (observe o espaço anterior, pois não queremos corresponder "não pré-detectável" em nossa saída.

Para taxa de clock em gráficos integrados Intel (testado em I3 e I5)

execute o comando sudo find /sys -type f -name gt_cur* -print0 | xargs -0 cat Isso mergulha na árvore / sys para localizar o arquivo gt_cur_freq_mhz que está no meu I3 /sys/devices/pci0000:00/0000:00:02.0/drm/card0/gt_cur_freq_mhze imprime o conteúdo. que, no meu caso, sob carga extremamente leve, é 350igual a 350 MHz, que corresponde à frequência mínima encontrada em /sys/devices/pci0000:00/0000:00:02.0/drm/card0/gt_min_freq_mhze em funcionamento glxgearse glmark2resulta 1050em 1050 MHz, que corresponde à frequência máxima encontrada em/sys/devices/pci0000:00/0000:00:02.0/drm/card0/gt_max_freq_mhz

Para taxas de clock em placas nvidia:

nvidia-smi -stats -d procClkcorresponde ao relógio da GPU nvidia-smi -stats -d memClkcorresponde ao relógio da memória.

Nota: Não consigo testar o acima, pois minha confiável GeForce 210 não é suportada e isso funciona apenas no Kepler ou em GPUs mais recentes, conforme indicado por `nvidia-smi -stats --help '

Atualmente, não tenho nenhuma solução para taxa de clock em placas AMD e não tenho o hardware disponível para teste. No entanto, direi que, até onde sei, o aticonfigmencionado na resposta aceita não existe mais e parece que nvclocknão está disponível para nada desde que seja confiável.

Se você estiver executando o Ubuntu em um Chromebook com crouton, a única resposta que funcionará será chrome://gpuno navegador Chrome.

Se você deseja obter informações simples, tente o gpustat . É muito bom e simples.

O autor fornece as seguintes instruções de instalação:

Instale a partir do PyPI:

pip install gpustat 

Para instalar a versão mais recente (ramificação mestre) via pip:

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

Se você não tem privilégios de root, por favor, tente instalar no espaço de nomes de usuário: pip install --user. Observe que a partir da v0.4, gpustat.pynão é mais um executável com dependência zero. No entanto, em casos raros, você precisará de um único script executável (legado), também pode tentar:

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

Bem, esta resposta supõe que você tenha um servidor com GPUs NVIDIA. Você tem três maneiras:

1. Para obter apenas uma breve síntese: nvidia-smi

2. Para obter um detalhado um: nvidia-smi -q. Você terá várias telas de informações detalhadas se tiver mais de 1 gpu.

3. Faça um ls /proc/driver/nvidia/gpus/. Ele exibirá a localização do barramento GPU como pastas. Agora, execute o seguinte comando para cada um dos locais do barramento gpu. Preencha <gpu-id>com a localização do ônibus:cat /proc/driver/nvidia/gpus/<gpu_id>/information

Para o Intel GMA950 (vem com o EeePC em particular), você pode executar:

setpci -s 00:02.0 f0.b

que retornará '00' para 200 MHz, '01' para 250 MHz ou '03' para 400 MHz. Você pode aplicar o mesmo princípio a outras placas Intel.

Se você possui uma placa AMD Radeon, convém executar os seguintes comandos

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

Deve relatar algo como isto

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 GPUs nvidia, o nvidia-smicomando é seu amigo. Veja man nvidia-smise você gosta.

Para listar as GPUs use nvidia-smi -L( nvidia-smi --list-gpus), nvidia-smi -qforneça informações sobre a gpu e os processos em execução.

Use lspci, lspci -vpara obter informações básicas, veja aqui .

No meu caso para ex, uma vez eu corro lspcie tenho:

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 obter todas as informações sobre o processador gráfico, você pode usar o seguinte comando, conforme especificado por @greyfade.

> glxinfo

No entanto, se o programa glxinfonão estiver instalado no momento, você poderá instalá-lo digitando:

> sudo apt install mesa-utils

Você também precisará habilitar o componente chamado universe. Feito isso, glxinfolistará todas as especificações relacionadas ao processador gráfico nesse ambiente.

Se você estiver procurando apenas os nomes das placas de vídeo na máquina, basta usar:

$ nvidia-smi --list-gpus

Para algumas GPUs mais recentes, isso também lista a memória de cada dispositivo.