Um emulador de terminal pode ser tão rápido quanto TTY 1-6?

59

Ultimamente, tenho tentado vários emuladores de terminal, do gnome-terminal interno, aterm, xterm, wterm ao rxvt. O teste que estou fazendo é nesta ordem:

  1. Abra uma janela tmux com 2 painéis
  2. O painel esquerdo será uma tarefa intensiva, como grep a /et/c -ruma simples tarefatime seq -f 'blah blah %g' 100000
  3. O painel direito será uma janela do vim com sintaxe ativada, abrindo qualquer arquivo que tenha mais de> 100 linhas de código.

Quando o painel esquerdo está imprimindo muita saída, o painel direito parece estar muito lento e sem resposta, tentei rolar no vim, mas leva 1-2 segundos para mudar. Quando tento pressionar CtrlCno painel esquerdo, ele aguarda mais de 10 segundos antes de parar

Quando eu faço a mesma coisa em TTY (pressionando CTRL+ ALT+ ( F[1-6])), isso não acontece e os dois painéis respondem muito bem.

Eu mudei de algumas configurações, como fontes antialias, mude de cor, use as configurações padrão e mude para xmonad e openbox, mas isso não muda nada.

O resultado de time seq -f 'blah blah %g' 100000não é realmente diferente entre esses terminais, mas a capacidade de resposta é realmente diferente, especialmente quando estou executando o painel spitted tmux (ou outros multiplexadores). Para sua informação, estou executando todos eles em um modo maximizado.

Eu li sobre os terminais com buffer de quadro, mas não sei como isso funciona e como pode ser usado para acelerar meu emulador de terminal.

Então, minha pergunta é: o que torna o emulador de terminal muito mais lento que o TTY? Existe alguma possibilidade de torná-lo tão rápido quanto o TTY? Talvez aceleração de hardware ou algo assim? Uma coisa eu sei: minha resolução no servidor X ao executar um emulador de terminal maximizado é 1920x1080, e quando estou executando o TTY é menor que isso, mas não tenho certeza de como isso afetaria o desempenho.

user17537
fonte
Parece que há um grande tampão em algum lugar
Thorbjørn Ravn Andersen
2
Observe que tty [1-6] nem sempre é nativamente rápido. Em uma das máquinas que estou usando, o console de texto é muito lento enquanto um xterm executa decentemente.
28415

Respostas:

75

Quando um emulador de terminal da GUI imprime uma string, ele precisa convertê-la em pontos de código da fonte, enviá-los para um representante de fontes, recuperar um bitmap e misturar esse bitmap na tela através do servidor X.

O renderizador de fontes precisa recuperar os glifos e executá-los (você sabia que as fontes Truetype / Opentype são programas executados dentro de uma máquina virtual no renderizador de fontes?). Durante o processo de execução de cada glifo, são tomadas várias decisões em relação às métricas de fontes, kerning (embora fontes monoespaçadas e kerning não se misturam bem), conformidade com Unicode, e isso é antes mesmo de chegarmos ao rasterizador que provavelmente usa sub endereçamento de pixels. O terminal precisa pegar o buffer produzido pelo rasterizador da fonte e blit-lo no lugar certo, cuidando das conversões no formato de pixel, canais alfa (para endereçamento sub-pixel), rolagem (que envolve mais blitting), etc.

Em comparação, gravar uma string em um Terminal Virtual em execução no modo de texto (nota: não um console gráfico) envolve gravar essa string na memória de vídeo. 'Olá Mundo!' envolve escrever 13 bytes (13 palavras de 16 bits, se você quiser cores também). O rasterizador da fonte X ainda nem começou seus exercícios de alongamento e quebra de juntas, e estamos prontos. É por isso que o modo de texto era tão incrivelmente importante nas décadas passadas. É muito rápido de implementar. Até a rolagem é mais fácil do que você pensa: mesmo nos veneráveis ​​MDA e CGA baseados em Motorola 6845, você pode rolar a tela verticalmente escrevendo um único valor de 8 bits em um registro (pode ser 16 ... já faz muito tempo). O circuito de atualização da telafez o resto. Você estava basicamente alterando o endereço inicial do buffer de quadros.

Não há nada que você possa fazer para criar um terminal gráfico tão rápido quanto um terminal de modo texto no mesmo computador. Mas lembre-se: existem computadores com modos de texto mais lentos que o terminal gráfico mais lento que você provavelmente verá em um computador moderno. O PC IBM original era muito ruim (o DOS fazia rolagem de software, suspiro). Quando vi meu primeiro console Minix em um 80286, fiquei impressionado com a velocidade da rolagem (salto). O progresso é bom.

