Os métodos para limitar os estados C acima serão todos permanentes (até que o sistema seja reinicializado). Se você quisesse gostaria de ter um sistema com latência extremamente baixa durante certas horas, mas quer mais economia de energia em outras vezes, existe um método para controlar dinamicamente quais estados-C são usados.
Para controlar dinamicamente os estados C, abra o arquivo / dev / cpu_dma_latency e grave a latência máxima permitida para ele. Isso impedirá que os estados C com latências de transição maiores do que o valor especificado sejam utilizados, desde que o arquivo / dev / cpu_dma_latency seja mantido aberto. A gravação de uma latência máxima permitida de 0 manterá os processadores em C0 (como o uso do parâmetro do kernel "idle = poll") e a gravação de um valor baixo (geralmente 5 ou inferior) deve forçar os processadores a C1 quando ociosos. O valor exato necessário para restringir os processadores ao estado C1 depende de vários fatores, como qual driver inativo você está usando, quais CPUs você está usando e, possivelmente, as tabelas ACPI em seu sistema. Valores mais altos também podem ser gravados para restringir o uso de estados C com latência maior que o valor gravado. O valor usado deve corresponder aos valores de latência em / sys / devices / system / cpu / cpuX / cpuidle / stateY / latency (onde X é o número da CPU e Y é o estado inativo) - estados inativos da CPU que têm uma latência maior que escrito para / dev / cpu_dma_latency não deve ser usado.
Uma maneira simples de fazer isso é compilar um programa simples que irá gravar nesse arquivo e permanecer aberto até ser eliminado. Um exemplo de tal programa está abaixo, e pode ser compilado cortando e colando o código em um arquivo chamado setcpulatency.c, e executando “make setcpulatency”. Portanto, para minimizar a latência durante certas horas, por exemplo, das 8h às 17h, um cron job pode ser configurado para ser executado às 8h. Esse cron job poderia executar setcpulatency em segundo plano com um argumento de 0, com uma entrada na tabela cron assim:
00 08 * * * /path/to/setcpulatency 0 &
Então, às 17h, outro trabalho do cron pode matar qualquer programa que mantenha o / dev / cpu_dma_latency aberto:
00 17 * * * kill -9 'lsof –t /dev/cpu_dma_latency'
Naturalmente, este é apenas um exemplo para mostrar como os estados C podem ser controlados dinamicamente ... o serviço crond geralmente é desativado em ambientes de baixa latência, mas essas etapas podem ser executadas manualmente ou executadas por outros meios.
#include <stdio.h>
#include <fcntl.h>
int main(int argc, char **argv) {
int32_t l;
int fd;
if (argc != 2) {
fprintf(stderr, "Usage: %s <latency in us>\n", argv[0]);
return 2;
}
l = atoi(argv[1]);
printf("setting latency to %d us\n", l);
fd = open("/dev/cpu_dma_latency", O_WRONLY);
if (fd < 0) {
perror("open /dev/cpu_dma_latency");
return 1;
}
if (write(fd, &l, sizeof(l)) != sizeof(l)) {
perror("write to /dev/cpu_dma_latency");
return 1;
}
}