Linux, C e semafori: dove sbaglio??

[cn73]

Olevo provare a risolvere il calssico problema di IPC del Produttore e Consumatore con buffer limitato (nel mio caso 4 elementi)...
Ho scritto questo codice, ma non funziona Dove sbaglio?? E' tutta la sera che ci sbatto la testa!

#include<stdio.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<sys/sem.h>

#define ARRAY_LENGTH 2
#define BUF_DIM 4


main() {

	int f;
	int in=0,out=0;
	int empty,full;
	char nextp,nextc;
	struct sembuf sops[ARRAY_LENGTH];
	int semid;

	//char buffer[10];
	//char *pun;

	semid = semget(IPC_PRIVATE,ARRAY_LENGTH,0666); //4 semafori nel set, r/w x tutti!
	printf("prelevato set di semafori id = %d\n",semid);

	empty = semctl(semid,0,SETVAL,BUF_DIM);
	full = semctl(semid,1,SETVAL,0);

	printf("Valore iniziale dei semafori:\n");
	printf("EMPTY: %d\n",semctl(semid,0,GETVAL,0));
	printf("FULL: %d\n",semctl(semid,1,GETVAL,0));


	f = fork();
	if (f == -1)
	{
	fprintf(stderr,"fork fallita\n");
	exit(1);
	}

	else if (f !=0) { //P
                 
		while (1){
			//nextp = 'x';
			printf("\n(P) -- wait(empty) -- tento di decrementare il semaforo EMPTY  %d\n",semctl(semid,0,GETVAL,0));
			//wait(empty) se il valore del sem EMPTY è 0 nn mi fa andare avanti!!
			sops[0].sem_num = 0; /* operazione sul semaforo 1 */
			sops[0].sem_op = -1; /* decrementa il semaforo di 1 */
			sops[0].sem_flg = 0; /* che fare: wait se == 0 */

			empty = semop(semid,sops,1); //1: lunghezza dell'array sops

			printf("\n(P) ho decrementato il semaforo EMPTY: %d\n", semctl(semid,0,GETVAL,0));
			//buffer[in]= nextp;
			system("sleep 10"); //P + lento di C
			printf("\n(P) ho prodotto l'elemento %d\n", in);


			in = (in +1) % BUF_DIM;
			
			printf("\n(P) -- signal(empty) -- tento di incrementare il semaforo FULL  %d\n",semctl(semid,1,GETVAL,0));
			//signal(full) incremento FULL
			sops[1].sem_num = 1; /* operazione sul semaforo 2 */
			sops[1].sem_op = 1; /* incrementa semaforo 2*/
			sops[1].sem_flg = 0; /* che fare: ??*/
			full = semop(semid,sops,1);
			printf("\n(P) - ho incrementato il semaforo FULL: %d\n" , semctl(semid,1,GETVAL,0));



		}
		exit(0);
		//semctl(semid,IPC_RMID,0);
		//printf("(P) Rilasciato i sem, ora muoio... \n");


	}
	else { //C

		while (1){

			printf("\n(C) -- wait(full) -- tento di decrementare il semaforo FULL: %d\n",semctl(semid,1,GETVAL,0));
			//wait(full)
			sops[1].sem_num = 1; /* operazione sul semaforo 0 */
			sops[1].sem_op =-1; /* decrementa il semaforo di 1 */
			sops[1].sem_flg = 0; /* che fare: wait se semaforo = 0 */

			full = semop(semid,sops,1); //1: lunghezza dell'array sops
			printf("\n(C) ho decrementato il semaforo FULL: %d\n" , semctl(semid,1,GETVAL,0));
			//nextc=buffer[out];
			system("sleep 1");
			printf("\n(C) ho consumato l'elemento %d\n", out);
			out = (out +1) % BUF_DIM;

			printf("\n(C) -- signal(empty) --  tento di incrementare il semaforo EMPTY - signal(EMPTY) %d\n" , semctl(semid,0,GETVAL,0));
			//signal(empty)
			sops[0].sem_num = 0; /* operazione sul semaforo 0 */
			sops[0].sem_op = 1; /* incrementa il semaforo di 1 */
			sops[0].sem_flg = 0; /* che fare: ?? */
			empty = semop(semid,sops,1);
			printf("\n(C) -ho incrementato il semaforo EMPTY - signal(EMPTY) %d\n" , semctl(semid,0,GETVAL,0));

		}
		
	}

}

[ilsensine]

--- sem.c.org	2004-04-02 09:03:57.000000000 +0200
+++ sem.c	2004-04-02 09:03:31.000000000 +0200
@@ -62,7 +62,7 @@
                         sops[1].sem_num = 1; /* operazione sul semaforo 2 */
                         sops[1].sem_op = 1; /* incrementa semaforo 2*/
                         sops[1].sem_flg = 0; /* che fare: ??*/
