jSchedule - An Extensible Framework For Production Planning

Document Sample
jSchedule - An Extensible Framework For Production Planning Powered By Docstoc
					  jSchedule - An Extensible Framework For
            Production Planning


                   Verteidigung des ”Großen Belegs”

                                20. Juni 2008




         Von: Cornelius Hald
Betreut durch: Prof. Dr. rer. nat. Oliver Rose

Am Lehrstuhl: Modellierung und Simulation, Fakultät Informatik, TU-Dresden
                    Gliederung

   Motivation
   Überblick
   Basis-Architektur
   Objekt-Modell
   Benutzung des Frameworks
   jSchedule erweitern
   Wunschliste
   Mögliche Anwendungen
   Fragen & Antworten
Motivation
                           Motivation

   Ursprüngliche Motivation
       LEKIN-Scheduler kann keine preemptiven Pläne
        erzeugen.
   Spätere Ziele
       Das Framework soll
            Die Entwicklung zukünftiger Projekte beschleunigen
            Studenten helfen, ihre Algorithmen zu testen
            Rapid-Prototyping von Algorithmen bieten
            In Zukunft vielleicht LEKIN-Scheduler ersetzen
            Einfach zu benutzen sein
   Andere verfügbare Lösungen sind nicht geeignet
              Bestehende Lösungen

   Andere Lösungen sind meistens
       Auf Geschwindigkeit optimiert, deshalb
            sind sie in C/C++ implementiert
            ist das Schreiben von Algorithmen schwieriger
            ist das Modell kryptischer (z.B. Matrizen statt Objekten)
       Spezialisiert auf bestimmte Probleme oder
        Umgebungen, z.B. Flow-Shops
       Nicht frei verfügbar
                          Beispiel: Lisa

   Lisa
       Open-Source Scheduling-Framework
       Geschrieben in C++
       Um einen Algorithmus zu implementieren braucht man:
            C++ Datei, in der man folgendes implementieren muss
                 Streams anlegen für das Lesen und Schreiben von Dateien
                 Eingabewerte aus Dateien lesen
                 Den Algorithmus ausführen
                 Ausgabe in Datei schreiben
                 Alle Streams etc. schließen
                 ==> Schon ca. 25 Zeilen Code ohne Algorithmus
            Makefile
            XML-Descriptor
Überblick
     Eigenschaften von jSchedule

   Bietet ein objekt-orientiertes Modell für Jobs, Maschinen,
    Workcenter, etc.
   Hilft beim Algorithmen schreiben
   Ist nicht festgelegt auf spezielle Probleme
   Gibt einen Rahmen zur Einbettung eigenen Codes vor
   Unterstützt beim Bewerten von Plänen
   Besteht aus leicht verständlichem Java-Code
       Benutzt keine Fremd-Bibliotheken (außer JRE)
   Ist Erweiterbar und anpassbar an eigene Bedürfnisse
   Bietet XML Import & Export
                            Flexibilität

   Flexibilität
        Eigene Umgebungen, Zielfunktionen, Constraints, etc.
         können implementiert werden.
        D.h., es können auch nicht vorhergesehene Probleme
         bearbeitet werden.
        Beispiel: Implementierung neuer Funktionalität
             Job mit den Eigenschaften ”Konventionalstrafe” und ”Priorität”
             Zielfunktion, welche beide Eigenschaften in Betracht zieht
             Algorithmus, der nach der neuen Zielfunktion optimiert
        Alle neu implementierten Klassen (Eigenschaften,
         Zielfunktion, Algorithmus) können wiederverwendet
         werden.
Basis-Architektur
Basis-Architektur


 Algorithm               Problem




             Scheduler




             ResultSet
                   Problem (1)
                                          Algorithm       Problem
   Ist die Beschreibung der gesamten
    Ausgangssituation
                                                  Scheduler
   Der einzige Eingabeparameter für den
    Algorithmus
   Bietet Methoden getMax(), getMin(),           ResultSet
    getAverage(), sort(), ...
   Ist Factory für Jobs und Maschinen
          Problem (2)

                  Jobs



               Workcenters   Machines



