Desempenho IPC: Named Pipe vs Socket

Todo mundo parece dizer que os pipes nomeados são mais rápidos do que os soquetes IPC. Eles são muito mais rápidos? Eu preferiria usar soquetes porque eles podem fazer comunicação bidirecional e são muito flexíveis, mas optarei pela velocidade em vez da flexibilidade se for em quantidade considerável.

Eu sugeriria que você pegasse o caminho fácil primeiro, isolando cuidadosamente o mecanismo IPC para que você pudesse mudar de soquete para tubo, mas eu definitivamente escolheria primeiro com o soquete. Você deve ter certeza de que o desempenho do IPC é um problema antes de otimizar preventivamente.

E se você tiver problemas por causa da velocidade do IPC, acho que você deve considerar mudar para memória compartilhada em vez de canalizar.

Se você quiser fazer algum teste de velocidade de transferência, deve experimentar o socat , que é um programa muito versátil que permite criar quase qualquer tipo de túnel.

Melhores resultados que você obterá com a solução de memória compartilhada .

Pipes nomeados são apenas 16% melhores do que soquetes TCP .

Os resultados são obtidos com o benchmarking IPC :

• Sistema: Linux (Linux ubuntu 4.4.0 x86_64 i7-6700K 4,00 GHz)
• Mensagem: 128 bytes
• Contagem de mensagens: 1000000

Referência de tubo:

Message size:       128
Message count:      1000000
Total duration:     27367.454 ms
Average duration:   27.319 us
Minimum duration:   5.888 us
Maximum duration:   15763.712 us
Standard deviation: 26.664 us
Message rate:       36539 msg/s

Referência FIFOs (pipes nomeados):

Message size:       128
Message count:      1000000
Total duration:     38100.093 ms
Average duration:   38.025 us
Minimum duration:   6.656 us
Maximum duration:   27415.040 us
Standard deviation: 91.614 us
Message rate:       26246 msg/s

Comparativo de mercado do Message Queue:

Message size:       128
Message count:      1000000
Total duration:     14723.159 ms
Average duration:   14.675 us
Minimum duration:   3.840 us
Maximum duration:   17437.184 us
Standard deviation: 53.615 us
Message rate:       67920 msg/s

Referência de memória compartilhada:

Message size:       128
Message count:      1000000
Total duration:     261.650 ms
Average duration:   0.238 us
Minimum duration:   0.000 us
Maximum duration:   10092.032 us
Standard deviation: 22.095 us
Message rate:       3821893 msg/s

Referência de soquetes TCP:

Message size:       128
Message count:      1000000
Total duration:     44477.257 ms
Average duration:   44.391 us
Minimum duration:   11.520 us
Maximum duration:   15863.296 us
Standard deviation: 44.905 us
Message rate:       22483 msg/s

Comparativo de mercado de soquetes de domínio Unix:

Message size:       128
Message count:      1000000
Total duration:     24579.846 ms
Average duration:   24.531 us
Minimum duration:   2.560 us
Maximum duration:   15932.928 us
Standard deviation: 37.854 us
Message rate:       40683 msg/s

Referência ZeroMQ:

Message size:       128
Message count:      1000000
Total duration:     64872.327 ms
Average duration:   64.808 us
Minimum duration:   23.552 us
Maximum duration:   16443.392 us
Standard deviation: 133.483 us
Message rate:       15414 msg/s

Eu vou concordar com shodanex, parece que você está prematuramente tentando otimizar algo que ainda não é problemático. A menos que você saiba que os soquetes serão um gargalo, eu apenas os usaria.

Muitas pessoas que juram por pipes nomeados encontram um pouco de economia (dependendo de como tudo o mais está escrito), mas acabam com um código que passa mais tempo bloqueando uma resposta IPC do que fazendo um trabalho útil. Claro, esquemas sem bloqueio ajudam nisso, mas podem ser complicados. Passando anos trazendo códigos antigos para a era moderna, posso dizer que a aceleração é quase nula na maioria dos casos que vi.

