SlideShare ist ein Scribd-Unternehmen logo
Parallelisierung des Growing Cells Meshing
                Algorithmus

         Marcus Riemer, Florian Held

                Fachhochschule Wedel
         University of Applied Sciences Wedel


                     WS 2011
Parallelisierung des Smart Growing Cells Algorithmus


Notwendige Kenntnisse
   Programmierung & Elementare Datenstrukturen
        Vorlesungen
             Programmstrukturen 2 ausreichend
             Algorithmen und Datenstrukturen in C optimal
        Inhaltlich
             B¨ume, Listen und Dynamische Arrays
              a


Hilfreiche Kenntnisse
     Grundlagen Threadprogrammierung
        Vorlesung Prozessprogrammierung
        Inhaltlich
             Elementare Probleme (Erzeuger-Verbraucher, Leser-Schreiber)
             Thread, Mutex, Lock
Gliederung


Einf¨hrung
    u

Surface Reconstruction
   Allgemein
   Smart Growing Cells

Parallelisierung
   Bedingungen
   1. Ansatz: Bottom Up
   2. Ansatz: Erzeuger-Verbraucher
   Parallele Datenstrukturen
   Gegen¨berstellung
           u

Ergebnis
Surface Reconstruction




             Reales Objekt ⇒ Punktwolke ⇒ Mesh
Surface Reconstruction - Dimensionen
Surface Reconstruction - Dimensionen




    Etwa 9.826.000 Punkte als Eingabe
Surface Reconstruction - Dimensionen




    Etwa 9.826.000 Punkte als Eingabe
    Etwa 4.000.000 Dreiecke im Ergebnismesh
Surface Reconstruction - Dimensionen




    Etwa 9.826.000 Punkte als Eingabe
    Etwa 4.000.000 Dreiecke im Ergebnismesh
    132 Minuten bei 2,6 Ghz und 8 Gb RAM
Surface Reconstruction - Dimensionen




    Etwa 9.826.000 Punkte als Eingabe
    Etwa 4.000.000 Dreiecke im Ergebnismesh
    132 Minuten bei 2,6 Ghz und 8 Gb RAM
Eines der eher kleineren Modelel, die zu verarbeiten sind ...
Gliederung


Einf¨hrung
    u

Surface Reconstruction
   Allgemein
   Smart Growing Cells

Parallelisierung
   Bedingungen
   1. Ansatz: Bottom Up
   2. Ansatz: Erzeuger-Verbraucher
   Parallele Datenstrukturen
   Gegen¨berstellung
           u

Ergebnis
Surface Reconstruction - Probleme




               M¨glichkeiten der Verkn¨pfung
                o                     u
Surface Reconstruction - Probleme




               M¨glichkeiten der Verkn¨pfung
                o                     u
Surface Reconstruction - Probleme




               M¨glichkeiten der Verkn¨pfung
                o                     u
Surface Reconstruction




                Zu analysierende Punktwolke
Smart Growing Cells Algorithmus




                   Ausgangssituation
Smart Growing Cells Algorithmus




                Gebildetes Neuronales Netz
Smart Growing Cells Algorithmus - Schritte




                    (a) Move / Gl¨tten
                                 a
Smart Growing Cells Algorithmus - Schritte




                    (a) Move / Gl¨tten
                                 a




                         (b) Split
Smart Growing Cells Algorithmus - Schritte




                    (a) Move / Gl¨tten
                                 a




                         (b) Split




                       (c) Collapse
Smart Growing Cells Algorithmus - Ablauf




                Ablauf einer Rekonstruktion
Gliederung


Einf¨hrung
    u

Surface Reconstruction
   Allgemein
   Smart Growing Cells

Parallelisierung
   Bedingungen
   1. Ansatz: Bottom Up
   2. Ansatz: Erzeuger-Verbraucher
   Parallele Datenstrukturen
   Gegen¨berstellung
           u

Ergebnis
Parallelisierung

 Eignung des Verfahrens f¨r die Parallelisierung
                         u
     Robust gegen¨ber Ver¨nderungen der Reihenfolge und
                  u        a
     Verteilung der Operationen
Parallelisierung

 Eignung des Verfahrens f¨r die Parallelisierung
                         u
     Robust gegen¨ber Ver¨nderungen der Reihenfolge und
                  u        a
     Verteilung der Operationen
     Gr¨ße des Meshes ∼ Anzahl m¨glicher Threads
       o                            o
Parallelisierung

 Eignung des Verfahrens f¨r die Parallelisierung
                         u
     Robust gegen¨ber Ver¨nderungen der Reihenfolge und
                  u        a
     Verteilung der Operationen
     Gr¨ße des Meshes ∼ Anzahl m¨glicher Threads
       o                            o
Parallelisierung

 Eignung des Verfahrens f¨r die Parallelisierung
                         u
     Robust gegen¨ber Ver¨nderungen der Reihenfolge und
                  u        a
     Verteilung der Operationen
     Gr¨ße des Meshes ∼ Anzahl m¨glicher Threads
       o                            o
Parallelisierung

 Eignung des Verfahrens f¨r die Parallelisierung
                         u
     Robust gegen¨ber Ver¨nderungen der Reihenfolge und
                  u        a
     Verteilung der Operationen
     Gr¨ße des Meshes ∼ Anzahl m¨glicher Threads
       o                            o
 Theorie: Standardprozess einfach mehrfach ausf¨hren
                                                 u
Parallelisierung

 Eignung der Implementierung f¨r die Parallelisierung
                              u
Parallelisierung

 Eignung der Implementierung f¨r die Parallelisierung
                              u
     Hochgradig optimiert
Parallelisierung

 Eignung der Implementierung f¨r die Parallelisierung
                              u
     Hochgradig optimiert
     Nutzung von vorreserviertem Speicher
Parallelisierung

 Eignung der Implementierung f¨r die Parallelisierung
                              u
     Hochgradig optimiert
     Nutzung von vorreserviertem Speicher
     Eigene grundlegende Datenstrukturen
Parallelisierung

 Eignung der Implementierung f¨r die Parallelisierung
                              u
     Hochgradig optimiert
     Nutzung von vorreserviertem Speicher
     Eigene grundlegende Datenstrukturen


                                          Mes h




                                                           Pool

                       Octree       S ignalCounterTree   Faces
                                                         Vertices
                                                          Edges




                      PooledLis t




                         Pool
Pool

Der Pool
       ist ein vorreservierter Speicherbereich in Form eines Arrays
Pool

Der Pool
       ist ein vorreservierter Speicherbereich in Form eines Arrays
       ... dessen Gr¨ße zu Anfang bekannt sein muss
                    o
Pool

Der Pool
       ist ein vorreservierter Speicherbereich in Form eines Arrays
       ... dessen Gr¨ße zu Anfang bekannt sein muss
                    o
       ... sich jedoch ggf. noch vergr¨ßern l¨sst.
                                      o      a
Pool

Der Pool
       ist ein vorreservierter Speicherbereich in Form eines Arrays
       ... dessen Gr¨ße zu Anfang bekannt sein muss
                    o
       ... sich jedoch ggf. noch vergr¨ßern l¨sst.
                                      o      a
       stellt einen einfache aber schnelle Speicherverwaltung dar
Pool

Der Pool
       ist ein vorreservierter Speicherbereich in Form eines Arrays
       ... dessen Gr¨ße zu Anfang bekannt sein muss
                    o
       ... sich jedoch ggf. noch vergr¨ßern l¨sst.
                                      o      a
       stellt einen einfache aber schnelle Speicherverwaltung dar
       ersetzt Aufrufe von new und delete
Pool als Speicherwaltung

Statt:
 Foo * c r e a t e F o o ( ) {
             return new Foo();
 }

 void d e l e t e F o o ( Foo * f o o ) {
             delete foo;
 }
Pool als Speicherwaltung

Statt:
 Foo * c r e a t e F o o ( ) {
             return new Foo();
 }

 void d e l e t e F o o ( Foo * f o o ) {
             delete foo;
 }


... haben wir:
 Foo * c r e a t e F o o ( Pool< Foo > * p o o l ) {
             return pool-¿newValue();
 }

 void d e l e t e F o o ( Pool< Foo > * p o o l , Foo * f o o ) {
             pool-¿deleteValue( foo );
 }
PooledList

Die PooledList
    ist eine Listenimplementierung auf Basis des Pools
PooledList

Die PooledList
    ist eine Listenimplementierung auf Basis des Pools
    ...mit konstanter Zugriffszeit auf die Elemente.
PooledList

Die PooledList
    ist eine Listenimplementierung auf Basis des Pools
    ...mit konstanter Zugriffszeit auf die Elemente.




Implementierungsdetail: Pool und PooledList werden sowohl f¨ru
die Speicherverwaltung als auch als Datenstruktur verwendet.
Octree

    Zur Erinnerung: Move-Schritt ben¨tigt Bezugspunkt
                                    o
Octree

    Zur Erinnerung: Move-Schritt ben¨tigt Bezugspunkt
                                    o
    Problem: Finde den n¨chstgelegenen Nachbarn zu einem
                        a
    gegebenen Punkt p
Octree

    Zur Erinnerung: Move-Schritt ben¨tigt Bezugspunkt
                                    o
    Problem: Finde den n¨chstgelegenen Nachbarn zu einem
                        a
    gegebenen Punkt p
    L¨sung mit r¨umlicher Datenstruktur:
     o          a
     1. Unterteile den Raum an den x-, y - und z-Achsen in 8
        Unterr¨ume
              a
Octree

    Zur Erinnerung: Move-Schritt ben¨tigt Bezugspunkt
                                    o
    Problem: Finde den n¨chstgelegenen Nachbarn zu einem
                        a
    gegebenen Punkt p
    L¨sung mit r¨umlicher Datenstruktur:
     o          a
     1. Unterteile den Raum an den x-, y - und z-Achsen in 8
        Unterr¨ume
              a
     2. Befinden sich in einem Unterraum u mehr als k Punkte, so
        wiederhole 1. f¨r u
                       u
Octree

    Zur Erinnerung: Move-Schritt ben¨tigt Bezugspunkt
                                    o
    Problem: Finde den n¨chstgelegenen Nachbarn zu einem
                        a
    gegebenen Punkt p
    L¨sung mit r¨umlicher Datenstruktur:
     o          a
     1. Unterteile den Raum an den x-, y - und z-Achsen in 8
        Unterr¨ume
              a
     2. Befinden sich in einem Unterraum u mehr als k Punkte, so
        wiederhole 1. f¨r u
                       u
