Abbildung von UML Klassendiagrammen 


Мы поможем в написании ваших работ!



ЗНАЕТЕ ЛИ ВЫ?

Abbildung von UML Klassendiagrammen



Jede Klasse auf eine Klasse abgebildet in OO-Sprachen

In nicht OO-Sprachen auf Strukturen (Verbund)

In C mit struct C {int a1;…}; struct C c1, c2, c3;

ODER mit typedef struct {int a1;…} C; C c1,c2,c3;

C * c4;/* Referenz! */

c4 = (C*) malloc(sizeof(C));

Bei Referenzen geschieht der Attributzugriff mit Operator ->: c4->a1

 

Methoden werden umgewandelt wie hier:

m(parameter) {...attribut... }

wird zu freistehender Funktion

m(C* objekt, parameter) {...objekt->attribut... }

Vererbung wird simuliert, in dem die Attribute der Oberklassen dem Verbund hinzugefügt werden

Polymorphie kann man falls nötig über Funktionszeiger und Typumwandlung des ersten Parameters simulieren.

Referenzen benutzen, um Assoziationen zu simulieren.

 

{ordered} -> List<A> z.B. ArrayList, Vector

{unique} -> HashSet<A>, TreeSet<A>

Qualifizierer -> Abblidung<Objekt,B> z.B. HashMap<Signature,Object>

Implementierung von Zustandsautomaten

Implizite Speicherung – berechnet aus Attributen, Zustandsübergangsfunktion ist implizit, jedes Mal neu berechnet.

Explizite Speicherung ­– explizit zugeweist, Zustandsübergangsfunktion explizit.

Vergleich Implizite vs Explizite

· Implizite Speicherung spart Speicherplatz

· Explizite spart Rechenzeit

· Implizite ist komplizierter

· Explizite ist umfangreicher

· Explizite ist offensichtlicher und wird bei Änderungen wahrscheinlicher berücksichtigt

· Implizite ist nicht immer möglich, explizite schon

Eingebettet:

· Jede Methode kennt den kompletten Automaten

o Sie führt ihre Aufgabe kontextsensitiv

o Nimmt die Zustandsübergänge selbst vor

o Implementier als eine große Fallunterscheidung pro Methode (switch z.B.)

· Kompakter, schneller

Ausgelagert:

· Die Methode läuft im aktuellen Zustand, der ein Objekt ist

· Der Code zur Reaktion und Änderung der Zustände befindet sich in dedizierten Klassen

· Die Äste der Fallunterscheidung sind auf gleichnamige Methode verteilt

· Vorteil: flexibler, bei komplexen Automaten übersichtlicher

 

Grundlagen zur Parallelverarbeitung

Warum?

· Mehr Leistung oder mehr Ressourcen als Prozessorsysteme bieten können

· Taktfrequenzen steigen nicht

· Simulationen, wenn Experimente unmöglich sind

Alte Mooresche Regel: Doubling every two years

Neue Mooresche Regel: Verdoppelung der Anzahl Prozessoren pro Chip mit jeder Chip-Generation, bei etwa gleicher Taktfrequenz.

Multikern in Servers seit 2005, in Laptops seit 2006.

Es wird zwischen nebenläufig und parallel unterschieden, klar.

Zwei wichtige Architekturen:

· Gemeinsamer Speicher (wurde in Vorlesung behandelt)

· Verteilter Speicher

Prozess

· Wird durch Betriebssystem erzeugt

· Enthält Informationen über Programmressourcen und Ausführungszustand, z.B.

o Code-Segment (Programminstruktionen)

o Daten-Segment (für globale Variablen, Keller, Halde)

o Mind. 1 Kontrollfaden

· CPU-Kontrollwechsel zwischen Prozessen langsam

Kontrollfaden (Thread):

· Instruktionsfolge, die ausgeführt wird

· Existiert in einem Prozess

· Ein Faden hat eigenen

o Befehlszeiger

o Keller (Stack)

o Register

· Teilt sich mit anderen Fäden des gleichen Prozesses

o Adressraum

o Code/Daten-Segmente

o Andere Ressourcen (z.B geöffnete Dateien, Sperren)