Se você realmente acha que os soquetes vão atrasar você, então saia do portão usando a memória compartilhada com atenção cuidadosa em como você usa os bloqueios. Novamente, na realidade, você pode encontrar uma pequena aceleração, mas observe que está desperdiçando uma parte dela esperando bloqueios de exclusão mútua. Não vou defender uma viagem ao inferno do futex (bem, não exatamente mais o inferno em 2015, dependendo da sua experiência).

Libra por libra, os soquetes são (quase) sempre a melhor maneira de obter IPC de espaço do usuário em um kernel monolítico ... e (normalmente) a mais fácil de depurar e manter.

Lembre-se de que soquetes não significam necessariamente IP (e TCP ou UDP). Você também pode usar soquetes UNIX (PF_UNIX), que oferecem uma melhoria de desempenho perceptível em relação à conexão com 127.0.0.1

Como frequentemente, os números dizem mais do que sentimento, aqui estão alguns dados: Pipe vs Unix Socket Performance (opendmx.net) .

Este benchmark mostra uma diferença de velocidade cerca de 12 a 15% mais rápida para tubos.

Se você não precisa de velocidade, os soquetes são o caminho mais fácil!

Se o que você está vendo é a velocidade, a solução mais rápida é a memória compartilhada, não os canais nomeados.

Para comunicação bidirecional com canais nomeados:

• Se você tiver poucos processos, poderá abrir dois tubos para duas direções (processA2ProcessB e processB2ProcessA)
• Se você tiver muitos processos, pode abrir canais de entrada e saída para cada processo (processAin, processAout, processBin, processBout, processCin, processCout etc)
• Ou você pode ir híbrido como sempre :)

Pipes nomeados são muito fáceis de implementar.

Por exemplo, eu implementei um projeto em C com pipes nomeados, graças à comunicação baseada em entrada-saída de arquivo padrão (fopen, fprintf, fscanf ...) foi tão fácil e limpo (se isso também for uma consideração).

Até os codifiquei com java (estava serializando e enviando objetos sobre eles!)

Pipes nomeados têm uma desvantagem:

• eles não escalam em vários computadores como soquetes, uma vez que dependem do sistema de arquivos (assumindo que o sistema de arquivos compartilhado não é uma opção)

Um problema com os soquetes é que eles não têm uma maneira de liberar o buffer. Existe algo chamado algoritmo de Nagle, que coleta todos os dados e os libera após 40 ms. Portanto, se for a capacidade de resposta e não a largura de banda, talvez seja melhor usar um tubo.

Você pode desabilitar o Nagle com a opção de socket TCP_NODELAY, mas o final da leitura nunca receberá duas mensagens curtas em uma única chamada de leitura.

Então teste, acabei sem nada disso e implementei filas baseadas em mapeamento de memória com pthread mutex e semáforo em memória compartilhada, evitando muitas chamadas de sistema do kernel (mas hoje elas não são mais lentas).

Pipes e soquetes nomeados não são funcionalmente equivalentes; os soquetes fornecem mais recursos (eles são bidirecionais, para começar).

Não podemos dizer qual terá melhor desempenho, mas suspeito fortemente que não importa.

Os soquetes de domínio Unix farão praticamente o que os soquetes tcp farão, mas apenas na máquina local e com (talvez um pouco) menor sobrecarga.

Se um soquete Unix não for rápido o suficiente e você estiver transferindo muitos dados, considere o uso de memória compartilhada entre o cliente e o servidor (que é MUITO mais complicado de configurar).

Tanto o Unix quanto o NT têm "pipes nomeados", mas são totalmente diferentes no conjunto de recursos.

Você pode usar uma solução leve como ZeroMQ [ zmq / 0mq ]. É muito fácil de usar e muito mais rápido que os soquetes.