SS2013: EA2.2 (Lagerverwaltung mit SLX)

Hallo,

ist hier noch jemand der sich in diesem Semester mit dem Kurs und den EAs beschäftigt?

Ich schlage mich gerade mit o.g. Einsendeaufgabe und könnte wirklich gut noch eine Hilfestellung gebrauchen.

Welche Klassen benötigen ich?
- class Artikel (passiv gem. Aufgabenstellung)
- class ma_Auslagerung (aktiv, übernimmt die Auslagerung) ??
oder bringe ich Ein- und Auslagerung in der main() unter?

Ich habe die gleiche Frage eben auch im moodle gepostet. Dort scheint aber auch nicht viel los zu sein.

Gruß
Jens
 
Hi Jens,

da geht es mir wie dir. Kämpfe auch ziemlich mit der Aufgabe.
Momentan habe ich nur eine class Artikel, in der ich die Artikel einlagere und eine main-Prozedur, in der ich Instanzen von den Artikeln erzeuge.
Danach kommt, in einer zweiten Fork-Anweisung, das auslagern.
Durch die Vorgabe mit Sets zu arbeiten, ist das alles etwas einfacher.
Ist alles nicht so sauber, aber funktioniert einigermaßen. Muss nur noch herausfinden, wie ich die durchschnittlichen und maximalen Zeiten berechnen kann.

Aber gut zu wissen, dass ich nicht der einzige bin ;-)

Viele Grüße,
Lucjan
 
Hallo Lucjan,
also eine Klasse Artikel, die einlagert kann man eigentlich nicht machen, da Artikel laut Aufgabenstellung passive Objekte sein sollen. Somit gibt es dort keine Logik.
Also bei mir funktioniert das Ein- und Auslagern grundsätzlich schon ganz gut.
Wo ich ein Problem habe: Wie setze ich am besten eine Warteschlange für Bestellungen um, für die aktuell kein Artikel im Lager ist?
Erstelle ich für jede Artikelart eine eigene Wartschlange?
Oder gibt es gar eine eigene Warteschlangenklasse?
Gruß
BeachyX
 
Beachy, wie hast du denn das ein- und auslagern gelöst? Für mich hat das in der Klasse Artikel am meisten Sinn gemacht, aber in der Main - Prozedur kann ich es auch packen. Dann wäre der Artikel zumindest passiv.
Fand es aber sinnvoll eine Klasse Artikel anzulegen, da ich dort sagen kann: Keine Plätze mehr frei -> WAIT_UNTIL Plätze frei.
Ich bin mir nicht sicher, dass man die Bestellungen so explizit beachten muss, wie du das tust. Aber ich denke, da bist du mit einer Warteschlage wohl am besten bedient. Würde dann eine Warteschlange pro Artikelart vorschlagen, das müsste am unproblematischsten sein.
Auch die Auslagerung habe ich sehr einfach gelöst und das komplette Lager aufgelöst, sobald es voll war.

Zum Vergleich mal mein unfertiger(!) Quellcode:
//*****************************************************************************
// SLX Lagerverwaltung
//*****************************************************************************

import <h7>

module lager1
{
//*****************************************************************************
// Global Declarations
//*****************************************************************************

rn_stream Ankunft;

// deterministische Zeitangaben
int simulationszeit = 60;


//Prüfung auf freie Lagerplätze
control boolean lagerplatz_frei = TRUE;

// Verfügbare Plätze
int plaetze = 10;
int platz;

set ( Artikel ) ranked FIFO lager1;
set ( Artikel ) ranked LIFO lager2;

random_variable(time) rv_avgtime;
random_variable(time) rv_maxtime;

pointer (Artikel) akt_artikel;




//*****************************************************************************
// Customer Object
//*****************************************************************************

class Artikel
{
float auslagerung;
float einlagerung;
actions
{
if (lagerplatz_frei == FALSE)
{
wait until (lagerplatz_frei == TRUE);
}
else{
plaetze -= 1;
//place ME into lager1;
//place ME into lager2;

}
if (plaetze == 0){
lagerplatz_frei = FALSE;
}

einlagerung = rv_expo(Ankunft, 10.0);
auslagerung = rv_expo(Ankunft, 10.0);

tabulate rv_maxtime = auslagerung - einlagerung;

}
}

//*****************************************************************************
// Lagerverwaltung
//*****************************************************************************

procedure main
{
pointer ( Artikel ) art;
int ankunft;

fork{
forever{
art = new Artikel;
activate art;
place art into lager1;
place art into lager2;
platz=rv_discrete_uniform(Ankunft, 1, 10);
advance platz;
fork {
if (lagerplatz_frei == FALSE){


for (art = each Artikel in lager2)
remove art from lager2;
for (art = each Artikel in lager1)
remove art from lager1;
//remove art from lager1;
lagerplatz_frei = TRUE;
plaetze =10;
}

}


// terminate;
}

}

advance simulationszeit;



report system;
}

} // End of Lagerhaltung
 
Top