dubbio programmazione concorrente C

[gian2991]

buongiorno,
ho un problema che non riesco a risolvere, in pratica devo realizzare un programma che chiede in ingresso quanti processi voglio simulare, e devo utilizzare i semafori per sincronizzarli, fino ad adesso però io sapevo a priori quanti erano i miei processi, e adesso che devo chiedere al'utente quanti ne voglio non ho idea di come fare.
avete qualche consiglio?

[Zoff]

usa

Codice: Seleziona tutto

int nprocessi;
printf("Inserire il numero di processi da simulare: ");
scanf("%d",&nprocessi);
printf("Verranno simulati %d processi.\n",nprocessi);

[minomic]

Forse intendeva che non sa come avviare i processi perché non ne conosce il numero... Se è così, allora basta un ciclo for, dentro al quale avvii i vari thread.

[Zoff]

La richiesta sembrava abbastanza chiara:

....... adesso che devo chiedere al'utente quanti ne voglio non ho idea di come fare.
avete qualche consiglio?

[minomic]

La richiesta sembrava abbastanza chiara:

....... adesso che devo chiedere al'utente quanti ne voglio non ho idea di come fare.
avete qualche consiglio?

Non voglio mettere in dubbio la tua interpretazione, però ammetterai una cosa: se uno dice che "fino ad adesso sapevo a priori quanti erano i miei processi", ecc. significa che ha già fatto un po' di programmazione concorrente. Quindi non mi sembra plausibile che non sappia utilizzare scanf e printf.

Invece io ho interpretato la domanda così: "adesso che devo chiedere all'utente quanti ne voglio, non ho idea di come gestire i vari processi", riferito però alla parte di programmazione concorrente, e non alla semplice richiesta del numero.

[gian2991]

scusate se sono stato poco chiaro, riesco a prendere in ingresso il numero di processi, il problema è l'esecuzione, un mio compagno mi ha suggerito cosi

Codice: Seleziona tutto

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/types.h>
#include <string.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <errno.h>

#ifndef KEY
#define KEY 2 /*dimensione per il buffer di lettura/scrittura*/
#endif

int semid;

int charToInt(char u){
	int a=u-'0';
	return a;
}

int numeroNodi(){
	char buffer[50];
    	int nodesNumber;
    	memset(buffer,'\0',50);                // Azzera la memoria in modo che non ci siano problemi quando si va a leggere del buffer
    	write(1,"inserisci i nodi da simulare: ",sizeof(char)*29);
    	read(0,buffer,50);
    	nodesNumber=atoi(buffer);
    	return nodesNumber;
}

void wait_sem(int id_sem, int numsem){
	struct sembuf sem_buf;
	sem_buf.sem_num=numsem;
	sem_buf.sem_flg=0;
	sem_buf.sem_op=-1;
	semop(id_sem,&sem_buf,1); //semaforo rosso
}

void signal_sem(int id_sem,int numsem){
	struct sembuf sem_buf;
	sem_buf.sem_num=numsem;
	sem_buf.sem_flg=0;
	sem_buf.sem_op=1;
	semop(id_sem,&sem_buf,1); //semaforo verde
}

union semun{ 
 	int val;                  	/* value for SETVAL */       
	struct semid_ds *buf;     	/* buffer for IPC_STAT, IPC_SET */ 
      	unsigned short *array;    	/* array for GETALL, SETALL */ 
                                 	/* Linux specific part: */       
	struct seminfo *__buf;    	/* buffer for IPC_INFO */ 
};

void nodi(int n){
	
}

