Esempio n. 1
0
int main(){

	int shmflag=PROT|IPC_CREAT; 
	int shmid; // ID du segment de mémoire partagée
	shmid = shmget(IPC_PRIVATE,5*sizeof(int),shmflag); // Création d'un segment de mémoire partagée de taille 5 entiers
	
	if(shmid == -1) perror("Création échouée");
	else printf("Segment mémoire créé.\n");

	int *idx_w; // Index d'écriture
	int *idx_r; // Index de lecture
	idx_w=shmat(shmid,0,shmflag); // On attache le segment mémoire à l'index d'écriture
	idx_r=shmat(shmid,0,shmflag); // On attache le segment mémoire à l'index de lecture

	pid_t fils;

	// Variables du fils
	int i, j=0;
	// Variables du père
	int k, l=0;

	// Création des sémaphores
	init_semaphore();
	// Initialisation des sémaphores
	val_sem(sem_vide,5); // Au début, il y a 5 emplacements libres dans le buffer 
	val_sem(sem_plein,0); // Au début, il n'y a pas de message en attente

	switch (fils=fork()){
		case -1:
			perror("Probleme fork");
			break;	
		case 0: // Fils	- PRODUCTEUR
			for (i = 1; i < 51; i++) // Pour afficher 50 valeurs 
			{
				P(sem_vide); // On applique P au sémaphore comptant le nombre d'emplacement libres
				idx_w[j]=i;
				printf("Produit : %d\n", idx_w[j]);
				j++;
				j = j%5; // Le buffer est circulaire de taille 5, on accède uniquement aux cases 0 1 2 3 et 4
				V(sem_plein); // On applique V au sémaphore comptant le nombre de messages en attente
			}
			shmdt(idx_w); // Détachement du segment mémoire
			break; 
		default: // Père - CONSOMMATEUR
			for (k = 1; k < 51; k++)
			{
				P(sem_plein); // On applique P au sémaphore comptant le nombre de messages en attente
				printf("Consommé : %d\n", idx_r[l]);	
				l++;
				l = l%5; // Le buffer est circulaire de taille 5, on accède uniquement aux cases 0 1 2 3 et 4
				V(sem_vide); // On applique V au sémaphore comptant le nombre d'emplacement libres
			}
			wait(0); // On attend la fin du fils
			shmdt(idx_r); // Détachement du segment mémoire
			shmctl(shmid, IPC_RMID,0); // Destruction du segment mémoire
			printf("Segment mémoire supprimé.\n");
			detruire_semaphore();
	}
	return 0;
}
Esempio n. 2
0
tampon_t * detruire_tampon(tampon_t * tampon)
{
    detruire_semaphore(tampon->semaphore);
    free(tampon->valeurs);
    free(tampon);
    return NULL;
}
Esempio n. 3
0
File: sem1.c Progetto: Faengsel/sr02
int main(){
	init_semaphore();
	val_sem(1,2);
	P(2);
	sleep(5);
	V(2);
	detruire_semaphore();

	return 0;
}
Esempio n. 4
0
int main() {
    int shmid;
    int* ptr;
    int i = 0, A=0;

    /*
    init_semaphore();
    printf("Initialisation du 2ème sémaphore à 1\n");
    val_sem(2,1);
    printf("P(2)\n");
    P(2);
    sleep(20);
    printf("V(2)\n");
    V(2);
    detruire_semaphore();
    */

    // Creation et attachement d'un segment mémoire
    // On crée le segment en utilisant IPC_PRIVATE car le segment de mémoire est partagé entre un processus père et un processus fils
    shmid = shmget(IPC_PRIVATE, 100, IPC_CREAT | 0600 );

    //on  attache ce segment à l'espace virtuel du processus
    ptr = shmat(shmid, 0, 0);

    // Création du sémaphore
    init_semaphore();

    // Initialisation du premier sémaphore à 1 (mutex)
    val_sem(1,1);

    // On initialise l'entier E à 0 en mémoire partagée
    ptr[0] = 0;

    // Création du processus fils
    pid_t pidChild = fork();
    if (pidChild < 0) {
        // fork failed.
        perror("Fork of pidChild failed.");
        return -1;
    }
    else if (pidChild == 0) {
        // Processus fils
        for(i = 0 ; i<100 ; i++) {
            P(1);
            A = ptr[0];
            //attendre entre 20 et 100ms (Utilisez les fonctions usleep(3) et rand(3V))
            usleep(rand_a_b(20, 100));
            A++;
            ptr[0] = A;
            V(1);
            usleep(rand_a_b(20, 100));
        }
        shmdt(ptr);
    }
    else {
        //processus père
        for(i = 0 ; i<100 ; i++) {
            P(1);
            A = ptr[0];
            //attendre entre 20 et 100ms (Utilisez les fonctions usleep(3) et rand(3V))
            usleep(rand_a_b(20, 100));
            A++;
            ptr[0] = A;
            V(1);
            usleep(rand_a_b(20, 100));
            printf("%dème valeur de E : %d\n", i, ptr[0]);
        }

        //On attend la fin du processus fils
        if (waitpid(pidChild, 0, 0) == -1) {
            // Si echec du waitpid, envoie d'un signal d'interruption
            kill(pidChild, SIGKILL);
            perror("Wait child failed");
            return -1;
        }
        printf("valeur finale de E : %d\n", ptr[0]);
        detruire_semaphore();
        // on effectue le détachement du segment
        shmdt(ptr);
        // Suppression du segment de mémoire partagée
        shmctl(shmid, IPC_RMID, 0);
    }

    return 0;
}