Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
2489 connectés 

  FORUM HardWare.fr
  Programmation
  C

  C, linux et les pipes

 
 


 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

C, linux et les pipes

n°2079082
effa
Posté le 30-05-2011 à 12:46:51  profilanswer
 

Bonjour, j'ai un TP à realiser pour lequel je m'arrache les cheveux....
L'objectif est creer 2 equipes composées d'un processus pere et de 5 sous processus. Chque sous processus doit ecrire dans un fichier son PID en binaire, et son PPID. les fichiers sont numérotés de 0000 a 9999. Le processus pere envoit aux sous processus le numero de fichier a conquérir. Le processus pere est soumis à une tempo de 20s.
En outre, si un processus de l'autre equipe ouvre un fichier deja conquis par l'autre equipe, il recupere le pid de l'adversaire et le tue via SIG_QUIT.
Enfin, un programme qui compte les points par equipe devra etre mis à disposition....
Voila mon debut de code (j'ai honte de le dire, mais j'y ai déjà passé une semaine entière....)
Je crois que seul le premier n° de fichier est recupéré par le sous processus ?
D'autre part, je n'ai pas la moindre idee de comment installer le programme qui compte les points par équipe...
HELP svp, mon exam arrive et je n'ai pas encore pu commencer les revisions tant que je n'ai pas fini ca....et ce n'est pas faute de ne pas bosser !
 