Octree
Octree




    Ergebnis: Effiziente Suche des n¨chsten Nachbarn in einer
                                  a
    globalen Datenstruktur
SignalCounterTree

    Zur Erinnerung: Split-Schritt ben¨tigt Gewinner
                                     o
SignalCounterTree

    Zur Erinnerung: Split-Schritt ben¨tigt Gewinner
                                     o
    Move-Schritt erh¨ht “Signalz¨hler” des Vertex’
                    o           a
SignalCounterTree

    Zur Erinnerung: Split-Schritt ben¨tigt Gewinner
                                     o
    Move-Schritt erh¨ht “Signalz¨hler” des Vertex’
                    o           a
    Vertex mit h¨chstem Signalz¨hler ist Gewinner
                o              a
SignalCounterTree

    Zur Erinnerung: Split-Schritt ben¨tigt Gewinner
                                     o
    Move-Schritt erh¨ht “Signalz¨hler” des Vertex’
                    o           a
    Vertex mit h¨chstem Signalz¨hler ist Gewinner
                o              a




    Verwaltung der Signalz¨hler in Form des SignalCounterTrees
                          a
    implementiert:
        Rot-Schwarz-Baum
        globale Datenstruktur
Zusammenfassung der vorhandenen Datenstrukturen

    Octree ist global
Zusammenfassung der vorhandenen Datenstrukturen

    Octree ist global
    SCTree (SignalCounterTree) ist global
Zusammenfassung der vorhandenen Datenstrukturen

    Octree ist global
    SCTree (SignalCounterTree) ist global
    Pool und PooledList werden als Datenstruktur verwendet
    → potentiell global
Zusammenfassung der vorhandenen Datenstrukturen

    Octree ist global
    SCTree (SignalCounterTree) ist global
    Pool und PooledList werden als Datenstruktur verwendet
    → potentiell global




Parallelisierung des Verfahrens = Parallelisierung der
Implementierung
Parallelisierung - Bottom Up

Grundlegende Idee
    Sperren aller grundlegenden Datenstrukturen
    Keine Anpassung des Algorithmus
    → Parallelisierung ”abschaltbar”


                                        Mes h




                                                         Pool

                     Octree       S ignalCounterTree   Faces
                                                       Vertices
                                                        Edges




                    PooledLis t




                       Pool
Parallelisierung - Bottom Up

Grundlegender Ansatz:
    Lesende Zugriffe parallel zulassen
    Schreibende Zugriffe exklusiv ausf¨hren
                                     u
Parallelisierung - Bottom Up

Grundlegender Ansatz:
    Lesende Zugriffe parallel zulassen
    Schreibende Zugriffe exklusiv ausf¨hren
                                     u



→ Typisches Leser-Schreiber Problem
Parallelisierung - Bottom Up

Grundlegender Ansatz:
    Lesende Zugriffe parallel zulassen
    Schreibende Zugriffe exklusiv ausf¨hren
                                     u



→ Typisches Leser-Schreiber Problem



L¨sung mit Boost.Thread
 o
    SharedLockable modelliert geteilten und exklusiven Zugriff
    Sicherer: Sperrobjekte benutzen
Parallelisierung - Bottom Up


 class T h r e a d s a f e
 {
 public :
          int h a s I n d e x ( int i n d e x ) {
                        SharedLock lock( mMutex );
                        return ( mValueCount <= i n d e x ) ;
            }

            int s e t V a l u e S a f e ( int i n d e x , int v a l u e ) {
                        ExclusiveLock lock( mMutex );
                       if ( h a s I n d e x ( i n d e x ) ) {
                                    mValues [ i n d e x ] = v a l u e ;
                                    return ( true )
                       }

                        return ( false ) ;
            }
 };
Parallelisierung - Bottom Up - Problemfall Rekursion

 class T h r e a d s a f e
 {
 public :
          int h a s I n d e x ( int i n d e x ) {
                           SharedLock lock( mMutex );
                          return ( h a s I n d e x I m p l ( i n d e x ) ) ;
             }

             int s e t V a l u e S a f e ( int i n d e x , int v a l u e ) {
                           ExclusiveLock lock( mMutex );
                          return ( s e t V a l u e S a f e I m p l ( i n d e x , v a l u e ) ) ;
             }

 private :
             int h a s I n d e x I m p l ( int i n d e x ) {
                         return ( mValueCount <= i n d e x ) ;
             }
             int s e t V a l u e S a f e I m p l ( int i n d e x , int v a l u e ) {
                         /* U s e s h a s I n d e x I m p l ( ) i n i m p l e m e n t a t i o n */
             }
 };
Parallelisierung - Bottom Up - Problemfall Rekursion

                                                                   public uint indexOf(Val*)

                                                                                                                                                        private uint indexOfImpl(Val*)
                                                               public void resizeFastArray(uint)
                                                                                                                                                                                             private uint deletionsToAddress(uint)   private uint biggerDeletionIndex(uint, uint, uint)

                                                                                                            private void resizeFastArrayImpl(uint)
                 public void increaseFastArray(float)      private void increaseFastArrayImpl(float)
                                                                                                                                                     private Val* getValImpl(const uint)      private uint deletionsToIndex(uint)               private void sortDeleted()

                                                                                                                public Val* getVal(const uint)

                                                                                                                                                                                                private Val* getNewValImpl()
                      public Val* getNewVal()


      Usercode        public void delVal(Val*)                   private void delValImpl(Val*)               private void increaseDeletedStack()     private void resizeDeletedStack(uint)


                                                                     public void freeArray()
                                                                                                                private void freeArrayImpl()
                   public void initFastArray(uint)
                                                         private void initFastArrayImpl(uint, uint, bool)

                 public void initFastArray(uint, uint)


                     public bool isDeleted(Val*)
                                                                                                                        isDeletedImpl
                      public bool isValid(Val*)                  private bool isValidImpl(Val*)
Parallelisierung - Bottom Up - Problemfall Rekursion

                                                                                                                                          public uint indexOf(Val*)

                                                                                                                                                                                                                                                                                         private uint indexOfImpl(Val*)
                                                                                                                                     public void resizeFastArray(uint)
                                                                                                                                                                                                                                                                                                                                       private uint deletionsToAddress(uint)                                private uint biggerDeletionIndex(uint, uint, uint)

                                                                                                                                                                                                                 private void resizeFastArrayImpl(uint)
                                                          public void increaseFastArray(float)                                   private void increaseFastArrayImpl(float)
                                                                                                                                                                                                                                                                                      private Val* getValImpl(const uint)                   private uint deletionsToIndex(uint)                                               private void sortDeleted()

                                                                                                                                                                                                                       public Val* getVal(const uint)

                                                                                                                                                                                                                                                                                                                                              private Val* getNewValImpl()
                                                                  public Val* getNewVal()


      Usercode                                                    public void delVal(Val*)                                              private void delValImpl(Val*)                                              private void increaseDeletedStack()                                private void resizeDeletedStack(uint)


                                                                                                                                           public void freeArray()
                                                                                                                                                                                                                       private void freeArrayImpl()
                                                              public void initFastArray(uint)
                                                                                                                             private void initFastArrayImpl(uint, uint, bool)

                                                           public void initFastArray(uint, uint)


                                                                public bool isDeleted(Val*)
                                                                                                                                                                                                                               isDeletedImpl
                                                                  public bool isValid(Val*)                                             private bool isValidImpl(Val*)




                                                                                                                                                                                      getNearestPoint




                                                addPt                                                                     reinsert                                                   getNearestXPoints




                      initialAddPt            addPtCore                                                                                                                            getNearestXPointsCore




                    initialAddPtCore           minimisationCascadeAlternativ      getAverageDepth         constructor                      getPointsInQRadius          removeVec        checkNode




      addPtToNode        correctBox    createNode                  notMoreThenXChildren                                 removeVecCore         getPointsInQRadiusCore         getAverageListLength          getCenter                  getEdgeBoxSize      deletePotentialEmptyNodes        getNumOfNodes   ptInBox   getNumOfPts      freePointsInRadiusList   freeXPointsList   getListForNearestPointsSearch      resizeInRadiusSList       addToList




              NodeWriter                                                                            NodeReader                                                                                                                                  Reader                                                                             Writer                                                                        ListReader      ListWriter
Parallelisierung - Bottom Up - Problemefall Rekursion


Erster Ansatz:
     ¨
     Offentliche Methoden setzen eine Sperre und delegieren die
     eigentliche Arbeit an eine private Methode
    Private Methoden rufen niemals ¨ffentliche Methoden auf
                                   o
Parallelisierung - Bottom Up - Problemefall Rekursion


Erster Ansatz:
     ¨
     Offentliche Methoden setzen eine Sperre und delegieren die
     eigentliche Arbeit an eine private Methode
   Private Methoden rufen niemals ¨ffentliche Methoden auf
                                  o
                ¨
→ Umfangreiche Anderungen am Code
Parallelisierung - Bottom Up - Problemefall Rekursion


Erster Ansatz:
     ¨
     Offentliche Methoden setzen eine Sperre und delegieren die
     eigentliche Arbeit an eine private Methode
    Private Methoden rufen niemals ¨ffentliche Methoden auf
                                   o
                 ¨
→ Umfangreiche Anderungen am Code
→ Inkonsistente Zust¨nde durch zu kurze Sperren
                     a
Parallelisierung - Bottom Up - Problemefall Rekursion


Erster Ansatz:
     ¨
     Offentliche Methoden setzen eine Sperre und delegieren die
     eigentliche Arbeit an eine private Methode
    Private Methoden rufen niemals ¨ffentliche Methoden auf
                                   o
                 ¨
→ Umfangreiche Anderungen am Code
→ Inkonsistente Zust¨nde durch zu kurze Sperren
                     a


Zweiter Ansatz:
    Rekursive Mutexe verwenden
Parallelisierung - Bottom Up - Problemefall Rekursion


Erster Ansatz:
     ¨
     Offentliche Methoden setzen eine Sperre und delegieren die
     eigentliche Arbeit an eine private Methode
    Private Methoden rufen niemals ¨ffentliche Methoden auf
                                   o
                 ¨
