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;
}
tampon_t * detruire_tampon(tampon_t * tampon)
{
detruire_semaphore(tampon->semaphore);
free(tampon->valeurs);
free(tampon);
return NULL;
}
int main(){
init_semaphore();
val_sem(1,2);
P(2);
sleep(5);
V(2);
detruire_semaphore();
return 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;
}