Code :
  1. #include <stdio.h>
  2. #include <sys/types.h>
  3. #include <unistd.h>
  4. #include <stdlib.h>
  5. #include <sys/wait.h>
  6. #include <sys/msg.h>
  7. #include <sys/sem.h>
  8. #include <signal.h>
  10. void pere1();
  11. void pere2();
  12. void fils1();
  13. void fils2();
  14. int randomSel();
  15. void verif();
  16. int rand_a_b();
  18. //creation des tubes en lecture et en ecriture - 1 pour chaque equipe
  19. int pip1[2], pip2[2];
  20. char buff[5];
  22. // variables pour la sélection aléatoire des fichiers :
  23. int nb_arrivee=0;
  24. int min = 0000;
  25. int max = 8001;
  28. int main()
  29. {
  31. // les processus (pg1 sous processus pa1.1 a 5 et processus pg2 avec sous processus pa2.1 a 5)
  32. pid_t pg1,pg2, pa11, pa12, pa13, pa14, pa15, pa21, pa22, pa23, pa24, pa25;
  34. // variables pour récupérer nb de points
  35. int w11, w12, w13, w14, w15, w21, w22, w23, w24, w25;
  36. int r11, r12, r13, r14, r15, r21, r22, r23, r24, r25;
  39. // creation du premier processus general - equipe 1
  40. pg1=fork();
  43. if (pg1==0) {
  45. // creation pipe a partager entre pg1 et ses 5 sous processus
  46. // signale erreur si pb à la création d'un pipe
  47. if(pipe(pip1) == -1)
  48. {
  49.  perror("Erreur à la création du tube de communication 1." );
  50.  exit(-1);
  51. }
  53. // création des 5 sous processus - equipe 1
  54. pa11=fork();
  55. pa12=fork();
  56. pa13=fork();
  57. pa14=fork();
  58. pa15=fork();
  60. //appelle les fonctions selon type de processus
  61. switch(fork())
  62. {
  63.  case -1 :
  64.   perror("Erreur lors de la création du fils." );
  65.   exit(-1);
  66.  case 0 :
  67.   fils1();
  68.   break;
  69.  default :
  70.   pere1();
  71.   break;
  72. }
  73. return(0);
  75. }
  78. //creation du deuxième processus general - equipe 2
  79. pg2=fork();
  81. if (pg2==0) {
  83. // creation pipe a partager entre pg2 et ses 5 sous processus
  84. // signale erreur si pb à la création d'un pipe
  85. if(pipe(pip2) == -1)
  86. {
  87.  perror("Erreur à la création du tube de communication 3." );
  88.  exit(-1);
  89. }
  90. // création des 5 sous processus - equipe 2
  91. pa21=fork();
  92. pa22=fork();
  93. pa23=fork();
  94. pa24=fork();
  95. pa25=fork();
  99. //appelle les fonctions selon type de processus
  100. switch(fork())
  101. {
  102.  case -1 :
  103.   perror("Erreur lors de la création du fils." );
  104.   exit(-1);
  105.  case 0 :
  106.   fils2();
  107.   break;
  108.  default :
  109.   pere2();
  110.   break;
  111. }
  112. return(0);
  113. exit(0);
  114. }
  116. }// fin main
  118. // equipe 1
  119. void pere1(){
  121. // mise en place du timing
  122. //alarm(20);
  123. //while(20) {
  124. // sélection des fichiers
  125. int i;
  126. for (i=0; i<4; i++) {
  127. rand_a_b(min, max);
  128. char buff2 [4];
  129. // transforme le résultat en string
  130. sprintf(buff2, "%d", nb_arrivee);
  131. // ecriture et transmission des n° de fichiers via un pipe
  132. close(pip1[0]);
  133. printf("[Père :]Ecriture dans le tube de communication 1.\n" );
  134. if(write(pip1[1],  buff2, 4) > 4)
  135. {
  136.  perror("Erreur lors de l'écriture dans le tube de communication 1." );
  137.  exit(-1);
  138. }
  139. wait(NULL);
  140. close(pip1[1]);
  141. }
  142. }
  144. void fils1(){
  145. while(1) {
  146. // verifie si il a recut un signal SIG_QUIT
  147. signal(SIGQUIT, verif);
  148. //lit le n° de fichier  
  149. int car_lu;
  150. close(pip1[1]);
  151. printf("[Fils :]Attente de lecture\n" );
  152. car_lu=read(pip1[0], buff, 4);
  153. printf("[Fils :]Contenu de la lecture : %s\n",buff);
  154. close(pip1[0]);
  155. // ajoute  
  156. // ecrit
  157. exit(0);
  158. }}
  160. // equipe 2
  161. void pere2(){
  163. // mise en place du timing
  164. //alarm(20);
  165. //while(20) {
  166. int j;
  167. for (j=0; j<4; j++) {
  168. // sélection des fichiers
  169. rand_a_b(min, max);
  170. char buff2 [4];
  171. sprintf(buff2, "%d", nb_arrivee);
  172. // ecriture et transmission des n° de fichiers via un pipe
  173. close(pip2[0]);
  174. printf("[Père :]Ecriture dans le tube de communication 2.\n" );
  175. if(write(pip2[1], buff2, 4) > 4)
  176. {
  177. perror("Erreur lors de l'écriture dans le tube de communication 2." );
  178.  exit(-1);
  179. }
  181. wait(NULL);
  182. close(pip2[1]);
  183. }
  184. }
  186. void fils2(){
  188. while(1) {
  189. // verifie si il a recut un signal SIG_QUIT
  190. signal(SIGQUIT, verif);
  191. //lit le n° de fichier  
  192. int car_lu;
  193. close(pip2[1]);
  194. printf("[Fils :]Attente de lecture\n" );
  195. car_lu=read(pip2[0], buff, 4);
  196. printf("[Fils :]Contenu de la lecture : %s\n",buff);
  197. close(pip2[0]);
  198. exit(0);
  199. }
  200. }
  202. void verif(int num_sig) {
  203. if (num_sig==3) {
  204.  printf("je suis le processus %d et je suis mort", getpid());
  205.  exit(1);
  206.   }
  207. // réarme pour qu'unix ne repositionne pas le traitement par défaut
  208. signal(num_sig, verif);
  209. }
  212. int rand_a_b(int min, int max){
  213. nb_arrivee = rand()%(max-min)+min+1999;
  214. printf("nb d'arrivee %d : nb de depart %d : ", nb_arrivee , nb_arrivee-1999);
  215. return (nb_arrivee);
  217. }

