Carrega a saída de texto simples sem arquivos de gravação

Question

Eu tenho um programa (que eu corro do terminal) que gera 4 arquivos de texto plano.

Por exemplo

./myprog

gera file1.dat , file2.dat , file3.dat , file4.dat .

Eu quero criar um script que me permita executar myprog e carregar (ler) essas quatro "saídas de arquivo", mas sem gravar os arquivos físicos (pode ser, carregar esses arquivos apenas no RAM). Isso é possível?

O motivo é que eu preciso de cerca de 70000 desses arquivos, então não quero perder tempo salvando arquivos extras, só preciso usar as informações.

=============================================

Exemplo específico que me foi perguntado nos comentários

1. software triangular (software livre para gerar malhas para cálculo numérico, escrito em C) leia o arquivo mesh.poly :

:

4 2 0 1
1   0     0     20
2   1     0     20
3   1     1     10
4   0     1     10

4 1
1 1 2   20 # bottom side
2 2 3   20 # right side
3 3 4   10 # top side
4 4 1   20 # left side

0

1
1 0.5 0.5 1 0.0005

2. O comando triangle mesh.poly gera os seguintes arquivos:

mesh.node :

4  2  0  1
   1    0  0    20
   2    1  0    20
   3    1  1    10
   4    0  1    10

e mesh.ele

2  3  0
   1       4     1     2
   2       2     3     4

e outros dois arquivos, no total: quatro arquivos de saída.

3. Depois de gerar esses arquivos, preciso usar as informações em outro programa, escrito por mim em fortran, que precisa das informações *.node e *.ele . Estou pensando em escrever um arquivo .sh para fazer isso automaticamente, mas posso usar python ou qualquer outra linguagem que permita executar programas executáveis.

Para carregar (ler), o mesh.node e mesh.ele são fáceis. Mas eu preciso gerar milhares de arquivos físicos como saída de triangle e entrada do meu código fortran. Por esse motivo, estou procurando uma maneira de "escrever arquivos virtuais" pensando que será mais eficiente e limpo.

Meu problema é que eu tenho cerca de 70000 mesh.poly gerando arquivos de saída (e pequenos) 70000x4.

    

Answer 1

Você pode usar um sistema de arquivos com suporte de memória (tmpfs) ou FIFOs (pipes nomeados)

Talvez sua distribuição já tenha configurado um ponto de montagem tmpfs em algum lugar. Você poderia usar isso para todos os arquivos temporários. (por exemplo, /tmp/ em alguns sistemas e configurações)

No meu sistema, por padrão, eu obtenho um tmpfs suficientemente grande em / run / user / 1000, isso seria ótimo para os < 300MiB que você especificou.

Se você é root na máquina, pode montar um novo em algum lugar e usá-lo.

Em caso negativo: Como usuário normal, você pode configurar 4 Pipes nomeados com mkfifo e usá-los como "área de armazenamento temporário".

Seu algoritmo poderia então estar nas seguintes linhas de pseudo-código.

make_4_fifos_with_mkfifo
foreach polyfile in directory do
  rename_fifos_to_use_given_prefix $polyfile
  run triangle $polyfile
  run fortranCMD polyfile.node $polyfile.ele ...
done

O código acima pode ser implementado em muitas das linguagens de script existentes no seu sistema. Escolha qualquer um que você esteja confortável.

    

Answer 2

É bem simples, você pode escrever um script em perl ou tcl. Abaixo está o exemplo tcl.

set fp [open "somefile" r]
set file_data [read $fp]
close $fp

set data [split $file_data "\n"]
foreach line $data {
     # do some line processing here
}

Neste exemplo, somefile é um nome de arquivo e o conteúdo é copiado para a variável file_data.

Para mais informações link