Melhor legal: como posso pausar completamente um processo exigente se o computador estiver descompactado?

Question

Alguns trabalhos em segundo plano no meu PC fazem processamento pesado. Executá-los com um nível máximo ainda produz interatividade lenta e me irrita.

Existe uma maneira melhor do que o máximo legal?

Assim que eu uso o computador, quero que o trabalho em segundo plano seja interrompido. Pode continuar se eu não usar o PC por cerca de cinco minutos.

O trabalho em segundo plano não tem linha morta. Se não importa se demora muito mais tempo.

O trabalho que quero desacelerar é um processo de codificação de vídeo que usa um thread por CPU. No meu laptop há 4 threads produzindo 400% de carga.

    

Answer 1

Uma maneira alternativa de gerenciar (pausar) um processo exigente enquanto o computador é usado

Eu testei o script abaixo em combinação com kdenlive , renderizando um vídeo grande. Nos testes, funcionou bem. O script (background) em si praticamente não consome recursos. A única coisa que basicamente faz é verificar uma vez por 5 segundos se o processo de destino for executado. Somente em caso afirmativo, verificará o tempo ocioso atual. Ambos significam nada para o seu sistema

O script é baseado no uso de xprintidle . xprintidle controla os eventos de teclado e mouse e mede o tempo em que não houve atividade. Se o processo exigente começar, ele será pausado imediatamente (já que o computador é obviamente usado) com o comando:

kill -STOP <pid>

Se, subsequentemente, o tempo inativo exceder um certo limite de tempo (arbitrário), o processo é retomado, usando o comando:

kill -CONT <pid>

Posteriormente, se o tempo ocioso retornar abaixo do limite de tempo definido, o processo será pausado novamente e assim por diante.

usodacpuantes/durante/depoisdotempoocioso,renderizandoumvídeograndecomkdenliveusandomelt

Sobrekill-STOPekill-CONT

Emboraosargumentos-STOPe-CONTsejammencionadosemmankill,issonãoéexplicadodeformaestranha.Noentanto,porexemplo, aqui podemos ler o que faz:

Basicamente, kill -STOP 1234 pausará o processo com pid 1234 e kill -CONT 1234 o retomará. É como se você pudesse dormir aplicativos individuais em vez de todo o seu computador.

Assim, o processo exigente é colocado em repouso enquanto o computador é usado (descomprimido).

Encontrando o processo a ser pausado

O script é executado com o processo nome (você gostaria de ser pausado se usar o computador) como argumento.

O truque é encontrar o processo correto a ser pausado. Não será o nome do seu editor de vídeo, pois certamente usará ferramentas externas para renderizar. No meu caso, kdenlive usou melt . O script pausou com êxito melt e reiniciou a renderização após um tempo ocioso definido.

Você pode usar o comando top se não tiver certeza sobre o nome do processo. Execute top em um terminal e pressione Ctrl + M para ordenar o uso da memória. O processo exigente estará no topo.

O script

#!/usr/bin/env python3
import subprocess
import time
import sys

limit = int(sys.argv[1])
proc = sys.argv[2]

def get(command):
    return subprocess.check_output(command).decode("utf-8").strip()

def check_runs(proc):
    try:
        return get(["pgrep", proc])
    except subprocess.CalledProcessError:
        pass

pid1 = check_runs(proc)
t1 = int(int(get("xprintidle"))/1000)

while True:
    time.sleep(5)
    pid2 = check_runs(proc)
    # (only) if the process exists, manage its activity
    if pid2 != None:
        t2 = int(int(get("xprintidle"))/1000)
        # if the process just started, obviously the system is not idle ->
        # pause the process (try in case it was killed by user in between):
        if pid1 == None:
            try:
                subprocess.Popen(["kill", "-STOP", pid2])
            except subprocess.CalledProcessError:
                pass
        # If there is a change in time status (breaktime entered or ended)
        else:              
            if [t2 > limit, t1 > limit].count(True) == 1:
                if t2 > limit:
                    cmd = ["kill", "-CONT", pid2]
                else:
                    cmd = ["kill", "-STOP", pid2]
                subprocess.Popen(cmd)
        t1 = t2
    pid1 = pid2

Como usar

• O script precisa de xprintidle

  sudo apt-get instal xprintidle
  

• Copie o script acima em um arquivo vazio, salve-o como manage_proc.py

• Teste - execute-o pelo comando

  python3 /path/to/manage_proc.py <seconds> <process_name>
  

  em que <seconds> é o tempo ocioso em segundos antes que você queira que seu processo seja iniciado.
  Inicie o processo de consumo após o script foi iniciado.

• Se tudo funcionar bem, adicione o script a Startup Applications: Dash > Aplicativos de inicialização > Adicione o comando:

   python3 /path/to/manage_proc.py <seconds> <process_name>