Message cité 1 fois
mood
Publicité
Posté le 30-05-2011 à 12:46:51  profilanswer
 

n°2079164
shaoyin
Posté le 30-05-2011 à 16:23:44  profilanswer
 

effa a écrit :


 

Code :
  1. // création des 5 sous processus - equipe 1
  2. pa11=fork();
  3. pa12=fork();
  4. pa13=fork();
  5. pa14=fork();
  6. pa15=fork();
  8. //appelle les fonctions selon type de processus
  9. switch(fork())
  10. {
  11.  case -1 :
  12.   perror("Erreur lors de la création du fils." );
  13.   exit(-1);
  14.  case 0 :
  15.   fils1();
  16.   break;
  17.  default :
  18.   pere1();
  19.   break;
  20. }
  21. return(0);
  25. //creation du deuxième processus general - equipe 2
  26. pg2=fork();
  28. if (pg2==0) {
  30. // creation pipe a partager entre pg2 et ses 5 sous processus
  31. // signale erreur si pb à la création d'un pipe
  32. if(pipe(pip2) == -1)
  33. {
  34.  perror("Erreur à la création du tube de communication 3." );
  35.  exit(-1);
  36. }
  37. // création des 5 sous processus - equipe 2
  38. pa21=fork();
  39. pa22=fork();
  40. pa23=fork();
  41. pa24=fork();
  42. pa25=fork();
  46. //appelle les fonctions selon type de processus
  47. switch(fork())
  48. {
  49.  case -1 :
  50.   perror("Erreur lors de la création du fils." );
  51.   exit(-1);
  52.  case 0 :
  53.   fils2();
  54.   break;
  55.  default :
  56.   pere2();
  57.   break;
  58. }



 
Bon, j'avoue que je n'ai pas tout lu, mais déjà tes appels à "fork" sont foireux... C'est après chaque appel à cette fonction qu'il faut tester le code retour, sinon ton processus père va effectivement créer 5 fils, mais actuellement chaque fils qu'il crée engendre à son tour autant de processus que de fils restant à créer. Autant dire que ton processus père prend un sacré coup de vieux puisqu'il devient rapidement arrière-arrière-arrière grand père !
 
Ensuite, dans tes "switch", il ne faut surtout pas appeler "fork" à nouveau, parce que tu vas recréer un nouveau processus (comme s'il n'y en avait pas déjà assez...).
 

n°2079173
effa
Posté le 30-05-2011 à 16:35:01  profilanswer
 

merci, j'ai changé ca et d'autres choses :  
 

Code :
  1. #include <stdio.h>
  2. #include <sys/types.h>
  3. #include <unistd.h>
  4. #include <stdlib.h>
  5. #include <sys/wait.h>
  6. #include <sys/msg.h>
  7. #include <sys/sem.h>
  8. #include <signal.h>
  10. void pere1();
  11. void pere2();
  12. void fils1();
  13. void fils2();
  14. void verif();
  15. int rand_a_b();
  17. //creation des tubes en lecture et en ecriture - 1 pour chaque equipe
  18. int pip1[2], pip2[2];
  20. // variables pour la sélection aléatoire des fichiers :
  21. int num_fichier=0;
  22. int min = 0000;
  23. int max = 9999;
  26. int main()
  27. {
  29. // les processus (pg1 sous processus pa1.1 a 5 et processus pg2 avec sous processus pa2.1 a 5)
  30. pid_t pg1,pg2;
  32. // variables pour récupérer nb de points
  33. int w11, w12, w13, w14, w15, w21, w22, w23, w24, w25;
  34. int r11, r12, r13, r14, r15, r21, r22, r23, r24, r25;
  36. // variable permettant d'appliquer le signal  
  37. int sig=0;
  39. // creation du premier processus general - equipe 1
  40. pg1=fork();
  43. if (pg1==0) {
  45. // creation pipe a partager entre pg1 et ses 5 sous processus
  46. // signale erreur si pb à la création d'un pipe
  47. if(pipe(pip1) == -1)
  48. {
  49.  perror("Erreur à la création du tube de communication 1." );
  50.  exit(-1);
  51. }
  53. // création des 5 sous processus - equipe 1
  54. // et appelle les fonctions selon type de processus
  55. int nb = 0;
  56. pid_t pid;
  58. do
  59. {
  60.    pid = fork ();
  61.    if(pid==0){
  62.        fils1();}
  63.    nb++;
  64. } while (nb < 5);
  66. pere1();
  68. }
  70. //creation du deuxième processus general - equipe 2
  71. pg2=fork();
  73. if (pg2==0) {
  75. // creation pipe a partager entre pg2 et ses 5 sous processus
  76. // signale erreur si pb à la création d'un pipe
  77. if(pipe(pip2) == -1)
  78. {
  79.  perror("Erreur à la création du tube de communication 3." );
  80.  exit(-1);
  81. }
  82. // création des 5 sous processus - equipe 2
  83. // et appelle les fonctions selon type de processus
  84. int nb = 0;
  85. pid_t pid;
  88. do
  89. {
  90.    pid = fork ();
  91.    if(pid==0){
  92.        fils2();}
  93.    nb++;
  94. } while (nb < 5);
  96. pere2();
  98. }
  100. // compteur de points au niveau du processus grand-père :
  101. // statut : exit(0) => 0 en cas de mort ou d'échec, exit(1) => 1 en cas de reussite
  102. int total_equipe1;
  103. int total_equipe2;
  104. w11 = wait(&r11);
  105. r11 = WEXITSTATUS (r11);
  106. w12 = wait(&r12);
  107. r12 = WEXITSTATUS (r12);
  108. w13 = wait(&r13);
  109. r13 = WEXITSTATUS (r13);
  110. w14 = wait(&r14);
  111. r14 = WEXITSTATUS (r14);
  112. w15 = wait(&r15);
  113. r15 = WEXITSTATUS (r15);
  114. total_equipe1 = r11+r12+r13+r14+r15;
  115. w21 = wait(&r21);
  116. r21 = WEXITSTATUS (r21);
  117. w22 = wait(&r22);
  118. r22 = WEXITSTATUS (r22);
  119. w23 = wait(&r23);
  120. r23 = WEXITSTATUS (r23);
  121. w24 = wait(&r24);
  122. r24 = WEXITSTATUS (r24);
  123. w25 = wait(&r25);
  124. r25 = WEXITSTATUS (r25);
  125. total_equipe2 = r21+r22+r23+r24+r25;
  126. if (total_equipe1 > total_equipe2)
  127. {
  128. printf("l'equipe 1 gagne avec %d points contre %d points pour l'équipe 2", total_equipe1, total_equipe2);
  129. }
  130. else {
  132. if (total_equipe1 < total_equipe2)
  133. {
  134. printf("l'equipe 2 gagne avec %d points contre %d points pour l'équipe 1", total_equipe2, total_equipe1);
  135. }
  136. else {
  137. printf("les deux équipes dont à égalité avec %d points", total_equipe2);
  138. }
  139. }
  140. return (0);
  141. }// fin main
  143. // equipe 1
  144. void pere1(){
  146. // mise en place du timing
  147. alarm(20);
  148. while(20) {
  149. // sélection des fichiers
  150. rand_a_b(min, max);
  151. // ecriture et transmission des n° de fichiers via un pipe
  152. close(pip1[0]);
  153. printf("[Père :]Ecriture dans le tube de communication 1.\n" );
  154. write(pip1[1],  &num_fichier, sizeof(int));
  155. //EOF est envoyé aux processus lisant les données écrites dans le tube
  156. close(pip1[1]);
  157. wait(NULL);
  158. }
  159. }
  161. void fils1(){
  162. // verifie si il a recut un signal SIG_QUIT
  163. signal(SIGQUIT, verif);
  164. if (sig==1) exit(0);
  165. //lit le n° de fichier  
  166. close(pip1[1]);
  167. printf("[Fils :]Attente de lecture\n" );
  168. read(pip1[0], &num_fichier, sizeof(int));
  169. printf("[Fils :]Contenu de la lecture : %s\n",&num_fichier);
  170. close(pip1[0]);
  171. exit(1);
  172. }
  175. // equipe 2
  176. void pere2(){
  178. // mise en place du timing
  179. alarm(20);
  180. while(20) {
  182. // sélection des fichiers
  183. rand_a_b(min, max);
  184. // ecriture et transmission des n° de fichiers via un pipe
  185. close(pip2[0]);
  186. printf("[Père :]Ecriture dans le tube de communication 2.\n" );
  187. write(pip2[1],  &num_fichier, sizeof(int));
  188. //EOF est envoyé aux processus lisant les données écrites dans le tube
  189. close(pip2[1]);
  190. wait(NULL);
  191. }
  192. }
  194. void fils2(){
  195. // verifie si il a recut un signal SIG_QUIT
  196. signal(SIGQUIT, verif);
  197. if (sig==1) exit(0);
  198. //lit le n° de fichier  
  199. close(pip2[1]);
  200. printf("[Fils :]Attente de lecture\n" );
  201. read(pip2[0], &num_fichier, sizeof(int));
  202. printf("[Fils :]Contenu de la lecture : %s\n",&num_fichier);
  203. close(pip2[0]);
  204. exit(1);
  205. }
  208. // utilitaires communs  
  209. void verif(int num_sig) {
  210. if (num_sig==3) {
  211.  printf("je suis le processus %d et je suis mort", getpid());
  212.  sig=1;
  213.  exit(0);
  214.   }
  215. // réarme pour qu'unix ne repositionne pas le traitement par défaut
  216. signal(num_sig, verif);
  217. }
  220. int rand_a_b(int min, int max){
  221. num_fichier = rand()%(max-min)+min;
  222. printf("n° de fichier à conquérir ", num_fichier );
  223. return (num_fichier);
  225. }

n°2079183
shaoyin
Posté le 30-05-2011 à 16:45:00  profilanswer
 

Sauf erreur de ma part, la deuxième équipe est créée une fois que la fonction "pere1" est terminée, ce qui n'est sûrement pas ce que tu souhaites ?
 
Si tu regardes de près les "pères" des deux équipes doivent faire exactement la même chose, c'est à dire créer 5 fils puis appeler la fonction pereX(). Donc je te suggère de mettre ce code dans une fonction ("foo", par exemple).
Ensuite, dans ton main, tu appelles deux fois fork() pour créer tes deux pères. Après chaque appel, tu invoques ta fonction "foo" si tu es dans le processus fils.
 
Ainsi, ton programme crée les deux pères, et devient libre de faire autre chose, comme compter les points par exemple !

n°2079506
404 Not Fo​und
Posté le 31-05-2011 à 14:24:46  profilanswer
 

man fork
 
De rien [:zoubidawa]

n°2079812
effa
Posté le 01-06-2011 à 13:03:06  profilanswer
 

Bonjour,  
J'ai amélioré les choses (j'espere) grace à vous.  
j'aimerais suivre tes conseils shaoyin, mais je ne vois pas comment faire dans la mesure, ou d'apres moi il me faut deux pipes, et que ces deux pipes doivent etre declarees en dehors du main pour une question de portée, non ?
du coup, je suis obligée de faire deux fonctions : pere1 et pere2 et fils1 et fils2
non ????
 
