C-Programm_Semaphoren

[Lupus84]

Hallo zusammen,
ich habe mal wieder eine Aufgabe erhalten und komme damit nicht weiter und zwar gilt es folgende Aufgabenstellung zu bearbeiten:

Vor dem Zugang zu einem Rockkonzert findet in einer Sicherheitszone eine Sicherheitsprüfung der Besucher statt. In der Sicherheitszone dürfen sich immer nur maximal vier Besucher aufhalten.
Die sicherheitszone enthält einen Kontrollbereich mit einem Kratenkonrolleur und einem Personenkontrolleur, der die Person auf Wurfgegenstände abtastet. Im Kontrollbereich ist nur maximal ein Besucher erlaubt.
Der Kartenkontrolleur darf erst dann mit seiner Kontrolle beginnen, wenn ein Besucher den Kontrollbereich betreten hat. Erst nachdem der Kartenkontrolleur die Eintrittskarte vom Besucher erhalten hat, darf der Personenkontrolleur mit der Kontrolle beginnen. Der Katenkontrolleur darf dem Besucher die Karte erst dann wieder zurückgeben, wenn der Personenkontrolleur seine Kontrolle beendet hat.
Nur wenn eine komplette Kontrolle(PErson und Eintrittskarte)durchgeführt wurde, darf der Besucher den Kontrollbereich verlassen.
Entwickeln Sie ein C-Programm, in welchem ein Elternprozess folgende Kind-Prozesse kreiert:

Besucher 1 bis Besucher 6 nach folgendem Pseudocode:

Besucher{
<betritt Sicherheitszone>
<betritt Kontrollbereich>
<verlässt Kontrollbereich>
<verlässt Sicherheitszone>
}

Kartenkontrolleur{
<nimmt Besucher Eintrittskarte ab>
<kontrolliert Karte>
<gibt Besucher Karte zurück>
}

Personenkontrolleur{
<kontrolliert Besucher>
}
Die Prozesse sollen sich durch Semaphore synchronisieren, die vom Elternprozess zu Anfang kreiert. Die Kindprozesse sollen von ihrem Elternprozess nach einer gewissen Zeit(z.B. nach 10 Sekunden) beendet werden. Löschen sie die Semaphore nach ihrer Benutzung!

So viel erstmal zu Aufgabenstellung,weiter unten mein bisheriges Programm:


#include<stdio.h>
#include<stdlib.h>
#include<sys/sem.h>
#include<sys/ipc.h>
#include<unistd.h>
#include<errno.h>

int main(){

int SIZ, KOB, KKO, PKO, B;
int semid,err,i;
unsigned short init_array[5];

struct sembuf B_p, B_v;
struct sembuf SIZ_p, SIZ_v;
struct sembuf KOB_p, KOB_v;
struct sembuf KKO_p, KKO_v;
struct sembuf PKO_p, PKO_v;

semid=semget(IPC_PRIVATE,5,IPC_CREAT|0777);

init_array[0]=4;
init_array[1]=1;
init_array[2]=0;
init_array[3]=0;
init_array[4]=0;
init_array[5]=0;

semctl(semid,0,SETALL,init_array);

if(semid<0){
printf("Fehler beim Ablegen der Semaphore\n");
return -1;
}
err=semctl(semid,0,SETALL,init_array);
if(semid==-1){
printf("Fehler beim Anlegen der Semaphore\n");
perror("");
return -1;
}
else{
printf("Semaphore angelegt\n");
perror("");
}


SIZ_p.sem_num=0;
SIZ_p.sem_op=-1;
SIZ_p.sem_flg=0;
SIZ_v.sem_num=0;
SIZ_v.sem_op=1;
SIZ_v.sem_flg=0;

KOB_p.sem_num=0;
KOB_p.sem_op=-1;
KOB_p.sem_flg=0;
KOB_v.sem_num=0;
KOB_v.sem_op=1;
KOB_v.sem_flg=0;

KKO_p.sem_num=0;
KKO_p.sem_op=-1;
KKO_p.sem_flg=0;
KKO_v.sem_num=0;
KKO_v.sem_op=1;
KKO_v.sem_flg=0;

PKO_p.sem_num=0;
PKO_p.sem_op=-1;
PKO_p.sem_flg=0;
PKO_v.sem_num=0;
PKO_v.sem_op=1;
PKO_v.sem_flg=0;

B_p.sem_num=0;
B_p.sem_op=-1;
B_p.sem_flg=0;
B_v.sem_num=0;
B_v.sem_op=1;
B_v.sem_flg=0;



if((B=fork())==0){
while(1){
sleep(1);

if(fork()==1){

printf("Besucher betritt Sicherheitszone\n");
semop(semid,&SIZ_v,1);

printf("Besucher betritt Kontrollbereich\n");
semop(semid,&KOB_v,1);

printf("Besucher verlässt Kontrollbereich\n");
semop(semid,&KOB_p,1);

printf("Besucher verlässt Sicherheitszone\n");
semop(semid,&SIZ_p,1);
exit(0);
}
}
}


if((KKO=fork())==0){
while(1);

semop(semid, &KKO_v,1);
printf("Kontrolleur nimmt Karte\n");

semop(semid, &KKO_p,1);
printf("Kartenkonrolleur gibt Karte zurück\n");

}
if((PKO=fork())==0){

while(1){

semop(semid,&PKO_v,1);
printf("Personenkontrolleuer kontrolliert Besucher\n");

semop(semid,&PKO_p,1);
printf("Personenkontrolle ist fertig\n");

}
}

kill(KKO,3);
kill(PKO,3);
kill(B,3);
return 0;
}

