Faça um programa funcionar lentamente

Existe alguma maneira de executar um programa C ++ mais lento alterando os parâmetros do sistema operacional no Linux? Desta forma, gostaria de simular o que acontecerá se aquele programa específico rodar em uma máquina realmente mais lenta.

Em outras palavras, uma máquina mais rápida deve se comportar como uma máquina mais lenta para aquele programa específico.

• Reduza a prioridade usando nice(e / ou renice). Você também pode fazer isso programaticamente usando a nice()chamada do sistema. Isso não diminuirá a velocidade de execução em si, mas fará com que o agendador do Linux aloque menos (e possivelmente mais curtos) quadros de tempo de execução, antecipe com mais frequência, etc. Consulte Agendamento de processos (Capítulo 10) de Entendendo o kernel do Linux para obter mais detalhes sobre agendamento .
• Você pode querer aumentar a frequência de interrupção do cronômetro para colocar mais carga no kernel, o que tornará tudo mais lento. Isso requer uma reconstrução do kernel.
• Você pode usar o mecanismo de escalonamento de frequência da CPU (requer módulo de kernel) e controlar (desacelerar, acelerar) a CPU usando o cpufreq-setcomando.
• Outra possibilidade é chamar sched_yield(), o que renderá quantum para outros processos, em partes críticas de desempenho de seu programa (requer mudança de código).
• Você pode ligar funções comuns, como malloc(), free(), clock_gettime()etc. usando LD_PRELOAD , e fazer algumas coisas tolas como queimar alguns milhões de ciclos de CPU com rep; hop;, inserir barreiras de memória etc. Isto irá desacelerar o programa, com certeza. (Veja esta resposta para um exemplo de como fazer algumas dessas coisas).
• Como @Bill mencionou, você sempre pode executar o Linux em um software de virtualização que permite limitar a quantidade de recursos alocados de CPU, memória, etc.
• Se você realmente deseja que seu programa seja lento, execute-o em Valgrind (também pode ajudá-lo a encontrar alguns problemas em seu aplicativo, como vazamentos de memória, referências de memória ruins, etc).
• Alguma lentidão pode ser alcançada recompilando seu binário com otimizações desabilitadas (ou seja, -O0e habilite asserções (ou seja -DDEBUG).
• Você sempre pode comprar um PC antigo ou um netbook barato (como One Laptop Per Child , e não se esqueça de doá-lo para uma criança assim que terminar o teste) com uma CPU lenta e execute seu programa.

Espero que ajude.

QEMU é um emulador de CPU para Linux. O Debian tem pacotes para isso (imagino que a maioria das distros terá). Você pode executar um programa em um emulador e a maioria deles deve suportar a lentidão das coisas. Por exemplo, Miroslav Novak tem patches para desacelerar o QEMU.

Alternativamente, você pode fazer a compilação cruzada para outra CPU-linux (arm-none-gnueabi-linux, etc) e então fazer com que o QEMU traduza esse código para ser executado.

A boa sugestão é simples e pode funcionar se você combiná-la com outro processo que consuma cpu.

nice -19 test &
while [ 1 ] ; do sha1sum /boot/vmlinuz*; done;

Você não disse se precisa de E / S de gráficos, arquivos e / ou rede? Você sabe algo sobre a classe de erro que está procurando? É uma condição de corrida ou o código apenas tem um desempenho ruim no site do cliente?

Editar: Você também pode usar sinais como STOP e CONT para iniciar e parar seu programa. Um depurador também pode fazer isso. O problema é que o código roda a toda velocidade e depois é interrompido. A maioria das soluções com o agendador do Linux terá esse problema. Havia algum tipo de analisador de thread do afair da Intel. Eu vejo as notas de lançamento do Vtune . Este é o Vtune, mas eu tinha certeza de que existe outra ferramenta para analisar as corridas de thread. Consulte: Intel Thread Checker , que pode verificar algumas condições de corrida de thread. Mas não sabemos se o aplicativo é multi-threaded?

Use cpulimit:

Cpulimit é uma ferramenta que limita o uso de CPU de um processo (expresso em porcentagem, não em tempo de CPU). É útil para controlar trabalhos em lote, quando você não quer que eles comam muitos ciclos de CPU. O objetivo é impedir que um processo seja executado por mais de uma proporção de tempo especificada. Isso não altera o valor agradável ou outras configurações de prioridade de agendamento, mas o uso real da CPU . Além disso, ele é capaz de se adaptar à carga geral do sistema de forma dinâmica e rápida.

O controle da quantidade de cpu utilizada é feito enviando sinais SIGSTOP e SIGCONT POSIX para os processos.

Todos os processos filhos e threads do processo especificado compartilharão a mesma porcentagem de CPU.

Está nos repositórios do Ubuntu. Somente

apt-get install cpulimit

Aqui estão alguns exemplos de como usá-lo em um programa já em execução:

Limite o processo 'bigloop' por nome executável a 40% da CPU:

cpulimit --exe bigloop --limit 40
cpulimit --exe /usr/local/bin/bigloop --limit 40 

Limitar um processo por PID a 55% da CPU:

cpulimit --pid 2960 --limit 55

1. Obtenha um computador antigo
2. Os pacotes de hospedagem VPS tendem a funcionar lentamente, ter muitas interrupções e latências muito variáveis. Quanto mais barato você for, pior será o hardware. Ao contrário do hardware verdadeiramente antigo, há uma boa chance de que eles contenham conjuntos de instruções (SSE4) que geralmente não são encontrados em hardware antigo. No entanto, se você quiser um sistema que ande devagar e feche com frequência, um host VPS barato será o início mais rápido.

Se você deseja apenas simular seu programa para analisar seu comportamento em uma máquina muito lenta, pode tentar fazer com que todo o programa seja executado como um threadoutro programa principal .

Desta forma, você pode priorizar o mesmo código com prioridades diferentes em alguns threads de uma vez e coletar dados de sua análise. Eu usei isso no desenvolvimento de jogos para análise de processamento de quadros.

Use sleep ou espere dentro de seu código. Não é a maneira mais brilhante de fazer, mas é aceitável em todos os tipos de computador com velocidades diferentes.

A maneira mais simples possível de fazer isso seria envolver seu código executável principal em um loop while com um sleep no final.

Por exemplo:

void main()
{
    while 1
    {
        // Logic
        // ...
        usleep(microseconds_to_sleep)
    }
}

Como as pessoas irão mencionar, esta não é a maneira mais precisa, já que seu código lógico ainda rodará na velocidade normal, mas com atrasos entre as execuções. Além disso, ele assume que seu código lógico é algo executado em um loop.

Mas é simples e configurável.