Atualização: como acelerar o terminal

@ poige já mencionou três em sua resposta , mas aqui está minha opinião:

  • Diminua o tamanho do terminal. Meus próprios terminais tendem a crescer até preencherem as telas e ficam lentos enquanto o fazem. Fico exasperado, irritado com os terminais gráficos, depois redimensiono-os e tudo fica melhor. :)
  • (@poige) Use um emulador de terminal diferente. Você pode obter um enorme aumento de velocidade com o custo de alguns recursos modernos. xterme rxvtfunciona muito bem, possui um emulador de terminal fantástico. Suspeito que seus testes possam ter demonstrado um desempenho melhor que os "modernos".
  • (@poige) Não use fontes escalonáveis. 1986 pode ligar e pedir seus terminais de volta, mas você não pode negar que eles são mais rápidos. ;)
  • (@poige) Diminua o rasterizador da fonte desativando o endereçamento e as dicas de anti-aliasing / sub-pixel. A maioria deles permite substituições em variáveis ​​de ambiente, para que você não precise fazer isso globalmente. Nota: inútil se você escolher uma fonte de bitmap.
  • Isso vai doer mais: não use (vários painéis entrando)tmux - execute dois terminais separados lado a lado. Quando tmuxexibe dois painéis, ele tem que usar diretivas de terminal para mover o cursor muito. Embora as bibliotecas de terminais modernas sejam muito rápidas e boas para otimizar, elas ainda estão roubando bytes da largura de banda bruta do terminal. Para mover o cursor para uma linha arbitrária em um terminal compatível com DEC VT, você envia ESC [ row ; col H. Isso é de 6 a 10 bytes. Com vários terminais, você está segregando o trabalho, eliminando a necessidade de posicionamento, otimização, armazenamento em buffer e todo o restante curses, e fazendo melhor uso de vários núcleos de CPU.
Alexios
fonte
5
+1, mas a coisa do tmux é ainda mais complicada do que apenas alguns códigos de escape extras sendo enviados. Os terminais destinam-se a rolar a janela inteira, não a metade. Portanto, quando o tmux precisa mover todo o texto no painel esquerdo para cima de uma linha, ele não pode apenas criar uma nova linha e deixar o terminal movê-lo para cima, ele deve redesenhar todo o painel.
Patrick
11
Muito bem! Eu esqueci disso. Embora tenha havido terminais que possam rolar parte da tela (o IIRC foi chamado de parte 'protegendo' da tela - era usado para formulários etc.), nunca foi particularmente flexível e provavelmente não é suportado por emuladores de terminal modernos. Mesmo que você encontre algumas diretrizes obsoletas realmente bizarras ainda implementadas hoje.
Alexios #
Responda isso depois de três anos, mas espero que alguém ache isso útil. Percebo o atraso apenas quando faço a divisão vertical no meu vim (sim, até o NERDTree), mas a divisão normal não parece ser um problema durante a rolagem.
grito
17

Enquanto isso, o @Alexios descreveu muito bem todos os motivos, posso mencionar várias coisas, que aliviam relativamente a dor:

  • use fontes de bitmap ( Terminal, Terminus- essa é realmente ótima),
  • desative o anti-aliasing ou considere pelo menos não usar a renderização sub-pixel ,
  • use o terminal do KDE - konsole.
poige
fonte
11
Além disso, e este é o mais doloroso, diminua o tamanho do terminal (o OP está usando uma janela 1920x1200px). Eu amo grandes terminais, e os meus tendem a crescer até que eles ficam quase tão grande quanto a tela, mas a velocidade do terminal cai como o terminal cresce. Mesmo konsole(que eu sou a favor).
Alexs #
3
konsolefaz atualizações preguiçosas da tela: em vez de exibir imediatamente a saída, aguarda um pouco mais por uma saída, para atualizações em "lote". É por isso que ele tem um desempenho tão bom, a ponto de responder totalmente ao teste de estresse do OP.
Ninjalj 1/10
2
Certamente a renderização da fonte é armazenada em cache em algum momento. Eu não acho que os pixels que representam a letra f são renderizados novamente a partir da definição de vetor toda vez que são copiados para um pixmap. (a menos que precise ser renderizado em um novo tamanho ou em um novo ângulo). Não vou contestar o fato de que existem algumas fontes de bitmap realmente agradáveis, que podem ser a melhor opção apenas para aparência, se existirem para o tamanho desejado.
6138 Peter Cordes