Shared File

Shared File é o mecanismo IPC mais básico, que consiste simplesmente em manipular um arquivo comum com as operações básicas de open, write, read e close, com essas operações é possível inserir informações no arquivo e bem como realizar a leitura delas.

Introdução

Shared File é o mecanismo IPC mais básico, que consiste simplesmente em manipular um arquivo comum com as operações básicas de open, write, read e close, com essas operações é possível inserir informações no arquivo e bem como realizar a leitura delas. Arquivos normalmente são usados para guardar diversos tipos de informação como configurações, logs, anotações entre outros, a figura baixo ajuda a ilustrar a comunicação entre dois processos por meio de uma arquivo.

sharedfile

Na figura é possível observar a comunicação entre dois processos distintos, sendo um o Produtor(Button), e o outro o Consumidor(LED).
Para esse cenário o Produtor insere no arquivo a informação que o Consumidor irá consumir, porém para que o acesso ao arquivo ocorra de forma sincronizada, faz-se necessário o uso da estrutura struct flock que funciona como uma espécie de chave para acessar o arquivo, que por meio da função fcntl, é possível verificar se o arquivo está com o acesso liberado, para poder manipulá-lo. A seguir podemos ver a systemcall fcntl:

para mais informações sobre essa estrutura execute no terminal o comando:

Implementação

Para demonstrar o uso desse IPC, iremos utilizar o modelo Produtor/Consumidor, onde o processo Produtor(button_process) vai escrever seu estado interno no arquivo, e o Consumidor(led_process) vai ler o estado interno e vai aplicar o estado para si. Aplicação é composta por três executáveis sendo eles:

  • launch_processes – é responsável por lançar os processos button_process e led_process atráves da combinação fork e exec
  • button_interface – é reponsável por ler o GPIO em modo de leitura da Raspberry Pi e escrever o estado interno no arquivo
  • led_interface – é reponsável por ler do arquivo o estado interno do botão e aplicar em um GPIO configurado como saída

launch_processes

No main criamos duas variáveis para armazenar o PID do button_process e do led_process, e mais duas variáveis para armazenar o resultado caso o exec venha a falhar.

Em seguida criamos um processo clone, se processo clone for igual a 0, criamos um array de strings com o nome do programa que será usado pelo exec, em caso o exec retorne, o estado do retorno é capturado e será impresso no stdout e aborta a aplicação. Se o exec for executado com sucesso o programa button_process será carregado.

O mesmo procedimento é repetido novamente, porém com a intenção de carregar o led_process.

button_interface

Definimos o nome do arquivo que vai armazenar o estado interno, e uma função de apoio para realizar a criação do arquivo que será usado para compartilhar as informações

Aqui é criado uma variável para a formatação do dado que será armazenado no arquivo.

Neste ponto é criada uma variável do tipo flock que vai controlar o acesso ao arquivo.

Aqui é criado o descritor que é o responsável por armazenar o id do arquivo, e já aproveitamos para inicializar a variável state que contém o estado que o LED vai assumir.

Neste trecho inicializamos a interface do botão com o descritor preenchido conforme selecionado no momento da compilação.

Aqui reside o core da aplicação, neste fragmento, o programa fica em polling aguardando que o botão seja pressionado, caso não, aguarda 1 ms para não consumir processamento. Se for pressionado realiza a troca de estado e interrompe o laço while.

Aqui é feita a abertura do arquivo

Setamos as configurações de proteção, nesse caso corresponde em travar para escrita, sempre partindo do início do arquivo, e recebe o PID do processo. Aplicamos a configuração, caso falhe é aguardado 1ms para uma nova tentativa.

Com a trava obtida, iniciamos a formatação do dado para ser escrito no arquivo, e assim a sua escrita no arquivo.

Após a escrita configuramos para o arquivo para ser destravado para ser utilizado por outro processo.

E por fim fechamos o arquivo e aguardamos 100ms e aguardamos a próxima interação com o botão.

led_interface

Definimos o nome do arquivo que vai recuperado o estado gerado pelo botão.

Aqui é criado uma variável para a recuperação do dado que foi armazenado no arquivo.

Neste ponto é criada uma variável do tipo flock que vai controlar o acesso ao arquivo.