→ Umfangreiche Anderungen am Code
→ Inkonsistente Zust¨nde durch zu kurze Sperren
                     a


Zweiter Ansatz:
    Rekursive Mutexe verwenden
→ Noch langsamer
Parallelisierung - Bottom Up - Problemefall Rekursion


Erster Ansatz:
     ¨
     Offentliche Methoden setzen eine Sperre und delegieren die
     eigentliche Arbeit an eine private Methode
    Private Methoden rufen niemals ¨ffentliche Methoden auf
                                   o
                 ¨
→ Umfangreiche Anderungen am Code
→ Inkonsistente Zust¨nde durch zu kurze Sperren
                     a


Zweiter Ansatz:
    Rekursive Mutexe verwenden
→ Noch langsamer
→ Inkonsistente Zust¨nde durch zu kurze Sperren
                    a
Parallelisierung - Bottom Up - Probleme allgemein




    H¨ufiges Sperren und Entsperren von Mutexen
     a
    Effektives Sperren balancierter B¨ume ein offenes Problem
                                    a
Parallelisierung - Bottom Up - Probleme allgemein




    H¨ufiges Sperren und Entsperren von Mutexen
     a
    Effektives Sperren balancierter B¨ume ein offenes Problem
                                    a




→ Lock auch langsam wenn keine Kollisionen auftreten
Parallelisierung - Bottom Up - Probleme allgemein




    H¨ufiges Sperren und Entsperren von Mutexen
     a
    Effektives Sperren balancierter B¨ume ein offenes Problem
                                    a




→ Lock auch langsam wenn keine Kollisionen auftreten
→ Kein Verhindern unerwarteter destruktiver Operationen
Parallelisierung - Erzeuger-Verbraucher

Problem: Versucht Parallelismus implizit zu nutzen
Parallelisierung - Erzeuger-Verbraucher

Problem: Versucht Parallelismus implizit zu nutzen


L¨sung: M¨glichkeiten des SGC Algorithmus ausnutzen
 o       o
    ”Sperrbereiche” in denen ein Thread exklusiv arbeitet
    → Potenziell sehr viel weniger Sperrvorg¨nge n¨tig
                                            a     o
Parallelisierung - Erzeuger-Verbraucher

Problem: Versucht Parallelismus implizit zu nutzen


L¨sung: M¨glichkeiten des SGC Algorithmus ausnutzen
 o       o
    ”Sperrbereiche” in denen ein Thread exklusiv arbeitet
    → Potenziell sehr viel weniger Sperrvorg¨nge n¨tig
                                            a     o


Grundlegende Idee
    Einen Thread f¨r Verwaltungsaufgaben
                  u
    n weitere Threads f¨r die ”eigentliche Arbeit”
                       u
Parallelisierung - Erzeuger-Verbraucher

Problem: Versucht Parallelismus implizit zu nutzen


L¨sung: M¨glichkeiten des SGC Algorithmus ausnutzen
 o       o
    ”Sperrbereiche” in denen ein Thread exklusiv arbeitet
    → Potenziell sehr viel weniger Sperrvorg¨nge n¨tig
                                            a     o


Grundlegende Idee
    Einen Thread f¨r Verwaltungsaufgaben
                  u
    n weitere Threads f¨r die ”eigentliche Arbeit”
                       u


→ Klassisches Erzeuger-Verbraucher Problem
Parallelisierung - Worker, Jobs und WorkerManager



                       WorkerManager
                                                            Boos t::Thread
                 + getNextAvailableJob() : Job




                    S patialLocker                               Worker
        + lock( vec3d pos , float radius ) : bool
             + unlock( vec3d pos ) : bool                 + execute() : void




                                                                               Job
                                                   WorkingS et
                                                                      + is S tatic() : bool
Parallelisierung - getNextAvailableJob()

    Grundidee: WorkerManager-Thread erzeugt Jobs auf ”Vorrat”
    → getNextAvailableJob() nur noch eine pop Operation


         Pop   Move   Move   Split   Move   Move   Move   Split   Collapse   ...   Push
Parallelisierung - getNextAvailableJob()

    Grundidee: WorkerManager-Thread erzeugt Jobs auf ”Vorrat”
    → getNextAvailableJob() nur noch eine pop Operation


         Pop    Move   Move   Split   Move   Move   Move   Split   Collapse   ...   Push




    Erzeugte Jobs sperren Bereich bis zu ihrer Finalisierung
    → Wahrscheinlichkeit der erfolgreichen Joberstellung sinkt
Parallelisierung - getNextAvailableJob()

    Grundidee: WorkerManager-Thread erzeugt Jobs auf ”Vorrat”
    → getNextAvailableJob() nur noch eine pop Operation


         Pop    Move   Move   Split   Move   Move   Move   Split   Collapse   ...   Push




    Erzeugte Jobs sperren Bereich bis zu ihrer Finalisierung
    → Wahrscheinlichkeit der erfolgreichen Joberstellung sinkt



    Optimierung f¨r kleine Meshes notwendig
                 u
    → Nur ein Thread
    → Erstellt Jobs ”On Demand”
Parallelisierung - Auswahl der Strategie

Umschaltung auf “große” Strategie erfolgt zu sp¨t
                                               a
    M¨glichkeit der Parallelit¨t wird nicht ausgenutzt
     o                        a
Parallelisierung - Auswahl der Strategie

Umschaltung auf “große” Strategie erfolgt zu sp¨t
                                               a
    M¨glichkeit der Parallelit¨t wird nicht ausgenutzt
     o                        a




Umschaltung auf “große” Strategie erfolgt zu fr¨h
                                               u
    Es ist gar kein Platz f¨r mehrere Threads
                           u
    → Overhead durch r¨umliche Sperrungen
                          a
Parallele Datenstrukturen

    Erkenntnis: Vorhandene globale Datenstrukturen ungeeignet
    f¨r Parallelisierung
     u
Parallele Datenstrukturen

    Erkenntnis: Vorhandene globale Datenstrukturen ungeeignet
    f¨r Parallelisierung
     u
    Aufgabe: Implementierung neuer Datenstrukturen f¨r
                                                     u
        Pool und PooledList
        Octree
        SCTree
Paralleler Octree

    Idee: Einf¨hrung einer Ebene, auf der gelockt wird
              u
Paralleler Octree

    Idee: Einf¨hrung einer Ebene, auf der gelockt wird
              u
        oberhalb der Ebene sind generell nur lesende Zugriffe erlaubt
Paralleler Octree

    Idee: Einf¨hrung einer Ebene, auf der gelockt wird
              u
        oberhalb der Ebene sind generell nur lesende Zugriffe erlaubt
        unterhalb der Ebene darf sich in jedem Unterbaum nur ein
        Thread befinden
Paralleler Octree

    Idee: Einf¨hrung einer Ebene, auf der gelockt wird
              u
        oberhalb der Ebene sind generell nur lesende Zugriffe erlaubt
        unterhalb der Ebene darf sich in jedem Unterbaum nur ein
        Thread befinden
Aus SCTree wird SCMap

   Zur Erinnerung: SCTree ist ein RBTree (→ balanciert!)
Aus SCTree wird SCMap

   Zur Erinnerung: SCTree ist ein RBTree (→ balanciert!)
   Notwendigkeit: komplett neue Datenstruktur
Aus SCTree wird SCMap

   Zur Erinnerung: SCTree ist ein RBTree (→ balanciert!)
   Notwendigkeit: komplett neue Datenstruktur
   Wir wissen: Gr¨ßtes Element wird am h¨ufigsten gesucht
                 o                      a
Aus SCTree wird SCMap

   Zur Erinnerung: SCTree ist ein RBTree (→ balanciert!)
   Notwendigkeit: komplett neue Datenstruktur
   Wir wissen: Gr¨ßtes Element wird am h¨ufigsten gesucht
                 o                      a
   Außerdem haben Beobachtungen ergeben:
Aus SCTree wird SCMap

   Zur Erinnerung: SCTree ist ein RBTree (→ balanciert!)
   Notwendigkeit: komplett neue Datenstruktur
   Wir wissen: Gr¨ßtes Element wird am h¨ufigsten gesucht
                 o                      a
   Außerdem haben Beobachtungen ergeben:
       Es gibt obere und untere Schranken f¨r Signale
                                           u
Aus SCTree wird SCMap

   Zur Erinnerung: SCTree ist ein RBTree (→ balanciert!)
   Notwendigkeit: komplett neue Datenstruktur
   Wir wissen: Gr¨ßtes Element wird am h¨ufigsten gesucht
                 o                      a
   Außerdem haben Beobachtungen ergeben:
       Es gibt obere und untere Schranken f¨r Signale
                                           u
       Signale sind ann¨hernd normalverteilt
                        a
Aus SCTree wird SCMap
Aus SCTree wird SCMap




Implementierung als geordnete Hashtabelle:
    Hashfunktion ist Normalverteilungsapproximation
Aus SCTree wird SCMap

Implementierung als geordnete Hashtabelle:
Aus SCTree wird SCMap

Implementierung als geordnete Hashtabelle:
    Hashfunktion ist Normalverteilungsapproximation
Aus SCTree wird SCMap

Implementierung als geordnete Hashtabelle:
    Hashfunktion ist Normalverteilungsapproximation
    Lage des gr¨ßten Elements kann g¨nstig mitgespeichert
               o                    u
    werden (→ echte konstante Zugriffszeit)
Aus SCTree wird SCMap

Implementierung als geordnete Hashtabelle:
    Hashfunktion ist Normalverteilungsapproximation
    Lage des gr¨ßten Elements kann g¨nstig mitgespeichert
               o                    u
    werden (→ echte konstante Zugriffszeit)
    Anzahl der Buckets frei w¨hlbar
                             a
Aus SCTree wird SCMap

Implementierung als geordnete Hashtabelle:
    Hashfunktion ist Normalverteilungsapproximation
    Lage des gr¨ßten Elements kann g¨nstig mitgespeichert
               o                    u
    werden (→ echte konstante Zugriffszeit)
    Anzahl der Buckets frei w¨hlbar
                             a
    Durchschnittliche Gr¨ße der Buckets frei w¨hlbar
                        o                     a
→ sehr flexibel
Parallelisierung - SpatialLocker

 Veranschaulichung der Sperrbereiche:
Parallelisierung - SpatialLocker

    Aufgaben des SpatialLockers:
Parallelisierung - SpatialLocker

    Aufgaben des SpatialLockers:
        Verwaltung aller gesperrten Bereiche
Parallelisierung - SpatialLocker

    Aufgaben des SpatialLockers:
        Verwaltung aller gesperrten Bereiche
        Pr¨ft, ob in einem Bereich gearbeitet werden darf
          u
Parallelisierung - SpatialLocker

    Aufgaben des SpatialLockers:
        Verwaltung aller gesperrten Bereiche
        Pr¨ft, ob in einem Bereich gearbeitet werden darf
          u


    Allgemeine Problematik ist die Gr¨ße des Sperrbereichs:
                                     o
Parallelisierung - SpatialLocker

    Aufgaben des SpatialLockers:
        Verwaltung aller gesperrten Bereiche
        Pr¨ft, ob in einem Bereich gearbeitet werden darf
          u


    Allgemeine Problematik ist die Gr¨ße des Sperrbereichs:
                                     o
        Bei zu großen Sperrbereichen: Ablehnung neuer Jobs (→
        Programmstillstand)
Parallelisierung - SpatialLocker

    Aufgaben des SpatialLockers:
        Verwaltung aller gesperrten Bereiche
        Pr¨ft, ob in einem Bereich gearbeitet werden darf
          u


    Allgemeine Problematik ist die Gr¨ße des Sperrbereichs:
                                     o
        Bei zu großen Sperrbereichen: Ablehnung neuer Jobs (→
        Programmstillstand)
                                                   ¨
        Bei zu kleinen Sperrbereichen: Unerwartete Uberschneidungen
        (→ Programmabsturz)
Parallelisierung - SpatialLocker

     Aufgaben des SpatialLockers:
         Verwaltung aller gesperrten Bereiche
         Pr¨ft, ob in einem Bereich gearbeitet werden darf
           u


     Allgemeine Problematik ist die Gr¨ße des Sperrbereichs:
                                      o
         Bei zu großen Sperrbereichen: Ablehnung neuer Jobs (→
         Programmstillstand)
                                                    ¨
         Bei zu kleinen Sperrbereichen: Unerwartete Uberschneidungen
         (→ Programmabsturz)


     Ist der Sperrbereich gut gew¨hlt, so treten keine unerwarteten
                                 a
     ¨
     Uberschneidungen auf
  → parallelen Zugriffe auf das selbe Pool-/PooledList-Objekt
 sind ausgeschlossen
Parallelisierung - Gegen¨berstellung
                        u




               Parallelisierung im Straßenverkehr
Parallelisierung - Gegen¨berstellung
                        u




          Parallelisierung im Straßenverkehr - Bottom Up
Parallelisierung - Gegen¨berstellung
                        u




         Parallelisierung im Straßenverkehr - Sperrbereiche
Gliederung


Einf¨hrung
    u

Surface Reconstruction
   Allgemein
   Smart Growing Cells

Parallelisierung
   Bedingungen
   1. Ansatz: Bottom Up
   2. Ansatz: Erzeuger-Verbraucher
   Parallele Datenstrukturen
   Gegen¨berstellung
           u

Ergebnis
Ergebnis - Zeitgewinn
Ergebnis - Zeitgewinn




    Ausf¨hrungszeit = 50% SmallMeshStrategy + 50%
        u
    LargeMeshStrategy
Ergebnis - Zeitgewinn




    Ausf¨hrungszeit = 50% SmallMeshStrategy + 50%
        u
    LargeMeshStrategy
     10% Zeitgewinn mit jedem zus¨tzlichen Kern
                                 a
Ergebnis - Parametrisierung


 Parameter                    signifikant
Ergebnis - Parametrisierung


 Parameter                           signifikant



 Vermeidung von gesperrten Mutexen
Ergebnis - Parametrisierung


 Parameter                           signifikant



 Vermeidung von gesperrten Mutexen      nein
Ergebnis - Parametrisierung


 Parameter                           signifikant



 Vermeidung von gesperrten Mutexen      nein

 Sperrebene beim Octree
Ergebnis - Parametrisierung


 Parameter                           signifikant



 Vermeidung von gesperrten Mutexen      nein

 Sperrebene beim Octree                 nein
Ergebnis - Parametrisierung


 Parameter                           signifikant



 Vermeidung von gesperrten Mutexen      nein

 Sperrebene beim Octree                 nein

 Bucketgr¨ße der SCMap
         o
Ergebnis - Parametrisierung


 Parameter                           signifikant



 Vermeidung von gesperrten Mutexen      nein

 Sperrebene beim Octree                 nein

 Bucketgr¨ße der SCMap
         o                              nein
Ergebnis - Parametrisierung


 Parameter                           signifikant



 Vermeidung von gesperrten Mutexen      nein

 Sperrebene beim Octree                 nein

 Bucketgr¨ße der SCMap
         o                              nein

 Max. Anzahl an vorerstellten Jobs
Ergebnis - Parametrisierung


 Parameter                           signifikant



 Vermeidung von gesperrten Mutexen      nein

 Sperrebene beim Octree                 nein

 Bucketgr¨ße der SCMap
         o                              nein

 Max. Anzahl an vorerstellten Jobs      nein
Ergebnis - Parametrisierung


 Parameter                                          signifikant



 Vermeidung von gesperrten Mutexen                     nein

 Sperrebene beim Octree                                nein

 Bucketgr¨ße der SCMap
         o                                             nein

 Max. Anzahl an vorerstellten Jobs                     nein

 Zeitpunkt der Umstellung auf Large-Mesh-Strategy
Ergebnis - Parametrisierung


 Parameter                                          signifikant



 Vermeidung von gesperrten Mutexen                     nein

 Sperrebene beim Octree                                nein

 Bucketgr¨ße der SCMap
         o                                             nein

 Max. Anzahl an vorerstellten Jobs                     nein

 Zeitpunkt der Umstellung auf Large-Mesh-Strategy       ja
Ergebnis - Parametrisierung


 Parameter                                          signifikant



 Vermeidung von gesperrten Mutexen                     nein

 Sperrebene beim Octree                                nein

 Bucketgr¨ße der SCMap
         o                                             nein

 Max. Anzahl an vorerstellten Jobs                     nein

 Zeitpunkt der Umstellung auf Large-Mesh-Strategy       ja

 Anteil verworfene Jobs
Ergebnis - Parametrisierung


 Parameter                                          signifikant



 Vermeidung von gesperrten Mutexen                     nein

 Sperrebene beim Octree                                nein

 Bucketgr¨ße der SCMap
         o                                             nein

 Max. Anzahl an vorerstellten Jobs                     nein

 Zeitpunkt der Umstellung auf Large-Mesh-Strategy       ja

 Anteil verworfene Jobs                                 ja
Ergebnis - Fazit

    Implizite Parallelisierung geht mit C++ nicht
    → funktionale Programmiersprachen sind hier eindeutig
    vorteilhaft
Ergebnis - Fazit

    Implizite Parallelisierung geht mit C++ nicht
    → funktionale Programmiersprachen sind hier eindeutig
    vorteilhaft
    Nebenl¨ufige Anwendungen ben¨tigen saubere Struktur
          a                      o
    → neben Geschwindigkeit auch Strukturierung
Ergebnis - Fazit

    Implizite Parallelisierung geht mit C++ nicht
    → funktionale Programmiersprachen sind hier eindeutig
    vorteilhaft
    Nebenl¨ufige Anwendungen ben¨tigen saubere Struktur
          a                      o
    → neben Geschwindigkeit auch Strukturierung
    Parallelisierung sollte von Beginn an Teil des Softwaredesigns
    sein
Ergebnis - Fazit

Bei Datenstrukturen gilt:
Ergebnis - Fazit

Bei Datenstrukturen gilt:
    Probabilistische Datenstrukturen sind vorteilhaft
    → z.B. Hashmaps oder Skiplisten anstelle von balancierten
    B¨umen
     a
Ergebnis - Fazit

Bei Datenstrukturen gilt:
    Probabilistische Datenstrukturen sind vorteilhaft
    → z.B. Hashmaps oder Skiplisten anstelle von balancierten
    B¨umen
     a
    Modell und Implementierung k¨nnen stark voneinander
                                o
    abweichen
Ergebnis - Fazit

Bei Datenstrukturen gilt:
    Probabilistische Datenstrukturen sind vorteilhaft
    → z.B. Hashmaps oder Skiplisten anstelle von balancierten
    B¨umen
     a
    Modell und Implementierung k¨nnen stark voneinander
                                o
    abweichen
    Dar¨berhinaus sollte die Ebene des Locks frei w¨hlbar sein
       u                                           a
Ergebnis - Offene Fragen




    Optimale Parametrisierung noch unbekannt
Ergebnis - Offene Fragen




    Optimale Parametrisierung noch unbekannt
    Effektive Strategie zur Joberstellung noch nicht gefunden
    → Jobs werden erstellt und teilweise direkt wieder verworfen

Weitere ähnliche Inhalte

Andere mochten auch

Pre 1
Pre 1Pre 1
Protocolo en una mesa
Protocolo en una mesaProtocolo en una mesa
Protocolo en una mesa
Rosa María Cajade Rodríguez
 
Conferencia: Mitos y Creencias Infundadas en la Historia de la Ciencia- 27 de...
Conferencia: Mitos y Creencias Infundadas en la Historia de la Ciencia- 27 de...Conferencia: Mitos y Creencias Infundadas en la Historia de la Ciencia- 27 de...
Conferencia: Mitos y Creencias Infundadas en la Historia de la Ciencia- 27 de...
SOCIEDAD JULIO GARAVITO
 
Expose by fooooooooooooooooooooo
Expose    by foooooooooooooooooooooExpose    by fooooooooooooooooooooo
Expose by fooooooooooooooooooooo
Fouad Issam
 
Articles 93033 archivo-powerpoint_0 - copia
Articles 93033 archivo-powerpoint_0 - copiaArticles 93033 archivo-powerpoint_0 - copia
Articles 93033 archivo-powerpoint_0 - copia
Victor Saldivia Cardoch
 
Estadistica1
Estadistica1Estadistica1
Estadistica1
Lucila Paz
 
Primera reunion seminario
Primera reunion seminarioPrimera reunion seminario
Primera reunion seminario
ultrapegaso
 
