Microssegundo precisa (ou melhor) sincronismo de processos no Linux

Question

Eu preciso de uma maneira muito precisa a partes de tempo do meu programa. Eu poderia usar o relógio de alta resolução regular para isso, mas que irá retornar tempo wallclock, que não é o que eu preciso:. I needthe tempo gasto executando apenas o meu processo

Lembro-me de ver um patch para o kernel Linux que me permitem vez que meus processos para a precisão de nanossegundos, só que eu esqueci de marcá-la e eu esqueci o nome do patch, bem como:. (

Lembro-me de como ele funciona embora:

Em cada mudança de contexto, ele irá ler o valor de um relógio de alta resolução, e adicione o delta dos dois últimos valores para o tempo de processo do processo em execução. Isso produz uma alta resolução visão precisa do processo de tempo real processo.

O tempo de processo regular é mantido usando o relógio regular, o que é que eu acredito milissegundo preciso (1000Hz), que é muito grande para os meus propósitos.

Alguém sabe o Kernel Patch eu estou falando? Lembro-me também que era como uma palavra com uma carta antes ou depois -. Algo como 'rtimer' ou algo assim, mas eu não me lembro exatamente

(Outras sugestões são bem-vindos também)

---

O Completely Fair Scheduler sugeriu sugerido por Marko não é o que eu estava procurando, mas parece promissor. O problema que tenho com ele é que as chamadas que pode utilizar para obter o tempo de processo ainda não estão retornando valores que são bastante granular.

• vezes () está retornando valores 21, 22, em milissegundos.
• relógio () está retornando valores 21000, 22000, mesmo granularidade.
• getrusage () está retornando valores como 210002, 22001 (e somesuch), eles parecem ter um pouco melhor precisão, mas os valores olhar visivelmente o mesmo.

Então, agora o problema que eu provavelmente estou tendo é que o kernel tem a necessidade de informação, eu só não sei a chamada de sistema que vai devolvê-lo.

Answer 1

Se você estiver olhando para este nível de resolução de temporização, você provavelmente está tentando fazer alguma micro-otimização. Se for esse o caso, você deve olhar para PAPI . Não só fornecer tanto relógio de parede e (único processo) informação virtual momento, ele também fornece acesso aos contadores de eventos de CPU, que pode ser indispensável quando você está tentando melhorar o desempenho.

http://icl.cs.utk.edu/papi/

Answer 2

Consulte esta questão para obter mais algumas informações .

Algo que eu usei para essas coisas é gettimeofday (). Ele fornece uma estrutura com segundos e microssegundos. Chamá-lo antes do código, e novamente depois. Em seguida, basta subtrair as duas estruturas usando timersub, e você pode obter o tempo que levou em segundos a partir do campo tv_usec.

Answer 3

Se você precisar de muito pequenas unidades de tempo para para (presumo) testar a velocidade de seu software, eu recomendaria apenas correr as peças que você deseja tempo em um loop milhões de vezes, tomar o tempo antes e depois do laço e calcular a média. Um efeito colateral agradável de fazer isso (além de não precisar descobrir como usar nanossegundos) é que você deseja obter resultados mais consistentes, pois a sobrecarga aleatória causada pela sceduler OS será a média para fora.

É claro que, a menos que seu programa não precisa ser capaz de executar milhões de vezes em um segundo, provavelmente é rápido o suficiente, se você não pode medir um tempo de execução milissegundo.

Answer 4

Eu acredito CFC ( Completely Fair Scheduler ) é o que você está procurando.

Answer 5

Você pode usar o temporizador de eventos de alta precisão ( HPET ) se você tiver um bastante recente kernel 2.6. Confira Documentação / hpet.txt sobre como usá-lo. Esta solução é a plataforma embora dependente e eu acredito que só está disponível em sistemas x86 mais recentes. HPET tem pelo menos um temporizador 10MHz por isso deve atender às suas necessidades facilmente.

Eu acredito que várias implementações PowerPC da Freescale apoiar um contador de ciclo de instrução exata bem. Eu usei isso uma série de anos atrás ao perfil código altamente otimizado, mas eu não consigo lembrar o que é chamado. Acredito Freescale tem um patch para o kernel você tem que aplicar a fim de acessá-lo a partir do espaço do usuário.

Answer 6

http://allmybrain.com/2008/ 10/06 / sincronismo-cc-code-on-linux /

pode ser de ajuda para você (diretamente se você está fazendo isso em C / C ++, mas espero que ele vai dar-lhe indicações, mesmo se você não é) ... Ele pretende fornecer precisão microssegundo, que apenas passa o seu critério. :)

Answer 7

Eu acho que encontrei o patch do kernel que eu estava procurando. Postá-lo aqui para que eu não esqueça o link:

http://user.it.uu.se/~mikpe/ linux / PERFCTR / http://sourceforge.net/projects/perfctr/

Edit: Ele funciona para os meus propósitos, embora não muito user-friendly

.

Answer 8

tente do CPU timestamp contra ? Wikipedia parece sugerir usando clock_gettime ().