· CPU-Kontrollwechsel zw. Fäden des gleichen Prozesses schneller, als zw. unterschiedlichen Prozessen

Prinzipielles Vorgehen bei gemeinsamen Speicher:

· Fäden erhalten parallel auszuführende Aufgaben (Instruktionen)

· Informationsaustausch über gemeinsam genutzte Variablen im Speicher

· Synchronisationskonstrukte koordinieren Ausführung im Falle von Daten oder Kontrollabhängigkeiten

· Prozesse und deren Fäden werden grundsätzlich vom Betriebssystem erzeugt und auf Prozessoren bzw. Kerne verteilt

o Schnittstellen dazu meistens in Programmiersprachen eingebaut

Parallelität für Java > 1.0

Der neue Kontrollfaden hat:

· Eigenen Keller und Programmzähler

· Zugriff auf den gemeinsamen Hauptspeicher (Halde)

· Möglicherweise lokale Kopien von Daten des Hauptspeichers(Cache)

Konstrukte zum Erzeugen von Parallelität

· Implementieren von Runnable

· Subklasse von Thread anlegen

· In beiden Fällen run() überschreiben

start() an Thread Instanz aufrufen um zu starten

Runnable leistet bessere Modularisierung.

Runnable ist serialisirbar, Thread nicht.

Grundlegende Koordinationsmechanismen sind eingebaut:

· Wechselseitiger Ausschluss

o Kritische Abschnitte, die nur von einer Akivität gleichzeitig benutzt werden

· Warten auf Ereignisse und Benachrichtigung

o Aktivitäte können auf Zustandsänderungen warten, die durch andere Aktiviäten verursacht werden

o Aktivitäten informieren andere, wartende Aktivitäten über Signale

· Unterbrechungen

Kritischer Abschnitt ist ein Stück Code, wo der Zugriff von mehreren Fäden gleichzeitig stattfindet.

· Nur eine Aktivität darf den kritischen Abschnitt gleichzeitig bearbeiten

· Vor dem Betreten muss sichergestellt werden, dass keine andere Aktivität den bearbeitet

Atomarität – Java garantiert, dass Zugriffe auf einzelne Variablen atomar erfolgen. (Ausgenommen double und long)

Zugriffe auf mehrere Variablen oder aufeinanderfolgende Lese- und Schreiboperationen werden nicht atomar ausgeführt.

Auch wenn Zugriff atomar ist, ist Synchronisation beim Speichern erforderlich.

Monitore zum Schutz kritischer Abschnitte.

· enter() und exit()

Jedes Objekt kann als Monitor verwendet werden (nicht die primitiven Typen)

XC2 monitorenter

0xC3 monitorexit dürfen nur paarweise in einem Block auftreten, damit man exit() nicht vergisst. Vor dem ausführen des Bytecodes wird das überprüft.

Um wait() und notify() aufrufen zu können, muss die akteulle Aktivität mit synchronized den zugehörigen Monitor bereits betreten haben.

Nach dem wait() passiert folgendes:

· Die akteulle Aktivität wird schlafengelegt, d.h. gibt den Prozessor ab

· Die Aktivität wird in eine Wait-Menge an dem Monitor des Objekts, an dem wait aufgerufen war, eingefügt.

· Der betreffende Monitor wird während des Wartens freigegeben.

· Andere Aktivitäten können jetzt um den Monitor konkurrieren

wait(long timeout, int nanos) wartet die Zeit und dann noch bis zur Freigabe des Monitors

notifyAll() weckt alle schlafende Aktivitäten auf, und die konkurrieren erneut um den Monitor

Geht schlafen gleich nach dem wait().

FALSCH: if(bedingung){wait()}; mit if

Gründe:

· Vorher: Kontrollfaden nicht unnötigerweise schlafen gehen

· Nachher: Nicht sichtbar, warum ein Signal geschickt wurde. Soll aber aus wait() rauskommen, nur dann, wenn die Bedingung falsch ist.

Notify mit notifyAll ersetzen

Problem: Wie beendet man eine Aktivität, die auf Signale wartet, die nicht mehr eintreffen werden? Antwort: interrupt() an Thread schicken.