Ich bin nicht ganz sicher ob die Anzahl der Semaphoren und deren Anwendung richtig ist ... Desweiteren sollte die fork() nur einmal aufgerufen werden und nach Möglichkeit in eine for-Schleife verpackt werden. Doch irgendwie will mir nicht wirklich ein Konzept einfallen! Wäre toll, wenn sich das jemand mal anschauen könnte...ich komme da auf keinen grünen Zweig ...

[Lupus84]

Also habe nochmal neu angefangen und habe jetzt eine Loesung.Allerdings fehlt noch eine Fehlerbehandlung! Bin natürlich immer froh wenn mir jemand vielleicht noch eine bessere Loesung zeigt! :)

/* Sicherheitsueberpruefung bei einem Rock-Konzert */

#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <signal.h>

int main()
{
int i, status; /* Hilfsvariable */
int security, Kontroll, Ausweis_hin, Ausweis_rueck, Person_hin, Person_rueck; /* Identifikatoren der Semaphorgruppen */
unsigned int init_array[1]; /* zur Initialisierung */
struct sembuf p_op, v_op; /* Buffer mit den Parametern fuer P- und V-Operatoren */
int Besucher1_pid,
Besucher2_pid,
Besucher3_pid,
Besucher4_pid,
Besucher5_pid,
Besucher6_pid,
Ausweis_pid,
Kontroll_pid;
/* PIDS der Kindprozesse */

printf("*************************************\n");
/* erzeugt Semaphorgruppen und einen Identifikator mit allen Zugriffsrechten (777) und weist den Semaphoren den internen Identifikator zu */
security = semget(IPC_PRIVATE, 1, IPC_CREAT|0777);
Kontroll = semget(IPC_PRIVATE, 1, IPC_CREAT|0777);
Ausweis_hin = semget(IPC_PRIVATE, 1, IPC_CREAT|0777);
Ausweis_rueck = semget (IPC_PRIVATE, 1, IPC_CREAT|0777);
Person_hin = semget(IPC_PRIVATE, 1, IPC_CREAT|0777);
Person_rueck = semget(IPC_PRIVATE, 1, IPC_CREAT|0777);

/* Initialisierung der benoetigten Semaphoren mit den zutreffenden Werten */
init_array[0] = 4;
semctl(security, 0, SETALL, init_array);
init_array[0] = 1;
semctl(Kontroll, 0, SETALL, init_array);
init_array[0] = 0;
semctl(Ausweis_hin, 0, SETALL, init_array);
init_array[0] = 0;
semctl(Ausweis_rueck, 0, SETALL, init_array);
init_array[0] = 0;
semctl(Person_hin, 0, SETALL, init_array);
init_array[0] = 0;
semctl(Person_rueck, 0, SETALL, init_array);

/* Vorbereitung der P- und V-Operation */
p_op.sem_num = 0; p_op.sem_op = -1; p_op.sem_flg = 0;
v_op.sem_num = 0; v_op.sem_op = 1; v_op.sem_flg = 0;

/* Erzeugung der "Besucher"-Prozesse */
/* Anschliessend ausfuehren der einzelnen Operationen */
if((Besucher1_pid=fork())==0)
{
semop(security, & p_op, 1);
printf("Besucher 1 betritt die Sicherheitszone!\n");
semop(Kontroll, & p_op, 1);
printf("Besucher 1 betritt den Kontrollbereich!\n");
semop(Ausweis_hin, & v_op, 1);
printf("Besucher 1 gibt den Ausweis ab!\n");
semop(Ausweis_rueck, & p_op, 1);
printf("Besucher 1 nimmt seinen Ausweis zurueck!\n");
semop(Kontroll, & v_op, 1);
printf("Besucher 1 verlaesst den Kontrollbereich!\n");
semop(security, & v_op, 1);
printf("Besucher 1 verlaesst die Sicherheitszone!\n");
exit(0);

}

if((Besucher2_pid=fork())==0)
{
semop(security, & p_op, 1);
printf("Besucher 2 betritt die Sicherheitszone!\n");
semop(Kontroll, & p_op, 1);
printf("Besucher 2 betritt den Kontrollbereich!\n");
semop(Ausweis_hin, & v_op, 1);
printf("Besucher 2 gibt den Ausweis ab!\n");
semop(Ausweis_rueck, & p_op, 1);
printf("Besucher 2 nimmt seinen Ausweis zurueck!\n");
semop(Kontroll, & v_op, 1);
printf("Besucher 2 verlaesst den Kontrollbereich!\n");
semop(security, & v_op, 1);
printf("Besucher 2 verlaesst die Sicherheitszone!\n");
exit(0);

}

if((Besucher3_pid=fork())==0)
{
semop(security, & p_op, 1);
printf("Besucher 3 betritt die Sicherheitszone!\n");
semop(Kontroll, & p_op, 1);
printf("Besucher 3 betritt den Kontrollbereich!\n");
semop(Ausweis_hin, & v_op, 1);
printf("Besucher 3 gibt den Ausweis ab!\n");
semop(Ausweis_rueck, & p_op, 1);
printf("Besucher 3 nimmt seinen Ausweis zurueck!\n");
semop(Kontroll, & v_op, 1);
printf("Besucher 3 verlaesst den Kontrollbereich!\n");
semop(security, & v_op, 1);
printf("Besucher 3 verlaesst die Sicherheitszone!\n");
exit(0);

}

if((Besucher4_pid=fork())==0)
{
semop(security, & p_op, 1);
printf("Besucher 4 betritt die Sicherheitszone!\n");
semop(Kontroll, & p_op, 1);
printf("Besucher 4 betritt den Kontrollbereich!\n");
semop(Ausweis_hin, & v_op, 1);
printf("Besucher 4 gibt den Ausweis ab!\n");
semop(Ausweis_rueck, & p_op, 1);
printf("Besucher 4 nimmt seinen Ausweis zurueck!\n");
semop(Kontroll, & v_op, 1);
printf("Besucher 4 verlaesst den Kontrollbereich!\n");
semop(security, & v_op, 1);
printf("Besucher 4 verlaesst die Sicherheitszone!\n");
exit(0);
}

if((Besucher5_pid=fork())==0)
{
semop(security, & p_op, 1);
printf("Besucher 5 betritt die Sicherheitszone!\n");
semop(Kontroll, & p_op, 1);
printf("Besucher 5 betritt den Kontrollbereich!\n");
semop(Ausweis_hin, & v_op, 1);
printf("Besucher 5 gibt den Ausweis ab!\n");
semop(Ausweis_rueck, & p_op, 1);
printf("Besucher 5 nimmt seinen Ausweis zurueck!\n");
semop(Kontroll, & v_op, 1);
printf("Besucher 5 verlaesst den Kontrollbereich!\n");
semop(security, & v_op, 1);
printf("Besucher 5 verlaesst die Sicherheitszone!\n");
exit(0);
}

if((Besucher6_pid=fork())==0)
{
semop(security, & p_op, 1);
printf("Besucher 6 betritt die Sicherheitszone!\n");
semop(Kontroll, & p_op, 1);
printf("Besucher 6 betritt den Kontrollbereich!\n");
semop(Ausweis_hin, & v_op, 1);
printf("Besucher 6 gibt den Ausweis ab!\n");
semop(Ausweis_rueck, & p_op, 1);
printf("Besucher 6 nimmt seinen Ausweis zurueck!\n");
semop(Kontroll, & v_op, 1);
printf("Besucher 6 verlaesst den Kontrollbereich!\n");
semop(security, & v_op, 1);
printf("Besucher 6 verlaesst die Sicherheitszone!\n");
exit(0);
}

/* Erzeugen des "Ausweiskontrolleur"-Prozesses */
if((Ausweis_pid=fork())==0)
{
while(1){
semop(Ausweis_hin, & p_op, 1);
printf("Der Ausweiskontrolleur hat dem Besucher den Ausweis abgenommen!\n");
semop(Person_hin, & v_op, 1);
printf("Der Ausweiskontrolleur hat den Besucher zur Personenkontrolle geschickt!\n");
printf("Der Ausweiskontrolleur kontrolliert den Ausweis!\n");
semop(Person_rueck, & p_op, 1);
printf("Der Ausweiskontrolleur hat die Personenkontrolle abgewartet!\n");
semop(Ausweis_rueck, & v_op, 1);
printf("Der Ausweiskontrolleur hat dem Besucher den Ausweis zurueckgegeben!\n");
}
}

/* Erzeugen des "Personenkontrolleur"-Prozesses */
if((Kontroll_pid=fork())==0)
{
while(1){
semop(Person_hin, & p_op, 1);
printf("Der Personenkontrolleur hat den Besucher kontrolliert!\n");
semop(Person_rueck, & v_op, 1);
}
}

sleep(20);

/* Terminieren der "Kontrolleur"-Prozesse, da diese sonst ewig weiterlaufen wuerden */
kill(Ausweis_pid, SIGKILL);
kill(Kontroll_pid, SIGKILL);


/* Loeschen der Semaphoren */
semctl(security, 0, IPC_RMID, 0);
semctl(Kontroll, 0, IPC_RMID, 0);
semctl(Ausweis_hin, 0, IPC_RMID, 0);
semctl(Ausweis_rueck, 0, IPC_RMID, 0);
semctl(Person_hin, 0, IPC_RMID, 0);
semctl(Person_rueck, 0, IPC_RMID, 0);
printf("************************************\n");
}