Travailler ensemble autour du PLU intercommunal : les préalables à la démarche
Travailler ensemble autour du PLU intercommunal : les préalables à la démarcheTravailler ensemble autour du PLU intercommunal : les préalables à la démarche
Travailler ensemble autour du PLU intercommunal : les préalables à la démarche
CAUE85
 
Práctica de word
Práctica de wordPráctica de word
Práctica de word
cecimcparra
 
La météo
La météoLa météo
La météo
Yeray888
 
Atelier de bioflexibilité 10 juin 2013
Atelier de bioflexibilité 10 juin 2013Atelier de bioflexibilité 10 juin 2013
Atelier de bioflexibilité 10 juin 2013
Jose Mario Horenstein
 
Presentación de la Charla de la SJG del 26 de Mayo 2012: Bioética de la Explo...
Presentación de la Charla de la SJG del 26 de Mayo 2012: Bioética de la Explo...Presentación de la Charla de la SJG del 26 de Mayo 2012: Bioética de la Explo...
Presentación de la Charla de la SJG del 26 de Mayo 2012: Bioética de la Explo...
SOCIEDAD JULIO GARAVITO
 
Code mondial d'etique di tourisme fra
Code mondial d'etique di tourisme fraCode mondial d'etique di tourisme fra
Code mondial d'etique di tourisme fra
SAFE HOST PROJECT
 
RPS et Action Syndicale SNPTES_CSEE_Madrid_Oct_2013
RPS et Action Syndicale SNPTES_CSEE_Madrid_Oct_2013RPS et Action Syndicale SNPTES_CSEE_Madrid_Oct_2013
RPS et Action Syndicale SNPTES_CSEE_Madrid_Oct_2013
Helene Hemet
 
Bde Esm-agic
Bde Esm-agicBde Esm-agic
Bde Esm-agic
Bde Esm-agic
 
Contratro electronico
Contratro electronicoContratro electronico
Contratro electronico
checho23123
 
Breve resumen
Breve resumenBreve resumen
Breve resumen
Gonzalo Grau Bassas
 
Pf ma doloresortega-2122010-bis
Pf ma doloresortega-2122010-bisPf ma doloresortega-2122010-bis
Pf ma doloresortega-2122010-bis
ultrapegaso
 
Presentación Pagoa 110225
Presentación Pagoa 110225Presentación Pagoa 110225
Presentación Pagoa 110225
NASF
 

Andere mochten auch (19)

Pre 1
Pre 1Pre 1
Pre 1
 
Protocolo en una mesa
Protocolo en una mesaProtocolo en una mesa
Protocolo en una mesa
 
Conferencia: Mitos y Creencias Infundadas en la Historia de la Ciencia- 27 de...
Conferencia: Mitos y Creencias Infundadas en la Historia de la Ciencia- 27 de...Conferencia: Mitos y Creencias Infundadas en la Historia de la Ciencia- 27 de...
Conferencia: Mitos y Creencias Infundadas en la Historia de la Ciencia- 27 de...
 
Expose by fooooooooooooooooooooo
Expose    by foooooooooooooooooooooExpose    by fooooooooooooooooooooo
Expose by fooooooooooooooooooooo
 
Articles 93033 archivo-powerpoint_0 - copia
Articles 93033 archivo-powerpoint_0 - copiaArticles 93033 archivo-powerpoint_0 - copia
Articles 93033 archivo-powerpoint_0 - copia
 
Estadistica1
Estadistica1Estadistica1
Estadistica1
 
Primera reunion seminario
Primera reunion seminarioPrimera reunion seminario
Primera reunion seminario
 
Travailler ensemble autour du PLU intercommunal : les préalables à la démarche
Travailler ensemble autour du PLU intercommunal : les préalables à la démarcheTravailler ensemble autour du PLU intercommunal : les préalables à la démarche
Travailler ensemble autour du PLU intercommunal : les préalables à la démarche
 
Práctica de word
Práctica de wordPráctica de word
Práctica de word
 
La météo
La météoLa météo
La météo
 
Atelier de bioflexibilité 10 juin 2013
Atelier de bioflexibilité 10 juin 2013Atelier de bioflexibilité 10 juin 2013
Atelier de bioflexibilité 10 juin 2013
 
Presentación de la Charla de la SJG del 26 de Mayo 2012: Bioética de la Explo...
Presentación de la Charla de la SJG del 26 de Mayo 2012: Bioética de la Explo...Presentación de la Charla de la SJG del 26 de Mayo 2012: Bioética de la Explo...
Presentación de la Charla de la SJG del 26 de Mayo 2012: Bioética de la Explo...
 
Code mondial d'etique di tourisme fra
Code mondial d'etique di tourisme fraCode mondial d'etique di tourisme fra
Code mondial d'etique di tourisme fra
 
RPS et Action Syndicale SNPTES_CSEE_Madrid_Oct_2013
RPS et Action Syndicale SNPTES_CSEE_Madrid_Oct_2013RPS et Action Syndicale SNPTES_CSEE_Madrid_Oct_2013
RPS et Action Syndicale SNPTES_CSEE_Madrid_Oct_2013
 
Bde Esm-agic
Bde Esm-agicBde Esm-agic
Bde Esm-agic
 
Contratro electronico
Contratro electronicoContratro electronico
Contratro electronico
 
Breve resumen
Breve resumenBreve resumen
Breve resumen
 
Pf ma doloresortega-2122010-bis
Pf ma doloresortega-2122010-bisPf ma doloresortega-2122010-bis
Pf ma doloresortega-2122010-bis
 
Presentación Pagoa 110225
Presentación Pagoa 110225Presentación Pagoa 110225
Presentación Pagoa 110225
 