int main(int argc, char *argv[]){
	//struct sembuf operazioni;
	int nodesNumber=numeroNodi();
	int fd_in=-1,cont=0;  
	pid_t nodi[nodesNumber];
	int a,i,j,nread,re;
	pid_t pid;
	ssize_t red;
	key_t key_MEM;
	key_t key_mem;
	key_t key_sem;
	key_t key_sem2;
	int *mem;
  	int *memoria;
	int *media;
	char *c;
	int curr_cont = 0;
	char filename[9];
   	char operazioni[nodesNumber][128];
	memset(operazioni,'-',128*nodesNumber);

	key_sem = ftok("elaborato2.c", 'a');
	key_sem2 = ftok("elaborato2.c", 'c');
    	key_mem = ftok("elaborato2.c", 'b');

	/////////////////////////////////////////// LETTURA DA FILE ////////////////////////////////////////////////////
	
	for(i=0;i<nodesNumber;i++){
            sprintf(filename,"file%d.txt",i+1);
            if((fd_in=open(filename,O_RDONLY,0644))==-1)
         	write(2,"OPEN: -1",sizeof(char)*8);
            nread=read(fd_in,operazioni[i],128);
            close(fd_in);
      	}
	for(j=0;j<nodesNumber;j++){	
		for(i=0;i<nread+1;i++){
			if(operazioni[j][i]=='\n')
				operazioni[j][i]='\0';
	      	}
	}
		
      	for(i=0;i<nread+1;i++){
            printf("operazioni[%d] =%c\n",i,operazioni[0][i]);
      	}
		
	/////////////////////////////////////////// MEMORIA CONDIVISA //////////////////////////////////////////////////

	int size_mem=((sizeof(int)*2)*2)*nodesNumber;
	int shmid=shmget(key_mem,size_mem,IPC_CREAT | 0666);
  	if(shmid==-1){
	    	write(2,"SHMGET: -1",sizeof(char)*10);
	    	exit(1);
  	}
  	mem=(int*)(shmat(shmid,0,0));
  	if(mem==(void*)-1){
    		write(2,"SHMAT: -1",sizeof(char)*9);
    		exit(1);
  	}
  	memoria=mem;
  	media=mem;

	for(i = 0; i < size_mem; i++){
		printf("MEMORIA[%d] = %d\n",i,memoria[i]);
	}

	////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	
	
	////////////////////////////////////////// SEMAFORI ////////////////////////////////////////////////////////////
	struct sembuf oper;
  	int idSem=semget(key_sem,nodesNumber,IPC_CREAT | 0666);	// creo i semafori
	if(idSem==-1){
    		write(2,"SEMGET: -1",sizeof(char)*10);
    		exit(1);
  	}
	for(i=0;i<nodesNumber;i++){
		if((semctl(idSem,i,SETVAL,0))==-1){
			write(2,"SEMCTL: -1",sizeof(char)*10);
    			exit(1);
		}
	}
	int idSemEnd=semget(key_sem2,1,IPC_CREAT | 0666);
	if(idSemEnd==-1){
		write(2,"SEMGET: -1",sizeof(char)*10);
    		exit(1);
	}
	if((semctl(idSemEnd,0,SETVAL,0))==-1){
			write(2,"SEMCTL: -1",sizeof(char)*10);
    			exit(1);
	}
	for(i=0;i<nodesNumber;i++){
		printf("semaforo[%i]: %i\n",i,semctl(idSem,i,GETVAL));
	}
	printf("semaforoEnd %i\n",semctl(idSemEnd,0,GETVAL));

	////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	/////////////////////////////////////////// CREAZIONE PROCESSI /////////////////////////////////////////////////	
	
	for(i=0;i<nodesNumber;i++){
		pid=fork();
		if(pid==0)
	   	{
			// esecuzione operazioni in comune per ogni processo, al termine ogni processo incrementa un semaforo (idSemEnd)
	     	 	exit(0);
	   	}
		else if(pid>0)
	   	{
			nodi[i]=pid;
	   	}
	   	else
	   	{   
	      		fprintf(stderr, "Errore nel fork");
	      		exit(1);
	   	}
	}
	for(i=0;i<nodesNumber;i++){
		printf("\nprocesso %d\n",nodi[i]);
	}

	// esecuzione del canale che controlla che il semaforo sia stato incrementato da tutti e allora termina il programma

	////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	return 0;
}

potrebbe andare come cosa? se no mi ha accennato di una system call exec nella parte dell'if con pid==0, ci sono diverse variabili e metodi che non uso, dovrò fare un pò di pulizia prima di consegnarlo