C Trabalho sobre processos em C

Edson Conte · 3 de maio de 2020

Tenho que fazer um trabalho para a cadeira de sistemas operacionais na faculdade e estou passando algumas dificuldades com a sincronização e comunicação dos processos e como fazer eles se comportarem da maneira que preciso, professor passou uma imagem com as especificações que estou botando como anexo aqui junto com o código que tenho até o momento, as coisas essências são o trabalho ser em C, utilizar processos pesados e implementar forks, pipes e exec.

Se os magos da TI conseguirem resolver essa ficaria muito grato!

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
int main() {
 
    int file_pipes[2];
    pid_t fork_result;
    struct Produtos {
        int productor;
        int time;
        char type[20];
        char quality[20];
    };
 
    if(pipe(file_pipes) == 0) {
       
        fork_result = fork();
 
        if(fork_result > 0) {
            struct Produtos fruta = {1, 2, "Maça", "Boa"};
            write(file_pipes[1], &fruta, sizeof(fruta));
           
            if(fork() == 0) {
                struct Produtos fruta;
                while(1) {
                    read(file_pipes[0], &fruta, BUFSIZ);
                    printf("\nProdutor: %d\nTempo: %d\nTipo: %s\nQualidade: %s\n", fruta.productor, fruta.time, fruta.type, fruta.quality);
                }
            }
        }
        else if (fork_result == 0){
            struct Produtos fruta = {2, 1, "Banana", "Boa"};
            sleep(fruta.time);
            write(file_pipes[1], &fruta, sizeof(fruta));
 
            if(fork() == 0) {
                struct Produtos fruta = {3, 2, "Maça", "Ruim"};
                sleep(fruta.time);
                write(file_pipes[1], &fruta, sizeof(fruta));
            }
        }
   
    }
    return 0;
}

arfneto · 4 de maio de 2020

Você escreveu esse código? Isso roda?

Não pode usar threads? Seria mais portável e não dependeria de usar Unix/Linux...

De todo modo é um problema interessante. É o primeiro que vão fazer com isso? Não fez nada com pipes ou semáforos ou alguma estrutura de sincronismo? Vi que é o primeiro trabalho, mas não teve nada antes?

Seu programa está ainda um pouco longe de funcionar eu acho.

Edson Conte · 4 de maio de 2020

Sim, era apenas a parte inicial mesmo, vou atualizar com o que já tenho feito, pode apenas utilizar processos pesados, as estruturas de sincronismo ficam a critério do aluno e deve ser utilizado pipe para comunicação entre os processos.

