h1

000659783 001__ 659783
000659783 005__ 20230408004734.0
000659783 0247_ $$2URN$$aurn:nbn:de:hbz:82-rwth-2016-049355
000659783 0247_ $$2HBZ$$aHT019019718
000659783 0247_ $$2Laufende Nummer$$a34813
000659783 037__ $$aRWTH-2016-04935
000659783 041__ $$aEnglish
000659783 082__ $$a004
000659783 1001_ $$0P:(DE-82)IDM01602$$aSchmidl, Dirk$$b0$$urwth
000659783 245__ $$aOpenMP scalability limits on large SMPs and how to extend them$$cvorgelegt von Diplom-Informatiker Dirk Schmidl$$honline
000659783 246_3 $$aOpenMP-Skalierbarkeitslimits auf großen SMP-Systemen and wie sie erweitert werden können$$yGerman
000659783 260__ $$aAachen$$c2016
000659783 300__ $$a1 Online-Ressource (vii, 123 Seiten) : Illustrationen, Diagramme
000659783 3367_ $$2DataCite$$aOutput Types/Dissertation
000659783 3367_ $$2ORCID$$aDISSERTATION
000659783 3367_ $$2BibTeX$$aPHDTHESIS
000659783 3367_ $$02$$2EndNote$$aThesis
000659783 3367_ $$0PUB:(DE-HGF)11$$2PUB:(DE-HGF)$$aDissertation / PhD Thesis$$bphd$$mphd
000659783 3367_ $$2DRIVER$$adoctoralThesis
000659783 500__ $$aVeröffentlicht auf dem Publikationsserver der RWTH Aachen University
000659783 502__ $$aDissertation, RWTH Aachen University, 2016$$bDissertation$$cRWTH Aachen University$$d2016$$gFak01$$o2016-06-28
000659783 5203_ $$aAktuell sind Rechenknoten mit zwei Prozessoren die am häufigsten verwendeten Knoten im Bereich des Hochleistungsrechnen.Viele tausend dieser Knoten können über ein schnelles Netzwerk miteinander gekoppelt werden zu einem Rechencluster. Um diese Cluster zu programmieren wird üblicherweise das Message Passing Interface (MPI) verwendet. MPI erfordert es die Parallelität und die verwendeten Datentransfers sehr explizit über Funktionsaufrufe zu realisieren. Eine Alternative zu MPI, welche eine Parallelisierung auf höherer Ebene erlaubt ist OpenMP. In OpenMP können serielle Programme mit Pragmas angereichert werden um rechenintensive Teile der Anwendung parallel auszuführen.In vielen Fällen ist dies mit weniger Aufwand verbunden wie eine Parallelisierung mit MPI, bei der die gesamte Datenverteilung über alle Knoten im gesamten Programm implementiert werden muss. Der Nachteil von OpenMP ist, dass es nur auf Maschinen mit geteiltem Hauptspeicher und nicht auf den weit verbreiteten Clustern eingesetzt werden kann. Eine Reihe von Herstellern hat sich aber darauf spezialisiert große Maschinen mit geteiltem Hauptspeicher herzustellen. Da geteilter Hauptspeicher und damit einhergehende Anforderungen an die Koheränz der Speicher und Caches kompliziert zu implementieren sind, haben solche Maschinen Eigenheiten, die bei der Programmierung mit OpenMP berücksichtigt werden müssen um eine gute Parallelisierung zu erreichen.In dieser Arbeit beschäftige ich mich damit die Eigenschaften verschiedener dieser großen Maschinen mit geteilten Hauptspeicher und die Programmierbarkeit mit OpenMP zu untersuchen. An Stellen an denen OpenMP nicht die nötigen Mittel für eine gute Parallelisierung liefert, werde ich Verbesserungen aufzeigen. Weiterhin beschäftige ich mich in der Arbeit damit, wie Anwendungen mit OpenMP für solche Maschinen systematisch optimiert werden können. Hierbei wird die Nutzbarkeit von Performance-Analyse-Werkzeugen untersucht und Verbesserungen im Bereich der Task-basierten Analyse vorgestellt, welche die Optimierung für große Systeme vereinfachen. Abschließend stelle ich noch ein Modell vor, welches verwendet werden kann um eine Performance-Abschätzung für eine Anwendung auf einem solchen System vorzunehmen.Abschließend wird anhand von zwei Anwendungen gezeigt, dass es die vorgestellten Optimierungen erlauben mit echten Nutzeranwendungen eine Skalierbarkeit mit OpenMP auf großen Systemen zu erreichen.$$lger
000659783 520__ $$aThe most widely used node type in high-performance computing nowadays is a 2-socket server node. These nodes are coupled to clusters with thousands of nodes via a fast interconnect, e.g. Infiniband. To program these clusters the Message Passing Interface (MPI) became the de-facto standard. However, MPI requires a very explicit expression of data layout and data transfer in a parallel program which often requires the rewriting of an application to parallelize it. An alternative to MPI is OpenMP, which allows to incrementally parallelize a serial application by adding pragmas to compute-intensive regions of the code.This is often more feasibly than rewriting the application with MPI. The disadvantage of OpenMP is that it requires a shared memory and thus cannot be used between nodes of a cluster. However, different hardware vendors offer large machines with a shared memory between all cores of the system.However, maintaining coherency between memory and all cores of the system is a challenging task and so these machines have different characteristics compared to the standard 2-socket servers. These characteristics must be taken into account by a programmer to achieve good performance on such a system. In this work, I will investigate different large shared memory machines to highlight these characteristics and I will show how these characteristics can be handled in OpenMP programs. When OpenMP is not able to handle different problems, I will present solutions in user space, which could be added to OpenMP for a better support of large systems. Furthermore, I will present a tools-guided workflow to optimize applications for such machines.I will investigate the ability of performance tools to highlight performance issues and I will present improvements for such tools to handle OpenMP tasks. These improvements allow to investigate the efficiency of task-parallel execution, especially for large shared memory machines.The workflow also contains a performance model to find out how well the performance of an application is on a system and when to stop tuning the application.Finally, I will present two application case studies where user codes have been optimized to reach a good performance by applying the optimization techniques presented in this thesis.$$leng
000659783 591__ $$aGermany
000659783 653_7 $$aOpenMP
000659783 653_7 $$ahigh performance computing
000659783 653_7 $$aNUMA-Architektur
000659783 653_7 $$aLeistungsoptimierung
000659783 7001_ $$0P:(DE-82)IDM01074$$aMüller, Matthias S.$$b1$$eThesis advisor
000659783 7001_ $$0P:(DE-82)003917$$aBischof, Christian$$b2$$eThesis advisor
000659783 8564_ $$uhttps://publications.rwth-aachen.de/record/659783/files/659783.pdf$$yOpenAccess
000659783 8564_ $$uhttps://publications.rwth-aachen.de/record/659783/files/659783_source.zip$$yrestricted
000659783 8564_ $$uhttps://publications.rwth-aachen.de/record/659783/files/659783.gif?subformat=icon$$xicon$$yOpenAccess
000659783 8564_ $$uhttps://publications.rwth-aachen.de/record/659783/files/659783.jpg?subformat=icon-1440$$xicon-1440$$yOpenAccess
000659783 8564_ $$uhttps://publications.rwth-aachen.de/record/659783/files/659783.jpg?subformat=icon-180$$xicon-180$$yOpenAccess
000659783 8564_ $$uhttps://publications.rwth-aachen.de/record/659783/files/659783.jpg?subformat=icon-640$$xicon-640$$yOpenAccess
000659783 8564_ $$uhttps://publications.rwth-aachen.de/record/659783/files/659783.jpg?subformat=icon-700$$xicon-700$$yOpenAccess
000659783 8564_ $$uhttps://publications.rwth-aachen.de/record/659783/files/659783.pdf?subformat=pdfa$$xpdfa$$yOpenAccess
000659783 909CO $$ooai:publications.rwth-aachen.de:659783$$pdnbdelivery$$pVDB$$pdriver$$purn$$popen_access$$popenaire
000659783 9141_ $$y2016
000659783 915__ $$0StatID:(DE-HGF)0510$$2StatID$$aOpenAccess
000659783 9201_ $$0I:(DE-82)123010_20140620$$k123010$$lLehrstuhl für Informatik 12 (Hochleistungsrechnen)$$x0
000659783 9201_ $$0I:(DE-82)120000_20140620$$k120000$$lFachgruppe Informatik$$x1
000659783 961__ $$c2016-08-17T19:38:26.078338$$x2016-06-30T09:31:28.877325$$z2016-08-17T19:38:26.078338
000659783 9801_ $$aFullTexts
000659783 980__ $$aphd
000659783 980__ $$aVDB
000659783 980__ $$aI:(DE-82)123010_20140620
000659783 980__ $$aI:(DE-82)120000_20140620
000659783 980__ $$aUNRESTRICTED