Como compartilhar dados entre processos Python sem gravar no disco

Question

Helllo, Eu gostaria de compartilhar pequenas quantidades de dados (<1K) entre python e processos. Os dados são física PC / 104 IO dados que muda rapidamente e muitas vezes (24x7x365). Haverá um único "servidor" de gravar os dados e vários clientes de leitura porções dela. O sistema esta será executado em usos memória flash (cartão CF), em vez de um disco rígido, por isso estou preocupado com desgaste a memória flash com um esquema baseado em arquivo. Eu também gosto de usar menos energia (tempo do processador) como estamos 100% movido a energia solar.

• Esta é uma preocupação válida? Poderíamos, eventualmente, alterar o cartão CF para um SSD.
• Será que mudando um valor usando mmap fisicamente gravar os dados no disco ou este é um arquivo virtual?
• Iremos estar em execução no Debian então talvez o IPC POSIX para o módulo python é a melhor solução. Alguém já usou?
• Alguém já experimentou o href="http://sourceforge.net/projects/poshmodule/" rel="noreferrer"> Sharing objeto módulo? Parece promissor, à primeira vista, mas é em "Alpha" e não parecem estar sendo ativamente desenvolvidos.

Obrigado

UPDATE: Nós abrandou a taxa de actualização de dados máxima a cerca de 10 Hz, mas mais tipicamente de 1 Hz. Clientes só será notificado quando um valor muda em vez da uma taxa constante atualização. Temos ido a um modelo de vários servidores / múltiplos clientes, onde cada servidor é especializada em um determinado tipo de instrumento ou função. Desde descobriu-se que a maior parte da programação ia ser feito por programadores Java, acabamos usando JSON-RPC sobre TCP. Os servidores wil ser escrito em Java, mas eu ainda espero escrever o cliente principal em Python e estou investigação implementações JSON-RPC.

Answer 1

Uma alternativa para escrever os dados para o arquivo no processo do servidor pode ser a escrever diretamente para os processos do cliente:

soquetes de domínio Use UNIX (ou sockets TCP / IP se os clientes são executados em máquinas diferentes) para conectar cada cliente para o servidor, e têm a gravação do servidor para esses soquetes. Dependendo do seu modelo de processamento particular, a escolha de um cliente / socket pode ser feito pelo servidor (por exemplo round-robin) ou pelos clientes de sinalização que eles estão prontos para mais.

Answer 2

Criar uma partição ramfs e gravação para isso. (Você pode usar tmpfs, mas ao contrário tmpfs, ramfs não é trocado para o disco). No entanto, como ramfs não tem um limite de tamanho, você deve tomar cuidado para que você não fique sem memória; desde que você está escrevendo apenas uma pequena bit de dados lá, não deve ser um problema.

Desta forma, os seus dados nunca vai ser gravados em um disco (nota: você vai perdê-los se poder falha).

Veja também as ramfs docs .

Answer 3

De acordo com o href="http://en.wikipedia.org/wiki/Mmap" rel="nofollow noreferrer"> artigo , memória mapeada conteúdo dos arquivos são gravados de volta para o disco quando atualizado.

Você já olhou para o módulo de multiprocessamento (na biblioteca padrão?) - especialmente o estado Sharing parte entre os processos

ramfs como mencionado por Piskvor também parece ser uma boa solução -. Especialmente quando nem todos os processos são escritos em Python

Answer 4

Ao executar em sistemas de flash, verifique se o sistema de arquivos é projetado adequadamente para maximizar a vida útil da memória flash (nivelamento de desgaste). JFFS e, creio eu, outros são agora capazes de fazer isso de forma eficaz. Se você usar esse sistema de uma, você não deve estar muito preocupado sobre o uso do flash, mas certamente se você estiver escrevendo um fluxo constante de dados que você gostaria de evitar fazer isso no flash.

Usando um sistema de arquivos RAM é uma boa idéia. Melhor ainda é evitar sistemas de arquivos completo, se o projeto do sistema vai deixar você. Para o efeito que você menciona POSH. Eu nunca tentei isso, mas nós encontramos Pyro ( "python Remote Objects" ) para ser uma solução elegante e eficaz em alguns casos similares.

E, claro, há o módulo de biblioteca multiprocessing padrão, que tem algumas semelhanças em termos de como ele se comunica entre processos. Eu começaria lá para qualquer novo desenvolvimento nesta área, e ir para outro lugar apenas se ele não conseguiu pan out.