Aqui é criado o descritor que é o responsável por armazenar o id do arquivo, e já aproveitamos para inicializar a variável state_old que contém o estado que o LED vai assumir, e por último criamos uma variável state_curr, que vai receber o valor contido no arquivo.

Neste trecho inicializamos a interface do LED com o descritor preenchido conforme selecionado no momento da compilação.

Aqui realizamos a abertura do arquivo, em modo de leitura, caso não seja possível obter o descritor, aguarda 1s e realiza uma nova tentativa.

Aqui preenchemos a estrutura com os parâmetros de trava para escrita, onde o arquivo é travado para escrita, sempre partindo do início do arquivo, e passamos o PID do processo.

Aqui obtemos as configuração atuais do arquivo, para podermos verificar quais são suas configurações

Caso esteja travado, fechamos o descritor e retornamos para o início do processo

Se estiver destravado setamos a trava para modo de leitura.

Lemos o conteúdo do arquivo.

Convertemos o valor lido e verificamos se o valor atual é diferente do valor anterior, caso for diferente aplica o novo estado, se não, não aplica a modificação.

Após a leitura configuramos para o arquivo para ser destravado para ser utilizado por outro processo.

E por fim fechamos o arquivo e aguardamos 100ms e aguardamos a próxima leitura.

Compilando, Executando e Matando os processos

Para compilar e testar o projeto é necessário instalar a biblioteca de hardware necessária para resolver as dependências de configuração de GPIO da Raspberry Pi.

Compilando

Para faciliar a execução do exemplo, o exemplo proposto foi criado baseado em uma interface, onde é possível selecionar se usará o hardware da Raspberry Pi 3, ou se a interação com o exemplo vai ser através de input feito por FIFO e o output visualizado através de LOG.

Clonando o projeto

Pra obter uma cópia do projeto execute os comandos a seguir:

Selecionando o modo

Para selecionar o modo devemos passar para o cmake uma variável de ambiente chamada de ARCH, e pode-se passar os seguintes valores, PC ou RASPBERRY, para o caso de PC o exemplo terá sua interface preenchida com os sources presentes na pasta src/platform/pc, que permite a interação com o exemplo através de FIFO e LOG, caso seja RASPBERRY usará os GPIO’s descritos no artigo.

Modo PC

Modo RASPBERRY

Executando

Para executar a aplicação execute o processo launch_processes para lançar os processos button_process e led_process que foram determinados de acordo com o modo selecionado.

Uma vez executado podemos verificar se os processos estão rodando atráves do comando

O output

Interagindo com o exemplo

Dependendo do modo de compilação selecionado a interação com o exemplo acontece de forma diferente

MODO PC

Para o modo PC, precisamos abrir um terminal e monitorar os LOG’s

Dessa forma o terminal irá apresentar somente os LOG’s referente ao exemplo.

Para simular o botão, o processo em modo PC cria uma FIFO para permitir enviar comandos para a aplicação, dessa forma todas as vezes que for enviado o número 0 irá logar no terminal onde foi configurado para o monitoramento, segue o exemplo

Output do LOG quando enviado o comando algumas vezez

MODO RASPBERRY

Para o modo RASPBERRY a cada vez que o botão for pressionado irá alternar o estado do LED.

Matando os processos

Para matar os processos criados execute o script kill_process.sh

Conclusão

Apesar de ser uma implementação simples, esse exemplo possui uma alta incidência de concorrência no acesso ao arquivo, para funcionar de forma razoável foi necessário inserir alguns atrasos para evitar(reduzir) a concorrência. Não é recomendado, pois precisa de outros mecanismos para sincronizar o seu acesso, como signal ou semaphore(que veremos mais adiante), mais a idéia é demonstrar o seu uso na forma pura sem interferência de outro IPC.

Referência

Outros artigos da série

<< FIFOSignal – O que é e como usar? >>
Notificações
Notificar
guest
2 Comentários
recentes
antigos mais votados
Inline Feedbacks
View all comments
MARCOS DE LIMA CARLOS
MARCOS DE LIMA CARLOS
11/05/2021 17:50

Show o artigo! Bem completo.

WEBINAR

Visão Computacional para a redução de erros em processos manuais

DATA: 23/09 ÀS 17:00 H