Problem        Environment



               Constraints



                Objective
                     Algorithm
                                         Algorithm       Problem
   Beschreibt, welche Problem-Typen
    er lösen kann (Capabilities)
                                                 Scheduler
   Bekommt vom Scheduler eine
    Kopie des Problems
   Beinhaltet die komplette Logik, in           ResultSet
    welcher Reihenfolge Jobs auf
    Maschinen gelegt werden
   Kann beliebige andere Objekte,
    Bibliotheken oder externen Code
    aufrufen
                     Scheduler
                                           Algorithm       Problem
   Prüft, ob der Algorithmus auf das
    Problem angewandt werden kann
                                                   Scheduler
   Gibt dem Algorithmus eine Kopie
    des Problems
   Startet den Algorithmus                        ResultSet

   Liefert ein ResultSet zurück. Dieses
    enthält einen oder mehrere gültige
    Pläne.
                        ResultSet
                                           Algorithm       Problem
   Ist eine Menge von gültigen Plänen
   Ein Plan (Schedule) beinhaltet                 Scheduler
       Ausgangsproblem
       Workcenter
                                                   ResultSet
       Maschinen
       Operationen (mit Referenzen zu Jobs)
       Das Interface IObjectiveProvider
            int l = schedule.calculate(Obj.LMAX);
            int m = schedule.calculate(Obj.CMAX);
Objekt-Modell
       Objekt-Modell (Ausschnitt)
                             Item                     *   Property




                                            ValueProperty      KeyedProperty



                                          DueDateProperty      SetupTimeProp



Workcenter         *       Maschine   *     Job
                                                  1



                                      *   Operation




      IObjectiveProvider                                             Schedule
Benutzung des Frameworks
        Benutzung des Frameworks

   Typischerweise werden folgende Schritte ausgeführt
       Ein Problem erstellen
       Mehrere Jobs und Maschinen erzeugen
       Die Eigenschaften der Jobs und Maschinen setzen
       Einen Algorithmus auswählen
       Den Scheduler starten
       Das Ergebnis bewerten
                     Problem erstellen

   Env env = Env.PM;
   Obj obj = Obj.CMAX;
   Con co1 = Con.DUEDATES;
   Con co2 = Con.REALEASETIMES;
   Problem prob =
      new Problem(env, 3, obj, co1, co2);

      Parallele              Makespan                    Release Time
Maschinen-Umgebung           Zielfunktion                 Constraint

                  Drei                      Due Date
                Maschinen                   Constraint
           Jobs erzeugen
                                          Zwei Jobs
Job j1 = problem.addJob("j1", 5);         erzeugen
                                          und dem
Job j2 = problem.addJob("j2", 8);         Problem
                                          hinzufügen.


j1.setReleaseTime(2);
j1.setDueDate(7);
                         Für beide Jobs das
                         ReleaseTime- und das
                         DueDate-Property
j2.setReleaseTime(5);    setzen.

j2.setDueDate(10);


Machine m1 = problem.addMachine("m1");
             Scheduling

Scheduler scheduler =              Einen neuen
                                   Scheduler
  new Scheduler(prob, Algo.EDD);   anlegen und
                                   den
ResultSet result =                 Algorithmus
                                   ausführen.
  scheduler.schedule();



Schedule schedule =
                                   Den ersten
  result.get(0);                   Schedule
                                   holen und
int cmax =                         Makespan
                                   berechnen.
  schedule.calculate(Obj.CMAX);
jSchedule erweitern
              jSchedule erweitern

   Einfache Erweiterbarkeit von:
       Constraint
       Property
       Environment
       Objective
       Algorithm
   Ähnliches Vorgehen für alle
    Klassen
   Factories sind vorhanden
   Plugin-Architektur noch nicht
    festgelegt