Soyez indulgents, je debute, je stresse et j'ai mon exam qui arrive  :cry:  
 
 

Code :
  1. #include <stdio.h>
  2. #include <sys/types.h>
  3. #include <unistd.h>
  4. #include <stdlib.h>
  5. #include <stddef.h>
  6. #include <sys/wait.h>
  7. #include <sys/msg.h>
  8. #include <sys/sem.h>
  9. #include <signal.h>
  10. #include <string.h>
  11. #include <sys/file.h>
  13. void pere1();
  14. void pere2();
  15. void fils1();
  16. void fils2();
  17. int verif();
  18. int rand_a_b();
  20. //variables des tubes en lecture et en ecriture - 1 pour chaque equipe
  21. int pip1[2], pip2[2];
  22. char buff[4];
  24. // variables pour la sélection aléatoire des fichiers :
  25. int num_fichier=0;
  26. int min = 0000;
  27. int max = 9999;
  29. FILE *f= NULL;
  31. int main()
  32. {
  34. // les processus (pg1 sous processus pa1.1 a 5 et processus pg2 avec sous processus pa2.1 a 5)
  35. pid_t pg1,pg2;
  37. // variables pour récupérer nb de points
  38. int total_equipe1=0;
  39. int total_equipe2=0;
  42. // creation du premier processus general - equipe 1
  43. pg1=fork();
  46. if (pg1==0) {
  48. // creation pipe a partager entre pg1 et ses 5 sous processus
  49. // signale erreur si pb à la création d'un pipe
  50. if(pipe(pip1) == -1)
  51. {
  52.  perror("Erreur à la création du tube de communication 1." );
  53.  exit(-1);
  54. }
  56. // création des 5 sous processus - equipe 1
  57. // et appelle les fonctions selon type de processus
  58. int nb = 0;
  59. pid_t pid;
  61. do
  62. {
  63.    pid = fork ();
  64.    if(pid==0){
  65.        fils1();}
  66.    nb++;
  67. } while (nb < 5);
  69. pere1();
  71. // compteur de points equipe 1
  72. // statut : exit(0) => 0 en cas de mort ou d'échec, exit(1) => 1 en cas de reussite
  73. int tot1;
  74. while(wait(&tot1) != -1){
  75. total_equipe1 += WEXITSTATUS(tot1);
  76. }
  78. }
  80. //creation du deuxième processus general - equipe 2
  81. pg2=fork();
  83. if (pg2==0) {
  85. // creation pipe a partager entre pg2 et ses 5 sous processus
  86. // signale erreur si pb à la création d'un pipe
  87. if(pipe(pip2) == -1)
  88. {
  89.  perror("Erreur à la création du tube de communication 2." );
  90.  exit(-1);
  91. }
  92. // création des 5 sous processus - equipe 2
  93. // et appelle les fonctions selon type de processus
  94. int nb = 0;
  95. pid_t pid;
  98. do
  99. {
  100.    pid = fork ();
  101.    if(pid==0){
  102.        fils2();}
  103.    nb++;
  104. } while (nb < 5);
  106. pere2();
  108. // compteur de points equipe 2
  109. // statut : exit(0) => 0 en cas de mort ou d'échec, exit(res) => valeur de 'res' en cas de reussite
  110. int tot2;
  111. while(wait(&tot2) != -1){
  112. total_equipe2 += WEXITSTATUS(tot2);
  113. }
  114. }
  116. // qui a gagné ?
  117. if (total_equipe1 > total_equipe2)
  118. {
  119. printf("l'equipe 1 gagne avec %d points contre %d points pour l'équipe 2", total_equipe1, total_equipe2);
  120. }
  121. else {
  123. if (total_equipe1 < total_equipe2)
  124. {
  125. printf("l'equipe 2 gagne avec %d points contre %d points pour l'équipe 1", total_equipe2, total_equipe1);
  126. }
  127. else {
  128. printf("les deux équipes dont à égalité avec %d points", total_equipe2);
  129. }
  130. }
  131. return (0);
  132. }// fin main
  134. // equipe 1
  135. void pere1(){
  137. // mise en place du timing
  138. alarm(20);
  139. while(1) {
  140. // sélection des fichiers
  141. rand_a_b(min, max);
  142. // ecriture et transmission des n° de fichiers via un pipe
  143. close(pip1[0]);
  144. printf("[Père :]Ecriture dans le tube de communication 1.\n" );
  145. write(pip1[1],  &num_fichier, sizeof(int));
  146. //EOF est envoyé aux processus lisant les données écrites dans le tube
  147. close(pip1[1]);
  148. }
  149. }
  151. void fils1(){
  152. // initialisation de la variable permettant d'incrémenter le compteur avec le nombre de points gagnés
  153. int res = 0;
  154. // initialisation de la variable signal  
  155. int sig =0;
  156. // a répéter tant que le pipe n'est pas vide et tant que la sortie n'est pas explicitement demandée  
  157. do {
  158. // verifie si il a recut un signal SIG_QUIT
  159. signal(SIGQUIT, verif);
  160. if (sig==1) exit(0);
  161. //lit le n° de fichier  
  162. close(pip1[1]);
  163. printf("[Fils :]Attente de lecture\n" );
  164. read(pip1[0], buff, 4);
  165. printf("[Fils :]Contenu de la lecture : %s\n",buff);
  166. close(pip1[0]);
  167. // transforme le int num_fichier en string et crée le nom de fichier  
  168. char s[10];
  169. sprintf(s,"F%d.bin",buff);
  170. // ouverture du ficher en lecture / ecriture binaire / à la fin
  171. f= fopen(s,ab+);
  172. // verrou exclusif et non bloquant sur le fichier  
  173. int l;
  174. l = flock(f, LOCK_EX | LOCK_NB);
  175. //si l=-1 alors, le fichier est deja utilisé, mise en attente et nouvelle tentative :
  176. if (l==-1) {
  177. do {
  178. sleep(5);
  179. l = flock(f, LOCK_EX | LOCK_NB);} while (l==-1);
  181. // pid et ppid :
  182. pid_t a = getpid();
  183. pid_t b = getppid();
  184. int c;
  185. int p;
  186. // ecriture du n° d'équipe (ppid) et du pid
  187. fwrite(&b, sizeof(int), 1, f);
  188. fwrite(&a, sizeof(int), 1, f);
  190. // on remonte de deux infos pour lire le ppid précédent inscrit - 1 info = 4 octets
  191. do
  192. { fseek (f, -16 , SEEK_CUR);
  193. // lecture du ppid  
  194. fread(&c, sizeof(c), 1, f);
  195. // comparaison des deux ppid  
  196. // si ils sont différents, on lit le pid, on envoie le signal au processus concerné  
  197. if (c!=b) {
  199. fread (&p, sizeof(p), 1, f);
  200. kill (p, SIG_QUIT)
  201. }
  202. // et on remonte de deux infos tant que l'on trouve un ppid différent
  203. } while (c!=b);
  205. // sinon, on ferme le fichier
  207. // fermeture du fichier
  208. fclose(f);
  209. // on délock  
  210. flock (f, LOCK_UN);
  211. res++;
  212. } while (read(pip1[0], buff, 4)>0;
  214. exit(res);
  215. }
  218. // equipe 2
  219. void pere2(){
  221. // mise en place du timing
  222. alarm(20);
  223. while(1) {
  225. // sélection des fichiers
  226. rand_a_b(min, max);
  227. // ecriture et transmission des n° de fichiers via un pipe
  228. close(pip2[0]);
  229. printf("[Père :]Ecriture dans le tube de communication 2.\n" );
  230. write(pip2[1],  &num_fichier, sizeof(int));
  231. //EOF est envoyé aux processus lisant les données écrites dans le tube
  232. close(pip2[1]);
  233. }
  234. }
  236. void fils2(){
  237. // initialisation de la variable permettant d'incrémenter le compteur avec le nombre de points gagnés
  238. int res = 0;
  239. // initialisation de la variable signal  
  240. int sig =0;
  241. // a répéter tant que le pipe n'est pas vide et tant que la sortie n'est pas explicitement demandée  
  242. do {
  243. // verifie si il a recut un signal SIG_QUIT
  244. signal(SIGQUIT, verif);
  245. if (sig==1) exit(0);
  246. //lit le n° de fichier  
  247. close(pip2[1]);
  248. printf("[Fils :]Attente de lecture\n" );
  249. read(pip2[0], buff, 4);
  250. printf("[Fils :]Contenu de la lecture : %s\n",buff);
  251. close(pip2[0]);
  252. // transforme le int num_fichier en string et creation du nom de fichier  
  253. char s[10];
  254. sprintf(s,"F%d.bin",buff);
  255. // ouverture du ficher en lecture / ecriture binaire / à la fin
  256. f= fopen(s,ab+);
  258. // verrou exclusif et non bloquant sur le fichier  
  259. int l;
  260. l = flock(f, LOCK_EX | LOCK_NB);
  261. //si l=-1 alors, le fichier est deja utilisé, mise en attente et nouvelle tentative :
  262. if (l==-1) {
  263. do {
  264. sleep(5);
  265. l = flock(f, LOCK_EX | LOCK_NB);} while (l==-1);
  267. // pid et ppdi :
  268. pid_t a = getpid();
  269. pid_t b = getppid();
  270. int c;
  271. // ecriture du n° d'équipe (ppid) et du pid
  272. fwrite(&b, sizeof(int), 1, f);
  273. fwrite(&a, sizeof(int), 1, f);
  274. // on remonte de deux infos pour lire le ppid précédent inscrit - 1 info = 4 octets
  275. do
  276. { fseek (f, -16 , SEEK_CUR);
  277. // lecture du ppid  
  278. fread(&c, sizeof(c), 1, f);
  279. // comparaison des deux ppid  
  280. // si ils sont différents, on lit le pid, on envoie le signal au processus concerné  
  281. if (c!=b) {
  283. fread (&p, sizeof(p), 1, f);
  284. kill (p, SIG_QUIT)
  285. }
  286. // et on remonte de deux infos tant que l'on trouve un ppid différent
  287. } while (c!=b);
  289. // sinon, on ferme le fichier
  290. // fermeture du fichier
  291. fclose(f);
  292. // on délock  
  293. flock (f, LOCK_UN);
  294. res++;
  295. } while (read(pip1[0], buff, 4)>0;
  297. exit(res);
  298. }
  302. // utilitaires communs  
  303. int verif(int num_sig) {
  304. if (num_sig==3) {
  305.  printf("je suis le processus %d et je suis mort", getpid());
  306.  sig=1;
  307.  return sig;
  308.   }
  309. // réarme pour qu'unix ne repositionne pas le traitement par défaut
  310. signal(num_sig, verif);
  311. }
  314. int rand_a_b(int min, int max){
  315. num_fichier = rand()%(max-min)+min;
  316. printf("n° de fichier à conquérir ", num_fichier );
  317. return (num_fichier);
  319. }


Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  C

  C, linux et les pipes

 

Sujets relatifs
[C# .NET] Crash d'une DataGridViewcours C++ concis ?
[C] Interpreteur de commandes - MultipipesProgrammer une communication via liaison RS232 en C
[RESOLU] linux bash caseerreur de syntaxe, probleme langage C
Buffer / Buffer overflow en C et en Java[C/C++/C#] Aspirateur de sites
Problème avec un alphabeta en C pour othello[Objective-C] Création d'image reçue via socket
Plus de sujets relatifs à : C, linux et les pipes

Forum MesDiscussions.Net, Version 2010.2
(c) 2000-2011 Doctissimo
Page générée en 0.179 secondes

Copyright © 1997-2022 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR