Semaphoren in Abhängigkeit an Bedingungen richtig setzen

[BodyLAB]

Hallo zusammen,

hab folgende Aufgabe (ist rein Theoretisch):

Ein Händler hat ein Lager für Kaffeesäcke und Tassen.
Beliefert wird er von einem Lieferant, der bei jeder Lieferung eine Tasse und ein Kaffeesack bringt.
Ein Ausfahrer A1 bringt je Fahrt eine Tasse zum Kunden, ein Ausfahrer A2 je Fahrt einen Kaffeesack.
Zum Be- und Entladen muss eine Laderampe benutzt werden.

Folgende Bedingungen müssen erfüllt werden:

• Zur Rampe kann jeweils nur ein Prozess (Lieferant, A1, A2) fahren
• A1 darf nur zur Rampe fahren, wenn noch eine Tasse im Lager ist. Analog zu A2.
• Das Lager hat eine beschränkte Kapazität, es kann höchstens 20 Stück aufnehmen
• Der Lieferant darf nur zur Rampe fahren, wenn er seine Lieferung vollständig abladen kann
• Zu Beginn sei das Lager leer und die Rampe frei

Liste alle benötigen Semaphoren auf und erkläre ihren Zweck:
Ich dachte hier an folgende Semaphoren:
RampenSemaphore(1) => Dieser Semaphore soll gewerleisten das immer nur ein Process die Rampe erhält
TassenSemaphore(0) => Dieser Semaphore soll signalisieren das es Tassen gibt
KaffeesackSemaphore(0) => wie TassenS.
MaxSemaphore(20) => Dieser Semaphore soll die Kapazität simulieren.

Füge in den aufgelisteten Pseudocode des Ablaufs der beteiligten Prozesse an entsprechenden Stellen den Aufruf der Semaphore da:

Process Lieferant {                Process A1 {                    Process A2 {
    while(true) {                    while(true) {                    while(true) {
      <zur Rampe fahren>;              <zur Rampe fahren>;              <zur Rampe fahren>;
      <1 Tasse entladen>;              <1 Tasse aufladen>;              <1 Kaffesack aufladen>;
      <1 Kaffeesack entladen>;          <Rampe verlassen>;              <Rampe verlassen>;
      <Rampe verlassen>;            }                                  }
    }                            }                                }
}

Mein Problem ist das ich das ganze mit der Kapazität nicht hin bekomme.

Bei mir würde der Process Lieferant wie folgt aussehen:

Process Lieferant {
    while(true) {
        MaxSemaphore.P(2); //Hier kommen 2 Exemplare ins Lager (Lager ist am Anfang leer)
        TassenSemaphore.V(); //Hier wird jetzt eine Tassen Objekt ins Lager gelegt
        KaffeesackSemaphore.V(); //ebenfals wie oben
        RampenSemaphore.P(); //Hier betritt nun der Lierferant die Rampe
        <zur Rampe fahren>;
        <1 Kaffeesack entladen>;
        <1 Tasse entladen>;
        <Rampe verlassen>;
        RampenSemaphore.V();
    }
}

Das sieht sehr merkwürdig aus (es sieht Falsch aus!) und deswegen bin ich mir total unsicher.
Vermutlich benötigt man mehr Semaphore?

Kann mir hierbei jemand Helfen?

 

[ChrisianM]

Ich würde sagen, du müsstest auf jeden Fall die auf dem Lager bereits befindliche Menge in einer Variable mitlaufen lassen.

Also in etwa so:

imLagerBefindlich = 0;

If imLagerBefindlich + neueLademenge <= 20 {
   ProzessSemaphore();
   imLagerBefindlich += neueLademenge;

else {
   abbrechen();

 

[BodyLAB]

Ich hab die Aufgabenstellung im Internet gefunden Wurde bei uns nur etwas abgeändert.

Klausur zur Vorlesung Grundlagen Betriebssysteme und Systemsoftware - PDF Kostenfreier Download

Klausur zur Vorlesung Grundlagen Betriebssysteme und Systemsoftware (Prof. Dr. J. Schlichter, Dr. W. Wörndl, WS 2011/12) Die Bearbeitungsdauer beträgt 90 Minuten. Es sind keine Hilfsmittel zugelassen.

docplayer.org

Aufgabe 1 ist meine Aufgabe. Leider finde ich derzeit keine Lösung dazu :-D
Ich weiß nämlich nicht ob es erlaubt ist ein wert dort mit rein zu geben oder ob das alles nur mit Semaphore erledigt werden soll?

 

[BodyLAB]

So also ich hab es jetzt so gemacht wie @AnfängerHoch10 geschrieben. Ob das erlaubt ist weiß ich nicht.

Als erstes benötige ich damit auch nur noch 3 Semaphore.
Der erste ist eben der dafür sorgt das immer nur ein Prozess zur Rampe läuft.
Der zweite und dritte ist das Abfragen ob eine "Couch" oder "Schrank" vorhanden sind <- ich orientiere mich jetzt an dem PDF von oben! Gefällt mir besser.

Mein Lösung würde dann wie folgt aussehen:

Semaphore: Rampe(1), S(0), C(0);


Proicess S {
    while(true) {
        S.p();
        Rampe.p();
        <zur Rampe fahren>
        <1 Schrank aufladen>
        <Rampe verlassen>
        Rampe.v();

    }
}

Proicess C {
    while(true) {
        C.p();
        Rampe.p();
        <zur Rampe fahren>
        <1 Couch aufladen>
        <Rampe verlassen>
        Rampe.v();

    }
}

Proicess F {
    imLagerBefindlich = 0;
    while(true) {
        if(imLagerBefindlich + 2 <= 20) {
            Rampe.p();
            imLagerBefindlich += 2;
            <zur Rampe fahren>
            <1 Schrank aufladen>
            S.v();
            <1 Couch aufladen>
            C.v();
            <Rampe verlassen>
            Rampe.v();
        }
    }
}

Dadurch das immer nur ein Prozess zur selben Zeit etwas abarbeitet benötigt man keine zwischen Synchronisation zwischen den Prozessen also sprich wenn ein Prozess ran darf, kann bzw. muss dieser auch zu ende laufen. Deswegen arbeitet Prozess C und S auch alles auf einmal ab und geben die Rampe wieder frei.

Falls jemand weiß wie das mit der Kapazität sonst gehen würde only semaphores wäre das echt Klasse würdet Ihr es mit mir Teilen
Ansonsten weiß ich auch nicht ob das so zu 100% korrekt ist?