Consegui fazer tudo, mas não do jeito que queria, fiz uma "arvore" de processos porque não estava conseguindo fazer com que eles executassem as partes de código que deveriam executar, e talvez não possa usar mais de 1 pipe pra realizar o sincronismo entre os processos consumidores e a esteira (já enviei essa duvida ao professor), mas não encontrei outra maneira de fazer isso.

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <sys/wait.h>

 
int main() {
 	
  	int file_pipesP[2];
    int file_pipesC1[2];
    int file_pipesC2[2];
	struct Produtos {
		int id;
      		int productor;
        	int time;
        	char type;
        	char quality;
	};
	
 
	if(pipe(file_pipesP) != 0) {  //Execução do Pipe
		perror("pipe");
		exit(EXIT_FAILURE);
	}
    if(pipe(file_pipesC1) != 0) {  //Execução do Pipe
		perror("pipe");
		exit(EXIT_FAILURE);
	}
    if(pipe(file_pipesC2) != 0) {  //Execução do Pipe
		perror("pipe");
		exit(EXIT_FAILURE);
	}
	
	int numProdutos = 3;
	int totalProdutos = numProdutos*4;	
	  	
	switch(fork()) {   //PRIMEIRO FORK
	case -1:
		perror("fork");
		exit(EXIT_FAILURE);
		break;
	case 0:
		switch(fork()) { //SEGUNDO FORK
			case -1:
				perror("fork");
				exit(EXIT_FAILURE);
				break;
			case 0:
				switch(fork()){ //TERCEIRO FORK
					case -1:
						perror("fork");
						exit(EXIT_FAILURE);
						break;
					case 0: // FILHO DO TERCEIRO FORK - PRODUTOR 1
						close(file_pipesP[0]);
						for(int i = 1; i <= numProdutos; i++){
							int productionTime = 4250000; // 4,2 segundos
							struct Produtos fruta = {i, 1 , productionTime/1000000, 'M', 'B'};
							usleep(productionTime);
							write(file_pipesP[1], &fruta, sizeof(fruta));
   						}
						break;
					default: //PAI DO TERCEIRO FORK	- PRODUTOR 2
						close(file_pipesP[0]);
						for(int i = 1; i <= numProdutos; i++){
							int productionTime = 2378000; // 2,3 segundos
							struct Produtos fruta2 = {i, 2, productionTime/1000000, 'M', 'R'};
							usleep(productionTime);
            						write(file_pipesP[1], &fruta2, sizeof(fruta2));
						}
						break;
				}	
				break;
			default:
				switch(fork()){ //QUARTO FORK
					case -1:
						perror("fork");
						exit(EXIT_FAILURE);
						break;
					case 0: // FILHO DO QUARTO FORK - PRODUTOR 3
						close(file_pipesP[0]);
						for(int i = 1; i <= numProdutos; i++){
							int productionTime = 2798700; //2,7 segundos
							struct Produtos fruta3 = {i, 3, productionTime/1000000, 'B', 'B'};
							usleep(productionTime);
							write(file_pipesP[1], &fruta3, sizeof(fruta3));
   						}
						break;
					default: //PAI DO QUARTO FORK	- PRODUTOR 4
						close(file_pipesP[0]);
						for(int i = 1; i <= numProdutos; i++){
							int productionTime = 1112300; //1,1 segundos
							struct Produtos fruta4 = {i, 4, productionTime/1000000, 'B', 'R'};
							usleep(productionTime);
	    						write(file_pipesP[1], &fruta4, sizeof(fruta4));
						}
						break;
				}	
				break;
		}
		break;
	default:
		switch(fork()){ // QUINTO FORK
			case -1:
				perror("fork");
				exit(EXIT_FAILURE);
				break;
			case 0: 
				switch(fork()){ // SEXTO FORK
					case -1: 
						perror("fork");
						exit(EXIT_FAILURE);
						break;
					case 0: // FILHO DO SEXTO FORK - CONSUMIDOR 1
                        close(file_pipesC1[1]);
                        struct Produtos frutas1[6];

                            for(int i = 0; i < 6; i++) {
                                read(file_pipesC1[0], &frutas1[i], BUFSIZ);
                                printf("Produto de ID %d e produtor %d consumido!\n", frutas1[i].id, frutas1[i].productor);
                            } 

                            int bananas = 0;
                            int macas = 0;
                            for(int i = 0; i < 6; i++) {
                                if(frutas1[i].type == 'B') {
                                    bananas++;
                                } else {
                                    macas++;
                                }
                            }

                            printf("\n-------------- Produtos de boa qualidade --------------\n");
                            printf("Bananas: %d unidades\n", bananas);
                            printf("Maças: %d unidades\n", macas);
                            printf("-------------------------------------------------------\n");

						break;
					default: // PAI DO SEXTO FORK - CONSUMIDOR 2 
                        close(file_pipesC2[1]);
                        struct Produtos frutas2[6];

                            for(int i = 0; i < 6; i++) {
                                read(file_pipesC2[0], &frutas2[i], BUFSIZ);
                                printf("Produto de ID %d e produtor %d consumido!\n", frutas2[i].id, frutas2[i].productor);
                            } 

                            int bananas1 = 0;
                            int macas1 = 0;
                            for(int i = 0; i < 6; i++) {
                                if(frutas2[i].type == 'B') {
                                    bananas1++;
                                } else {
                                    macas1++;
                                }
                            }

                            printf("\n-------------- Produtos de má qualidade --------------\n");
                            printf("Bananas: %d unidades\n", bananas1);
                            printf("Maças: %d unidades\n", macas1);
                            printf("------------------------------------------------------\n");
						break;
				}
				break;
			default: // ESTEIRA
				close(file_pipesP[1]);
				struct Produtos frutaEsteira;

					for(int i = 0; i < totalProdutos; i++){
						read(file_pipesP[0], &frutaEsteira, BUFSIZ);
						printf("Produto de ID %d e produtor %d recebido!\n", frutaEsteira.id, frutaEsteira.productor);

                        if(frutaEsteira.quality == 'B') {
                            write(file_pipesC1[1], &frutaEsteira, sizeof(frutaEsteira));
                        } else {
                            write(file_pipesC2[1], &frutaEsteira, sizeof(frutaEsteira));
                        }
					}
				break;
		}
		break;
	}
}