Parallelisierung des Growing Cells Meshing Algorithmus

  • 1. Parallelisierung des Growing Cells Meshing Algorithmus Marcus Riemer, Florian Held Fachhochschule Wedel University of Applied Sciences Wedel WS 2011
  • 2. Parallelisierung des Smart Growing Cells Algorithmus Notwendige Kenntnisse Programmierung & Elementare Datenstrukturen Vorlesungen Programmstrukturen 2 ausreichend Algorithmen und Datenstrukturen in C optimal Inhaltlich B¨ume, Listen und Dynamische Arrays a Hilfreiche Kenntnisse Grundlagen Threadprogrammierung Vorlesung Prozessprogrammierung Inhaltlich Elementare Probleme (Erzeuger-Verbraucher, Leser-Schreiber) Thread, Mutex, Lock
  • 3. Gliederung Einf¨hrung u Surface Reconstruction Allgemein Smart Growing Cells Parallelisierung Bedingungen 1. Ansatz: Bottom Up 2. Ansatz: Erzeuger-Verbraucher Parallele Datenstrukturen Gegen¨berstellung u Ergebnis
  • 4. Surface Reconstruction Reales Objekt ⇒ Punktwolke ⇒ Mesh
  • 6. Surface Reconstruction - Dimensionen Etwa 9.826.000 Punkte als Eingabe
  • 7. Surface Reconstruction - Dimensionen Etwa 9.826.000 Punkte als Eingabe Etwa 4.000.000 Dreiecke im Ergebnismesh
  • 8. Surface Reconstruction - Dimensionen Etwa 9.826.000 Punkte als Eingabe Etwa 4.000.000 Dreiecke im Ergebnismesh 132 Minuten bei 2,6 Ghz und 8 Gb RAM
  • 9. Surface Reconstruction - Dimensionen Etwa 9.826.000 Punkte als Eingabe Etwa 4.000.000 Dreiecke im Ergebnismesh 132 Minuten bei 2,6 Ghz und 8 Gb RAM Eines der eher kleineren Modelel, die zu verarbeiten sind ...
  • 10. Gliederung Einf¨hrung u Surface Reconstruction Allgemein Smart Growing Cells Parallelisierung Bedingungen 1. Ansatz: Bottom Up 2. Ansatz: Erzeuger-Verbraucher Parallele Datenstrukturen Gegen¨berstellung u Ergebnis
  • 11. Surface Reconstruction - Probleme M¨glichkeiten der Verkn¨pfung o u
  • 12. Surface Reconstruction - Probleme M¨glichkeiten der Verkn¨pfung o u
  • 13. Surface Reconstruction - Probleme M¨glichkeiten der Verkn¨pfung o u
  • 14. Surface Reconstruction Zu analysierende Punktwolke
  • 15. Smart Growing Cells Algorithmus Ausgangssituation
  • 16. Smart Growing Cells Algorithmus Gebildetes Neuronales Netz
  • 17. Smart Growing Cells Algorithmus - Schritte (a) Move / Gl¨tten a
  • 18. Smart Growing Cells Algorithmus - Schritte (a) Move / Gl¨tten a (b) Split
  • 19. Smart Growing Cells Algorithmus - Schritte (a) Move / Gl¨tten a (b) Split (c) Collapse
  • 20. Smart Growing Cells Algorithmus - Ablauf Ablauf einer Rekonstruktion
  • 21. Gliederung Einf¨hrung u Surface Reconstruction Allgemein Smart Growing Cells Parallelisierung Bedingungen 1. Ansatz: Bottom Up 2. Ansatz: Erzeuger-Verbraucher Parallele Datenstrukturen Gegen¨berstellung u Ergebnis
  • 22. Parallelisierung Eignung des Verfahrens f¨r die Parallelisierung u Robust gegen¨ber Ver¨nderungen der Reihenfolge und u a Verteilung der Operationen
  • 23. Parallelisierung Eignung des Verfahrens f¨r die Parallelisierung u Robust gegen¨ber Ver¨nderungen der Reihenfolge und u a Verteilung der Operationen Gr¨ße des Meshes ∼ Anzahl m¨glicher Threads o o
  • 24. Parallelisierung Eignung des Verfahrens f¨r die Parallelisierung u Robust gegen¨ber Ver¨nderungen der Reihenfolge und u a Verteilung der Operationen Gr¨ße des Meshes ∼ Anzahl m¨glicher Threads o o
  • 25. Parallelisierung Eignung des Verfahrens f¨r die Parallelisierung u Robust gegen¨ber Ver¨nderungen der Reihenfolge und u a Verteilung der Operationen Gr¨ße des Meshes ∼ Anzahl m¨glicher Threads o o
  • 26. Parallelisierung Eignung des Verfahrens f¨r die Parallelisierung u Robust gegen¨ber Ver¨nderungen der Reihenfolge und u a Verteilung der Operationen Gr¨ße des Meshes ∼ Anzahl m¨glicher Threads o o Theorie: Standardprozess einfach mehrfach ausf¨hren u
  • 27. Parallelisierung Eignung der Implementierung f¨r die Parallelisierung u
  • 28. Parallelisierung Eignung der Implementierung f¨r die Parallelisierung u Hochgradig optimiert
  • 29. Parallelisierung Eignung der Implementierung f¨r die Parallelisierung u Hochgradig optimiert Nutzung von vorreserviertem Speicher
  • 30. Parallelisierung Eignung der Implementierung f¨r die Parallelisierung u Hochgradig optimiert Nutzung von vorreserviertem Speicher Eigene grundlegende Datenstrukturen
  • 31. Parallelisierung Eignung der Implementierung f¨r die Parallelisierung u Hochgradig optimiert Nutzung von vorreserviertem Speicher Eigene grundlegende Datenstrukturen Mes h Pool Octree S ignalCounterTree Faces Vertices Edges PooledLis t Pool
  • 32. Pool Der Pool ist ein vorreservierter Speicherbereich in Form eines Arrays
  • 33. Pool Der Pool ist ein vorreservierter Speicherbereich in Form eines Arrays ... dessen Gr¨ße zu Anfang bekannt sein muss o
  • 34. Pool Der Pool ist ein vorreservierter Speicherbereich in Form eines Arrays ... dessen Gr¨ße zu Anfang bekannt sein muss o ... sich jedoch ggf. noch vergr¨ßern l¨sst. o a
  • 35. Pool Der Pool ist ein vorreservierter Speicherbereich in Form eines Arrays ... dessen Gr¨ße zu Anfang bekannt sein muss o ... sich jedoch ggf. noch vergr¨ßern l¨sst. o a stellt einen einfache aber schnelle Speicherverwaltung dar
  • 36. Pool Der Pool ist ein vorreservierter Speicherbereich in Form eines Arrays ... dessen Gr¨ße zu Anfang bekannt sein muss o ... sich jedoch ggf. noch vergr¨ßern l¨sst. o a stellt einen einfache aber schnelle Speicherverwaltung dar ersetzt Aufrufe von new und delete
  • 37. Pool als Speicherwaltung Statt: Foo * c r e a t e F o o ( ) { return new Foo(); } void d e l e t e F o o ( Foo * f o o ) { delete foo; }
  • 38. Pool als Speicherwaltung Statt: Foo * c r e a t e F o o ( ) { return new Foo(); } void d e l e t e F o o ( Foo * f o o ) { delete foo; } ... haben wir: Foo * c r e a t e F o o ( Pool< Foo > * p o o l ) { return pool-¿newValue(); } void d e l e t e F o o ( Pool< Foo > * p o o l , Foo * f o o ) { pool-¿deleteValue( foo ); }
  • 39. PooledList Die PooledList ist eine Listenimplementierung auf Basis des Pools
  • 40. PooledList Die PooledList ist eine Listenimplementierung auf Basis des Pools ...mit konstanter Zugriffszeit auf die Elemente.
  • 41. PooledList Die PooledList ist eine Listenimplementierung auf Basis des Pools ...mit konstanter Zugriffszeit auf die Elemente. Implementierungsdetail: Pool und PooledList werden sowohl f¨ru die Speicherverwaltung als auch als Datenstruktur verwendet.
  • 42. Octree Zur Erinnerung: Move-Schritt ben¨tigt Bezugspunkt o
  • 43. Octree Zur Erinnerung: Move-Schritt ben¨tigt Bezugspunkt o Problem: Finde den n¨chstgelegenen Nachbarn zu einem a gegebenen Punkt p
  • 44. Octree Zur Erinnerung: Move-Schritt ben¨tigt Bezugspunkt o Problem: Finde den n¨chstgelegenen Nachbarn zu einem a gegebenen Punkt p L¨sung mit r¨umlicher Datenstruktur: o a 1. Unterteile den Raum an den x-, y - und z-Achsen in 8 Unterr¨ume a
  • 45. Octree Zur Erinnerung: Move-Schritt ben¨tigt Bezugspunkt o Problem: Finde den n¨chstgelegenen Nachbarn zu einem a gegebenen Punkt p L¨sung mit r¨umlicher Datenstruktur: o a 1. Unterteile den Raum an den x-, y - und z-Achsen in 8 Unterr¨ume a 2. Befinden sich in einem Unterraum u mehr als k Punkte, so wiederhole 1. f¨r u u
  • 46. Octree Zur Erinnerung: Move-Schritt ben¨tigt Bezugspunkt o Problem: Finde den n¨chstgelegenen Nachbarn zu einem a gegebenen Punkt p L¨sung mit r¨umlicher Datenstruktur: o a 1. Unterteile den Raum an den x-, y - und z-Achsen in 8 Unterr¨ume a 2. Befinden sich in einem Unterraum u mehr als k Punkte, so wiederhole 1. f¨r u u
  • 48. Octree Ergebnis: Effiziente Suche des n¨chsten Nachbarn in einer a globalen Datenstruktur
  • 49. SignalCounterTree Zur Erinnerung: Split-Schritt ben¨tigt Gewinner o
  • 50. SignalCounterTree Zur Erinnerung: Split-Schritt ben¨tigt Gewinner o Move-Schritt erh¨ht “Signalz¨hler” des Vertex’ o a
  • 51. SignalCounterTree Zur Erinnerung: Split-Schritt ben¨tigt Gewinner o Move-Schritt erh¨ht “Signalz¨hler” des Vertex’ o a Vertex mit h¨chstem Signalz¨hler ist Gewinner o a
  • 52. SignalCounterTree Zur Erinnerung: Split-Schritt ben¨tigt Gewinner o Move-Schritt erh¨ht “Signalz¨hler” des Vertex’ o a Vertex mit h¨chstem Signalz¨hler ist Gewinner o a Verwaltung der Signalz¨hler in Form des SignalCounterTrees a implementiert: Rot-Schwarz-Baum globale Datenstruktur
  • 53. Zusammenfassung der vorhandenen Datenstrukturen Octree ist global
  • 54. Zusammenfassung der vorhandenen Datenstrukturen Octree ist global SCTree (SignalCounterTree) ist global
  • 55. Zusammenfassung der vorhandenen Datenstrukturen Octree ist global SCTree (SignalCounterTree) ist global Pool und PooledList werden als Datenstruktur verwendet → potentiell global
  • 56. Zusammenfassung der vorhandenen Datenstrukturen Octree ist global SCTree (SignalCounterTree) ist global Pool und PooledList werden als Datenstruktur verwendet → potentiell global Parallelisierung des Verfahrens = Parallelisierung der Implementierung
  • 57. Parallelisierung - Bottom Up Grundlegende Idee Sperren aller grundlegenden Datenstrukturen Keine Anpassung des Algorithmus → Parallelisierung ”abschaltbar” Mes h Pool Octree S ignalCounterTree Faces Vertices Edges PooledLis t Pool
  • 58. Parallelisierung - Bottom Up Grundlegender Ansatz: Lesende Zugriffe parallel zulassen Schreibende Zugriffe exklusiv ausf¨hren u
  • 59. Parallelisierung - Bottom Up Grundlegender Ansatz: Lesende Zugriffe parallel zulassen Schreibende Zugriffe exklusiv ausf¨hren u → Typisches Leser-Schreiber Problem
  • 60. Parallelisierung - Bottom Up Grundlegender Ansatz: Lesende Zugriffe parallel zulassen Schreibende Zugriffe exklusiv ausf¨hren u → Typisches Leser-Schreiber Problem L¨sung mit Boost.Thread o SharedLockable modelliert geteilten und exklusiven Zugriff Sicherer: Sperrobjekte benutzen
  • 61. Parallelisierung - Bottom Up class T h r e a d s a f e { public : int h a s I n d e x ( int i n d e x ) { SharedLock lock( mMutex ); return ( mValueCount <= i n d e x ) ; } int s e t V a l u e S a f e ( int i n d e x , int v a l u e ) { ExclusiveLock lock( mMutex ); if ( h a s I n d e x ( i n d e x ) ) { mValues [ i n d e x ] = v a l u e ; return ( true ) } return ( false ) ; } };
  • 62. Parallelisierung - Bottom Up - Problemfall Rekursion class T h r e a d s a f e { public : int h a s I n d e x ( int i n d e x ) { SharedLock lock( mMutex ); return ( h a s I n d e x I m p l ( i n d e x ) ) ; } int s e t V a l u e S a f e ( int i n d e x , int v a l u e ) { ExclusiveLock lock( mMutex ); return ( s e t V a l u e S a f e I m p l ( i n d e x , v a l u e ) ) ; } private : int h a s I n d e x I m p l ( int i n d e x ) { return ( mValueCount <= i n d e x ) ; } int s e t V a l u e S a f e I m p l ( int i n d e x , int v a l u e ) { /* U s e s h a s I n d e x I m p l ( ) i n i m p l e m e n t a t i o n */ } };
  • 63. Parallelisierung - Bottom Up - Problemfall Rekursion public uint indexOf(Val*) private uint indexOfImpl(Val*) public void resizeFastArray(uint) private uint deletionsToAddress(uint) private uint biggerDeletionIndex(uint, uint, uint) private void resizeFastArrayImpl(uint) public void increaseFastArray(float) private void increaseFastArrayImpl(float) private Val* getValImpl(const uint) private uint deletionsToIndex(uint) private void sortDeleted() public Val* getVal(const uint) private Val* getNewValImpl() public Val* getNewVal() Usercode public void delVal(Val*) private void delValImpl(Val*) private void increaseDeletedStack() private void resizeDeletedStack(uint) public void freeArray() private void freeArrayImpl() public void initFastArray(uint) private void initFastArrayImpl(uint, uint, bool) public void initFastArray(uint, uint) public bool isDeleted(Val*) isDeletedImpl public bool isValid(Val*) private bool isValidImpl(Val*)
  • 64. Parallelisierung - Bottom Up - Problemfall Rekursion public uint indexOf(Val*) private uint indexOfImpl(Val*) public void resizeFastArray(uint) private uint deletionsToAddress(uint) private uint biggerDeletionIndex(uint, uint, uint) private void resizeFastArrayImpl(uint) public void increaseFastArray(float) private void increaseFastArrayImpl(float) private Val* getValImpl(const uint) private uint deletionsToIndex(uint) private void sortDeleted() public Val* getVal(const uint) private Val* getNewValImpl() public Val* getNewVal() Usercode public void delVal(Val*) private void delValImpl(Val*) private void increaseDeletedStack() private void resizeDeletedStack(uint) public void freeArray() private void freeArrayImpl() public void initFastArray(uint) private void initFastArrayImpl(uint, uint, bool) public void initFastArray(uint, uint) public bool isDeleted(Val*) isDeletedImpl public bool isValid(Val*) private bool isValidImpl(Val*) getNearestPoint addPt reinsert getNearestXPoints initialAddPt addPtCore getNearestXPointsCore initialAddPtCore minimisationCascadeAlternativ getAverageDepth constructor getPointsInQRadius removeVec checkNode addPtToNode correctBox createNode notMoreThenXChildren removeVecCore getPointsInQRadiusCore getAverageListLength getCenter getEdgeBoxSize deletePotentialEmptyNodes getNumOfNodes ptInBox getNumOfPts freePointsInRadiusList freeXPointsList getListForNearestPointsSearch resizeInRadiusSList addToList NodeWriter NodeReader Reader Writer ListReader ListWriter
  • 65. Parallelisierung - Bottom Up - Problemefall Rekursion Erster Ansatz: ¨ Offentliche Methoden setzen eine Sperre und delegieren die eigentliche Arbeit an eine private Methode Private Methoden rufen niemals ¨ffentliche Methoden auf o
  • 66. Parallelisierung - Bottom Up - Problemefall Rekursion Erster Ansatz: ¨ Offentliche Methoden setzen eine Sperre und delegieren die eigentliche Arbeit an eine private Methode Private Methoden rufen niemals ¨ffentliche Methoden auf o ¨ → Umfangreiche Anderungen am Code
  • 67. Parallelisierung - Bottom Up - Problemefall Rekursion Erster Ansatz: ¨ Offentliche Methoden setzen eine Sperre und delegieren die eigentliche Arbeit an eine private Methode Private Methoden rufen niemals ¨ffentliche Methoden auf o ¨ → Umfangreiche Anderungen am Code → Inkonsistente Zust¨nde durch zu kurze Sperren a
  • 68. Parallelisierung - Bottom Up - Problemefall Rekursion Erster Ansatz: ¨ Offentliche Methoden setzen eine Sperre und delegieren die eigentliche Arbeit an eine private Methode Private Methoden rufen niemals ¨ffentliche Methoden auf o ¨ → Umfangreiche Anderungen am Code → Inkonsistente Zust¨nde durch zu kurze Sperren a Zweiter Ansatz: Rekursive Mutexe verwenden
  • 69. Parallelisierung - Bottom Up - Problemefall Rekursion Erster Ansatz: ¨ Offentliche Methoden setzen eine Sperre und delegieren die eigentliche Arbeit an eine private Methode Private Methoden rufen niemals ¨ffentliche Methoden auf o ¨ → Umfangreiche Anderungen am Code → Inkonsistente Zust¨nde durch zu kurze Sperren a Zweiter Ansatz: Rekursive Mutexe verwenden → Noch langsamer
  • 70. Parallelisierung - Bottom Up - Problemefall Rekursion Erster Ansatz: ¨ Offentliche Methoden setzen eine Sperre und delegieren die eigentliche Arbeit an eine private Methode Private Methoden rufen niemals ¨ffentliche Methoden auf o ¨ → Umfangreiche Anderungen am Code → Inkonsistente Zust¨nde durch zu kurze Sperren a Zweiter Ansatz: Rekursive Mutexe verwenden → Noch langsamer → Inkonsistente Zust¨nde durch zu kurze Sperren a
  • 71. Parallelisierung - Bottom Up - Probleme allgemein H¨ufiges Sperren und Entsperren von Mutexen a Effektives Sperren balancierter B¨ume ein offenes Problem a
  • 72. Parallelisierung - Bottom Up - Probleme allgemein H¨ufiges Sperren und Entsperren von Mutexen a Effektives Sperren balancierter B¨ume ein offenes Problem a → Lock auch langsam wenn keine Kollisionen auftreten
  • 73. Parallelisierung - Bottom Up - Probleme allgemein H¨ufiges Sperren und Entsperren von Mutexen a Effektives Sperren balancierter B¨ume ein offenes Problem a → Lock auch langsam wenn keine Kollisionen auftreten → Kein Verhindern unerwarteter destruktiver Operationen
  • 74. Parallelisierung - Erzeuger-Verbraucher Problem: Versucht Parallelismus implizit zu nutzen
  • 75. Parallelisierung - Erzeuger-Verbraucher Problem: Versucht Parallelismus implizit zu nutzen L¨sung: M¨glichkeiten des SGC Algorithmus ausnutzen o o ”Sperrbereiche” in denen ein Thread exklusiv arbeitet → Potenziell sehr viel weniger Sperrvorg¨nge n¨tig a o
  • 76. Parallelisierung - Erzeuger-Verbraucher Problem: Versucht Parallelismus implizit zu nutzen L¨sung: M¨glichkeiten des SGC Algorithmus ausnutzen o o ”Sperrbereiche” in denen ein Thread exklusiv arbeitet → Potenziell sehr viel weniger Sperrvorg¨nge n¨tig a o Grundlegende Idee Einen Thread f¨r Verwaltungsaufgaben u n weitere Threads f¨r die ”eigentliche Arbeit” u
  • 77. Parallelisierung - Erzeuger-Verbraucher Problem: Versucht Parallelismus implizit zu nutzen L¨sung: M¨glichkeiten des SGC Algorithmus ausnutzen o o ”Sperrbereiche” in denen ein Thread exklusiv arbeitet → Potenziell sehr viel weniger Sperrvorg¨nge n¨tig a o Grundlegende Idee Einen Thread f¨r Verwaltungsaufgaben u n weitere Threads f¨r die ”eigentliche Arbeit” u → Klassisches Erzeuger-Verbraucher Problem
  • 78. Parallelisierung - Worker, Jobs und WorkerManager WorkerManager Boos t::Thread + getNextAvailableJob() : Job S patialLocker Worker + lock( vec3d pos , float radius ) : bool + unlock( vec3d pos ) : bool + execute() : void Job WorkingS et + is S tatic() : bool
  • 79. Parallelisierung - getNextAvailableJob() Grundidee: WorkerManager-Thread erzeugt Jobs auf ”Vorrat” → getNextAvailableJob() nur noch eine pop Operation Pop Move Move Split Move Move Move Split Collapse ... Push
  • 80. Parallelisierung - getNextAvailableJob() Grundidee: WorkerManager-Thread erzeugt Jobs auf ”Vorrat” → getNextAvailableJob() nur noch eine pop Operation Pop Move Move Split Move Move Move Split Collapse ... Push Erzeugte Jobs sperren Bereich bis zu ihrer Finalisierung → Wahrscheinlichkeit der erfolgreichen Joberstellung sinkt
  • 81. Parallelisierung - getNextAvailableJob() Grundidee: WorkerManager-Thread erzeugt Jobs auf ”Vorrat” → getNextAvailableJob() nur noch eine pop Operation Pop Move Move Split Move Move Move Split Collapse ... Push Erzeugte Jobs sperren Bereich bis zu ihrer Finalisierung → Wahrscheinlichkeit der erfolgreichen Joberstellung sinkt Optimierung f¨r kleine Meshes notwendig u → Nur ein Thread → Erstellt Jobs ”On Demand”
  • 82. Parallelisierung - Auswahl der Strategie Umschaltung auf “große” Strategie erfolgt zu sp¨t a M¨glichkeit der Parallelit¨t wird nicht ausgenutzt o a
  • 83. Parallelisierung - Auswahl der Strategie Umschaltung auf “große” Strategie erfolgt zu sp¨t a M¨glichkeit der Parallelit¨t wird nicht ausgenutzt o a Umschaltung auf “große” Strategie erfolgt zu fr¨h u Es ist gar kein Platz f¨r mehrere Threads u → Overhead durch r¨umliche Sperrungen a
  • 84. Parallele Datenstrukturen Erkenntnis: Vorhandene globale Datenstrukturen ungeeignet f¨r Parallelisierung u
  • 85. Parallele Datenstrukturen Erkenntnis: Vorhandene globale Datenstrukturen ungeeignet f¨r Parallelisierung u Aufgabe: Implementierung neuer Datenstrukturen f¨r u Pool und PooledList Octree SCTree
  • 86. Paralleler Octree Idee: Einf¨hrung einer Ebene, auf der gelockt wird u
  • 87. Paralleler Octree Idee: Einf¨hrung einer Ebene, auf der gelockt wird u oberhalb der Ebene sind generell nur lesende Zugriffe erlaubt
  • 88. Paralleler Octree Idee: Einf¨hrung einer Ebene, auf der gelockt wird u oberhalb der Ebene sind generell nur lesende Zugriffe erlaubt unterhalb der Ebene darf sich in jedem Unterbaum nur ein Thread befinden
  • 89. Paralleler Octree Idee: Einf¨hrung einer Ebene, auf der gelockt wird u oberhalb der Ebene sind generell nur lesende Zugriffe erlaubt unterhalb der Ebene darf sich in jedem Unterbaum nur ein Thread befinden
  • 90. Aus SCTree wird SCMap Zur Erinnerung: SCTree ist ein RBTree (→ balanciert!)
  • 91. Aus SCTree wird SCMap Zur Erinnerung: SCTree ist ein RBTree (→ balanciert!) Notwendigkeit: komplett neue Datenstruktur
  • 92. Aus SCTree wird SCMap Zur Erinnerung: SCTree ist ein RBTree (→ balanciert!) Notwendigkeit: komplett neue Datenstruktur Wir wissen: Gr¨ßtes Element wird am h¨ufigsten gesucht o a
  • 93. Aus SCTree wird SCMap Zur Erinnerung: SCTree ist ein RBTree (→ balanciert!) Notwendigkeit: komplett neue Datenstruktur Wir wissen: Gr¨ßtes Element wird am h¨ufigsten gesucht o a Außerdem haben Beobachtungen ergeben:
  • 94. Aus SCTree wird SCMap Zur Erinnerung: SCTree ist ein RBTree (→ balanciert!) Notwendigkeit: komplett neue Datenstruktur Wir wissen: Gr¨ßtes Element wird am h¨ufigsten gesucht o a Außerdem haben Beobachtungen ergeben: Es gibt obere und untere Schranken f¨r Signale u
  • 95. Aus SCTree wird SCMap Zur Erinnerung: SCTree ist ein RBTree (→ balanciert!) Notwendigkeit: komplett neue Datenstruktur Wir wissen: Gr¨ßtes Element wird am h¨ufigsten gesucht o a Außerdem haben Beobachtungen ergeben: Es gibt obere und untere Schranken f¨r Signale u Signale sind ann¨hernd normalverteilt a
  • 97. Aus SCTree wird SCMap Implementierung als geordnete Hashtabelle: Hashfunktion ist Normalverteilungsapproximation
  • 98. Aus SCTree wird SCMap Implementierung als geordnete Hashtabelle:
  • 99. Aus SCTree wird SCMap Implementierung als geordnete Hashtabelle: Hashfunktion ist Normalverteilungsapproximation
  • 100. Aus SCTree wird SCMap Implementierung als geordnete Hashtabelle: Hashfunktion ist Normalverteilungsapproximation Lage des gr¨ßten Elements kann g¨nstig mitgespeichert o u werden (→ echte konstante Zugriffszeit)
  • 101. Aus SCTree wird SCMap Implementierung als geordnete Hashtabelle: Hashfunktion ist Normalverteilungsapproximation Lage des gr¨ßten Elements kann g¨nstig mitgespeichert o u werden (→ echte konstante Zugriffszeit) Anzahl der Buckets frei w¨hlbar a
  • 102. Aus SCTree wird SCMap Implementierung als geordnete Hashtabelle: Hashfunktion ist Normalverteilungsapproximation Lage des gr¨ßten Elements kann g¨nstig mitgespeichert o u werden (→ echte konstante Zugriffszeit) Anzahl der Buckets frei w¨hlbar a Durchschnittliche Gr¨ße der Buckets frei w¨hlbar o a → sehr flexibel
  • 103. Parallelisierung - SpatialLocker Veranschaulichung der Sperrbereiche:
  • 104. Parallelisierung - SpatialLocker Aufgaben des SpatialLockers:
  • 105. Parallelisierung - SpatialLocker Aufgaben des SpatialLockers: Verwaltung aller gesperrten Bereiche
  • 106. Parallelisierung - SpatialLocker Aufgaben des SpatialLockers: Verwaltung aller gesperrten Bereiche Pr¨ft, ob in einem Bereich gearbeitet werden darf u
  • 107. Parallelisierung - SpatialLocker Aufgaben des SpatialLockers: Verwaltung aller gesperrten Bereiche Pr¨ft, ob in einem Bereich gearbeitet werden darf u Allgemeine Problematik ist die Gr¨ße des Sperrbereichs: o
  • 108. Parallelisierung - SpatialLocker Aufgaben des SpatialLockers: Verwaltung aller gesperrten Bereiche Pr¨ft, ob in einem Bereich gearbeitet werden darf u Allgemeine Problematik ist die Gr¨ße des Sperrbereichs: o Bei zu großen Sperrbereichen: Ablehnung neuer Jobs (→ Programmstillstand)
  • 109. Parallelisierung - SpatialLocker Aufgaben des SpatialLockers: Verwaltung aller gesperrten Bereiche Pr¨ft, ob in einem Bereich gearbeitet werden darf u Allgemeine Problematik ist die Gr¨ße des Sperrbereichs: o Bei zu großen Sperrbereichen: Ablehnung neuer Jobs (→ Programmstillstand) ¨ Bei zu kleinen Sperrbereichen: Unerwartete Uberschneidungen (→ Programmabsturz)
  • 110. Parallelisierung - SpatialLocker Aufgaben des SpatialLockers: Verwaltung aller gesperrten Bereiche Pr¨ft, ob in einem Bereich gearbeitet werden darf u Allgemeine Problematik ist die Gr¨ße des Sperrbereichs: o Bei zu großen Sperrbereichen: Ablehnung neuer Jobs (→ Programmstillstand) ¨ Bei zu kleinen Sperrbereichen: Unerwartete Uberschneidungen (→ Programmabsturz) Ist der Sperrbereich gut gew¨hlt, so treten keine unerwarteten a ¨ Uberschneidungen auf → parallelen Zugriffe auf das selbe Pool-/PooledList-Objekt sind ausgeschlossen
  • 111. Parallelisierung - Gegen¨berstellung u Parallelisierung im Straßenverkehr
  • 112. Parallelisierung - Gegen¨berstellung u Parallelisierung im Straßenverkehr - Bottom Up
  • 113. Parallelisierung - Gegen¨berstellung u Parallelisierung im Straßenverkehr - Sperrbereiche
  • 114. Gliederung Einf¨hrung u Surface Reconstruction Allgemein Smart Growing Cells Parallelisierung Bedingungen 1. Ansatz: Bottom Up 2. Ansatz: Erzeuger-Verbraucher Parallele Datenstrukturen Gegen¨berstellung u Ergebnis
  • 116. Ergebnis - Zeitgewinn Ausf¨hrungszeit = 50% SmallMeshStrategy + 50% u LargeMeshStrategy
  • 117. Ergebnis - Zeitgewinn Ausf¨hrungszeit = 50% SmallMeshStrategy + 50% u LargeMeshStrategy 10% Zeitgewinn mit jedem zus¨tzlichen Kern a
  • 118. Ergebnis - Parametrisierung Parameter signifikant
  • 119. Ergebnis - Parametrisierung Parameter signifikant Vermeidung von gesperrten Mutexen
  • 120. Ergebnis - Parametrisierung Parameter signifikant Vermeidung von gesperrten Mutexen nein
  • 121. Ergebnis - Parametrisierung Parameter signifikant Vermeidung von gesperrten Mutexen nein Sperrebene beim Octree
  • 122. Ergebnis - Parametrisierung Parameter signifikant Vermeidung von gesperrten Mutexen nein Sperrebene beim Octree nein
  • 123. Ergebnis - Parametrisierung Parameter signifikant Vermeidung von gesperrten Mutexen nein Sperrebene beim Octree nein Bucketgr¨ße der SCMap o
  • 124. Ergebnis - Parametrisierung Parameter signifikant Vermeidung von gesperrten Mutexen nein Sperrebene beim Octree nein Bucketgr¨ße der SCMap o nein
  • 125. Ergebnis - Parametrisierung Parameter signifikant Vermeidung von gesperrten Mutexen nein Sperrebene beim Octree nein Bucketgr¨ße der SCMap o nein Max. Anzahl an vorerstellten Jobs
  • 126. Ergebnis - Parametrisierung Parameter signifikant Vermeidung von gesperrten Mutexen nein Sperrebene beim Octree nein Bucketgr¨ße der SCMap o nein Max. Anzahl an vorerstellten Jobs nein
  • 127. Ergebnis - Parametrisierung Parameter signifikant Vermeidung von gesperrten Mutexen nein Sperrebene beim Octree nein Bucketgr¨ße der SCMap o nein Max. Anzahl an vorerstellten Jobs nein Zeitpunkt der Umstellung auf Large-Mesh-Strategy
  • 128. Ergebnis - Parametrisierung Parameter signifikant Vermeidung von gesperrten Mutexen nein Sperrebene beim Octree nein Bucketgr¨ße der SCMap o nein Max. Anzahl an vorerstellten Jobs nein Zeitpunkt der Umstellung auf Large-Mesh-Strategy ja
  • 129. Ergebnis - Parametrisierung Parameter signifikant Vermeidung von gesperrten Mutexen nein Sperrebene beim Octree nein Bucketgr¨ße der SCMap o nein Max. Anzahl an vorerstellten Jobs nein Zeitpunkt der Umstellung auf Large-Mesh-Strategy ja Anteil verworfene Jobs
  • 130. Ergebnis - Parametrisierung Parameter signifikant Vermeidung von gesperrten Mutexen nein Sperrebene beim Octree nein Bucketgr¨ße der SCMap o nein Max. Anzahl an vorerstellten Jobs nein Zeitpunkt der Umstellung auf Large-Mesh-Strategy ja Anteil verworfene Jobs ja
  • 131. Ergebnis - Fazit Implizite Parallelisierung geht mit C++ nicht → funktionale Programmiersprachen sind hier eindeutig vorteilhaft
  • 132. Ergebnis - Fazit Implizite Parallelisierung geht mit C++ nicht → funktionale Programmiersprachen sind hier eindeutig vorteilhaft Nebenl¨ufige Anwendungen ben¨tigen saubere Struktur a o → neben Geschwindigkeit auch Strukturierung
  • 133. Ergebnis - Fazit Implizite Parallelisierung geht mit C++ nicht → funktionale Programmiersprachen sind hier eindeutig vorteilhaft Nebenl¨ufige Anwendungen ben¨tigen saubere Struktur a o → neben Geschwindigkeit auch Strukturierung Parallelisierung sollte von Beginn an Teil des Softwaredesigns sein
  • 134. Ergebnis - Fazit Bei Datenstrukturen gilt:
  • 135. Ergebnis - Fazit Bei Datenstrukturen gilt: Probabilistische Datenstrukturen sind vorteilhaft → z.B. Hashmaps oder Skiplisten anstelle von balancierten B¨umen a
  • 136. Ergebnis - Fazit Bei Datenstrukturen gilt: Probabilistische Datenstrukturen sind vorteilhaft → z.B. Hashmaps oder Skiplisten anstelle von balancierten B¨umen a Modell und Implementierung k¨nnen stark voneinander o abweichen
  • 137. Ergebnis - Fazit Bei Datenstrukturen gilt: Probabilistische Datenstrukturen sind vorteilhaft → z.B. Hashmaps oder Skiplisten anstelle von balancierten B¨umen a Modell und Implementierung k¨nnen stark voneinander o abweichen Dar¨berhinaus sollte die Ebene des Locks frei w¨hlbar sein u a
  • 138. Ergebnis - Offene Fragen Optimale Parametrisierung noch unbekannt
  • 139. Ergebnis - Offene Fragen Optimale Parametrisierung noch unbekannt Effektive Strategie zur Joberstellung noch nicht gefunden → Jobs werden erstellt und teilweise direkt wieder verworfen