2012-08-04 3 views
2

J'ai essayé de mettre en œuvre IPC avec FIFO, je l'ai fait ci-dessous et il semble fonctionner très bien, testé plusieurs fois et il me semble bon.IPC avec FIFO en C sous linux

La question est de savoir de quoi je dois m'occuper, je sais que la lecture et l'écriture seront atomiques car je vais écrire bien en dessous de PIPE_BUF.

J'ai couru comme ça

./writer

./reader ./reader

et j'ai vu que que les lecteurs fonctionnent très bien, par exemple le premier lecteur lit 1 alors le deuxième lecteur lit 2 et 3 puis le premier lecteur lit 4 et ainsi de suite.

s'il vous plaît noter que j'ai trouvé le code dans here et je l'ai modifié.

writer.c

#include<stdio.h> 
#include<unistd.h> 
#include<fcntl.h> 
#include<sys/types.h> 
#include<sys/stat.h> 
#include<string.h> 
    int main() 
    { 
    int fd,fd1; 
    fd=open("fifo1",O_WRONLY); 
    int data = 1; 
    while (1){ 
    write(fd,&data,sizeof(int)); 
    usleep(10); 
    data++; 
    } 

    //printf("File Content :%s",s1); 
    } 

reader.c

#include<stdio.h> 
#include<unistd.h> 
#include<fcntl.h> 
#include<sys/types.h> 
#include<sys/stat.h> 
#include<string.h> 
    int main() 
    { 
    int fd,fname; 
    mkfifo("fifo1",0600); 
    fd=open("fifo1",O_RDONLY); 
    int d = 0; 
    while(read(fd,&d,sizeof(int))!=0) 
    { 
    printf("%d\n",d); 
    usleep(10); 
    } 
    close(fd); 
    } 

Répondre

1

Si un processus de lecture est mort de faim, il se bloquer sur le read syscall, et l'écrivain serait éventuellement prévu par le noyau et écrira quelque chose. La limite PIPE_BUF compte que pour la taille maximale d'un message unique (par exemple une lecture, et vous ne serez pas atteindre cette taille). Symétriquement, si l'écrivain écrit beaucoup, le tampon fifo est plein (au-dessus de PIPE_BUF) et le syscall write est bloqué dans le processus d'écriture. Finalement, le planificateur exécutera le lecteur.

Voir read(2) et write(2) pages de manuel. En savoir plus sur poll(2) peut également s'avérer utile lorsque vous souhaitez effectuer un multiplexage. Voir aussi fifo(7).

PIPE_BUF est une limite à chaque lecture et écriture atomique. De plus grandes lectures et écritures pourraient être faites seulement en partie. Le noyau garantit que si une opération de lecture ou d'écriture peut être réalisée sur moins de PIPE_BUF octets (c'est-à-dire quand une telle quantité d'octets est disponible!), Elle sera effectuée en totalité sur les canaux et les descripteurs de fichiers associés.

Lire les et/ou advanced linux programming livres