Interrupt() geht nicht verloren, wird bei nächstem wait() executed

Wenn keine Behandlung für InterruptedException gibt, dann weiterleiten mit throw.

Nicht mit leeren catch-Block die InterruptedException empfangen

Trotz synchronized können noch deadlocks entstehen („gib mir Paapier“ und „gib mir den Stift“)

Math.ceil(n/#threads), nicht Math.floor

Nachdem alle Threads gestartet wurden, soll join aufgeruft warden, um bis Ende des Arbeits zu warten.

Java.util.concurrent stellt weitere Klassen zur parallelen Programmierung zur Verfügung, die ansonsten not thread-safe sind.

java.util.concurrent:

· Mengen (collections)

· Kostrukte zur asynchronen Ausführung, Thread Pools

· Synchronisierer (synchronizer)

Einige benutzen aus Performanzgründen keine Monitore, sondern explizite Sperren und volatile-Modifizierer

· Volatile bewirkt, dass ene Variable immer aktualisiert wird, auch wenn es mehrere Kopien davon in Caches gibt.

· Die Kopien selbst werden nicht aktualisiert

BlockingQueue:

· Datentausch zwischen Fäden gemäß dem Erzeuger-Verbraucher Muster

· Erzeuger blockiert, wenn die Schlange voll

· Verbraucher blockiert, wenn die Schlange leer

Verschieden Implementierungen:

· ArrayBlockingQueue – basiert auf Array mit fester Größe

· DelayQueue – ordnet Elemente nach Wartezeiten an

· LinkedBlockingQueue – basiert auf verk Liste

· PriorityBlockingQueue - ordnet Elemente gemäß einer Vergleichsoperation

· SynchronousQueue – basiert auf Schlange mit Kapazität 0, führt zu einem Rendezvous: ablegender und holender Faden warten aufeinander

 

Semaphore – werden zur Synchronisation zwischen Fäden verwendet

· Wird mit einer Anzahl der Genehmigungen initialisiert

· acquire blockiert, bis eine Genehmigung verfügbar ist und erniedrigt anschließend Anzahl der Genehmigungen um

· release erhöht Anzahl der Genehmigungen um 1

CyclicBarrier

· Synchronisiert Gruppe von n Fäden

· Fäden rufen await()-Methode der Barriere auf, die so lange blockiert, bis n Fäden warten

· Danach wird den Fäden erlaubt, ihre Ausführung fortzusetzen

· Beim Vektor Beispiel statt join ansetzbar

· Zyklische Barriere, weil sie in Schleifen wiederholt benutzt werden kann, ohne das es zu Überholungen kommt

Parallele Algorithmen

· Matrix-Vektor Multiplikation

· Matrix-Matrix Multiplikation

· Numerische Integration

· Bewertung von parallelen Algorithmen

· Dateiindizierung

Matrix-Vektor Fall A*b=y

Zeilenweise Aufteilung der Matrix A hat Vorteile gegenüber den spaltenweisen Aufteilung:

· Keine Schreibkonflikte bzgl. Y

· Cache-Effekt: Eine Cachezeile speichert Elemente mit aufsteigenden Adressen, und holt damit einen Teil einer Zeile auf einmal. Elemente einer Spalte sind dagegen in unterschiedlicher Cachezeilen

· Mit Zeilenweise keine Synchronisation von y erforderlich, mit spaltenweise schon.

Blockweise Aufteilung:

· Wenn Speicherzellen nur von einem Prozessor gleichzeitig gelesen werden können, muss der Zugriff koordiniert werden

Matrix-Matrix

· ijk, kij, ikj Algorithmen

· Systolischer Algorithmus

· Cannon-Algorithmus



Поделиться:


Последнее изменение этой страницы: 2017-01-19; просмотров: 143; Нарушение авторского права страницы; Мы поможем в написании вашей работы!

infopedia.su Все материалы представленные на сайте исключительно с целью ознакомления читателями и не преследуют коммерческих целей или нарушение авторских прав. Обратная связь - 52.91.255.225 (0.041 с.)