Bonjour à tous,

Voila j'ai un projet en C qui consiste à réaliser une simulation des processus dans un environnement de temps partagé sur une machine mono-processeur.

En gros pour être plus claire j'ai alpha processus qui peuvent lire dans le tampon en même temps mais j'ai un seul processus qui peut écrire dedans. 

A la fin je dois avoir 2 chaînes de processus : le premier est l'ordre d'entré des processus et le deuxième l'ordre de sortie.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <semaphore.h>
#include <time.h>
#include <math.h>
#define TAILLE 20 // Taille du tampon
#define ALPHA 10 // ALPHA (<TAILLE)
#define PROC 20 // Nbr total de processus(>ALPHA)

sem_t ecriture;
sem_t lecture;
int id = 100;
int tab_enter[ALPHA]; //ordre d'entrer
int tab_exit[ALPHA]; //ordre de sortie
int i_enter = 0; //index entrée
int i_exit = 0; //index sortie
int proc_en_cour = 0; // nbr de processus en cours simultanement

void init_tamp(int* tampon){
    for(int i=0;i<TAILLE;i++){
    	srand(time(NULL));
		tampon[i]=rand()%TAILLE;
    }
}

void proP(int* tampon){

    int nom = id++;
    sem_wait(&lecture);
    proc_en_cour++;
    //seulement alpha processus peuvent entrer à la fois
    tab_enter[i_enter] = nom;
    i_enter++;
    srand(time(NULL)+nom);
    int num = rand()%TAILLE;

    unsigned long long moyQuad=0;

    for(int i = 0; i < num; i++){
        moyQuad += tampon[i] * tampon[i];
    }

    moyQuad /= num;

    //zone critique ----> ecriture de 5
    sem_wait(&ecriture);
    tampon[TAILLE - num + 1] = moyQuad;
    sem_post(&ecriture);
    //fin
    tab_exit[i_exit] = nom;
    i_exit++;
    if(proc_en_cour==ALPHA){ // une fois les ALPHA processus executé on libere le semaphone Lecture
        proc_en_cour = 0;
        i_exit=0;
        i_enter=0;
    	printf("----------------entrée-----------------\n");
    	for(int i=0; i<ALPHA; i++){
    		printf("%i\n",tab_enter[i]);
    	}
    	printf("---------------sortie--------------\n");
    	for(int i=0; i<ALPHA; i++){
    		printf("%i\n",tab_exit[i]);
    	}
    	for(int i = 0; i<ALPHA; i++){ //initialisation des tableaux FIFO
            tab_enter[i]=0;
            tab_exit[i]=0;
        }

    	for(int i=0; i<ALPHA; i++){
    		sem_post(&lecture);
    	}

    }
}
void main()
{
	for(int i = 0; i<ALPHA; i++){ //initialisation des tableaux FIFO
        tab_enter[i]=0;
        tab_exit[i]=0;
    }
    unsigned long long tampon[TAILLE];

    sem_init(&ecriture, 0, 1);
    sem_init(&lecture, 0, ALPHA);

    pthread_t threadP;

    init_tamp(tampon);

    for(int i=0; i<PROC; i++){ // lance les n processus
        pthread_create(&threadP,NULL,proP,tampon);
        pthread_join(threadP, NULL);
    }
    return 0;
}

J'en suis arrivé à ce code mais j'ai deux problème que je n'arrive pas du tout à résoudre :

• Le premier est que, sans raison apparente et de manière totalement aléatoire, mon "programme" s’arrête en pleine exécution, sans erreur et retourne un valeur très éloigné de mon 0 attendu.
• La deuxième est que l'ordre de sortie et le même que l'ordre d'entré ce qui me parait très étrange car, étant multi threadé, je devrais avoir des un ordre de sortie totalement différent que celui d'entré.

J’espère que j'ai était assez clair et vous remercie d'avance des éventuelles solution que vous m'apporterais.