-                        full = semop(semid,sops,1);
+                        full = semop(semid,sops+1,1);
                         printf("\n(P) - ho incrementato il semaforo FULL: %d\n" , semctl(semid,1,GETVAL,0));
 
 
@@ -84,7 +84,7 @@
                         sops[1].sem_op =-1; /* decrementa il semaforo di 1 */
                         sops[1].sem_flg = 0; /* che fare: wait se semaforo = 0 */
 
-                        full = semop(semid,sops,1); //1: lunghezza dell'array sops
+                        full = semop(semid,sops+1,1); //1: lunghezza dell'array sops
                         printf("\n(C) ho decrementato il semaforo FULL: %d\n" , semctl(semid,1,GETVAL,0));
                         //nextc=buffer[out];
                         system("sleep 1");

[cn73]

Per cortesia fammi capire...

intendi togliere per il semaforo FULL

- full = semop(semid,sops,1);

e sostituirlo con

+ full = semop(semid,sops+1,1); ??


Io avevo capito questo:

La chiamata semop() consente di specificare una lista (sops[]) di
(nsops) operazioni:
int semop ( int semid, struct sembuf *sops, unsigned nsops );

Un esempio di chiamata e':
semop ( sid, sops, 1);
la quale indica che si fa una operazione, la quale e' specificata
nella lista sops[].

quel parametro nsops pensavo fosse l'offset all'inerno dell'array a partrire da sops...

[ilsensine]

Originariamente inviato da cn73
Per cortesia fammi capire...

intendi togliere per il semaforo FULL

- full = semop(semid,sops,1);

e sostituirlo con

+ full = semop(semid,sops+1,1); ??


Io avevo capito questo:

Sì
man diff

quel parametro nsops pensavo fosse l'offset all'inerno dell'array a partrire da sops...

Puoi specificare in un array _più_ operazioni da compiere anche su _più_ semafori in maniera _atomica_.
Nel tuo caso compi una unica operazione su un unico semaforo alla volta, quindi potevi anche non usare un array.

[cn73]

full = semop(semid,sops+1,1);


sops +1 è l'indirizzo dell'elemento dell'array che contiene il semaforo sul quale voglio aplllicare l'operazione?

il terzo parametro (nops =1) che cavolo indica? Che voglio eseguire una sola operazione atomica su quel array di semafori?

[cn73]

Per non riscrivere sempre il codice dei semafori è corretto implementare due funzioni P e V in questo modo?

P(struct sembuf sems[ARRAY_LENGTH], int index, int semid){
		sems[index].sem_num = index; /* operazione sul semaforo 0 */
		sems[index].sem_op = -1; /* incrementa il semaforo di 1 */
		sems[index].sem_flg = 0; /* che fare: ?? */	
		
		return semop(semid,sems + index,1); 
}	

V(struct sembuf sems[ARRAY_LENGTH], int index, int semid){
		sems[index].sem_num = index; /* operazione sul semaforo 0 */
		sems[index].sem_op = +1; /* incrementa il semaforo di 1 */
		sems[index].sem_flg = 0; /* che fare: ?? */	
		
		return semop(semid,sems + index,1); 
}

[ilsensine]

Ti stai solo complicando la vita...

struct sembuf s;
s.sem_flg = 0;

s.sem_op = -1;
s.sem_num = 0;
semop(semid, &s, 1);

s.sem_op = 1;
s.sem_num = 1;
semop(semid, &s, 1);

[cn73]

Allora diciamo che un array di semafori è utile quando si devono eseguire operazioni unuitarie contemporaneamente su + semafori.Se devo eseguire una sola operazion alla volta su n semafori conviene definire 2 diversi semafori:


struct sembuf s1;
struct sembuf s2;

E' corretto?

[ilsensine]

Se le operazioni non vengono effettuate in contemporanea (ad es. da due thread) puoi anche usare una unica struct sembuf

[cn73]

Ho capito!


struct sembuf sops;

...
prelevo n semafori
semid = semget(IPC_PRIVATE,n,0666);

e poi uso P(i) e V(i) dove

P(int sem ){
		sops.sem_num = sem; /* operazione sul semaforo 0 */
		sops.sem_op = -1; /* incrementa il semaforo di 1 */
		sops.sem_flg = 0; /* che fare: ?? */	
		
		return semop(semid,sops,1); 
}	

V(int sem){
		sops.sem_num = sem; /* operazione sul semaforo 0 */
		sops.sem_op = +1; /* incrementa il semaforo di 1 */
		sops.sem_flg = 0; /* che fare: ?? */	
		
		return semop(semid,sops ,1); 
}