Eine Zielfunktion implementieren

   Von jschedule.main.objectives.Objective erben
   Die folgenden abstrakten Methoden implementieren
    int calculate(IObjectiveProvider p);
    String getName();
    Obj getEnum();

   Den Enum jschedule.main.objectives.Obj erweitern
          Makespan-Zielfunktion

@Override
public int calculate(IObjectiveProvider p) {
    int makespan = 0;
    int endTime     = 0;
    for (Operation o : p.getAllOperations()) {
        endTime   = o.getEndTime();
        makespan = Math.max(endTime, makespan);
    }
    return makespan;
}
     Algorithmus implementieren

   Capabilities definieren, welche Probleme ein
    Algorithmus lösen kann.

    @Override
    public Set<Capability> getCapabilities() {
    EnvironmentDefinition def = new
     EnvironmentDefinition(Env.Pm, 1, 3);
    Capability c = new Capability(def,
     Obj.CMAX, Con.DUEDATES, Con.PREC);
    [...]
    }
        Einfacher EDD-Algorithmus

public ResultSet execute(Problem p) {
    p.sortJobsAsc(Prop.DUEDATE);
    Machine machine = p.getMachine(0);
    for (Job job : p.getJobs()) {
        machine.scheduleJob(job);
    }
    Schedule schedule = new Schedule();
    schedule.addMachine(machine);
    return new ResultSet(schedule);
}
Wunschliste
      Algorithmen-Komponenten

   Unterstützung für Algorithmen-Komponenten


        Problem                         Problem




       Algorithm 1                   Main Algorithm




       Algorithm 2        Sub Algorithm 1      Sub Algorithm 2




        Solution                        Solution
             Validierung von Plänen

   Bessere Validierung beim Erstellen der Pläne
       Es sollte nicht möglich sein, einen Algorithmus zu
        schreiben, der bestehende Constraints verletzt.
       Dafür müsste jeder Constraint und jedes Environment
        Regeln beinhalten, mit denen ein Plan geprüft werden
        kann.
       Probleme:
            Umsetzung (Kombination aller Regeln prüfen)
            Performance
                       Sonstiges

   Besserer XML Import & Export
       Momentan können nicht alle Eigenschaften (z.B.
        Object) eines Jobs verarbeitet werden.
   Tiefere Integration der Import & Export Schnittstellen
       Der Entwickler sollte mehr Unterstützung vom
        Framework bekommen.
   Mehr Flexibilität bei den Rückgabewerten von
    Zielfunktionen
       In dieser Version nur Integer-Werte möglich
                   Anwendungen

   Offener LEKIN-Scheduling Ersatz
       UI für das Erstellen von Problemen
       UI für die Anzeige von Plänen
       Interaktion mit Modell
   Scheduling Webservice
       Könnte zentral Planungsdienste für verschiedene
        Anwendungen bereit stellen
   Integration mit Dritt-Software
       Z.B. Microsoft Excel
       Simulationssoftware
Fragen & Antworten
Danke für Ihre Aufmerksamkeit!
                    Bildnachweis

   Alle Bilder stehen unter einer Creative Commons
    Lizenz.
   Quellen:
       http://flickr.com/photos/slaff/1536210711/
       http://flickr.com/photos/loupiote/25426957
       http://flickr.com/photos/photochiel/156811950
       http://flickr.com/photos/yadayada/1818614990
       http://flickr.com/photos/bradburiana/994029370
       http://flickr.com/photos/billjacobus1/122497422
       http://flickr.com/photos/pavel1998/2110081159
       http://flickr.com/photos/ogil/1507585665
                                Lizenz

This work is licensed under the Creative Commons Attribution-Noncommercial-
No Derivative Works 3.0 Germany License. To view a copy of this license, visit
http://creativecommons.org/licenses/by-nc-nd/3.0/de/ or send a letter to Creative
Commons, 171 Second Street, Suite 300, San Francisco, California, 94105,
USA.

				
DOCUMENT INFO
Shared By:
Categories:
Stats:
views:6
posted:2/10/2010
language:German
pages:38