PRAKTIKUM ZUR VL - hu-berlin.de · MPI (Message Passing Interface) Single Program Multiple Data (SPMD) OpenMP-Compiler GCC 4.2 Programme zur Optimierung von parallelen Programmen

PRAKTIKUM ZUR VL

NEUE KONZEPTE UND

TECHNIKEN FÜR

DATENBANKSYSTEME

Humboldt-Universität zu Berlin

Martin Kost

Agenda

Programmierung unter einer Mehrkernarchitektur

Motivation

Partitionierung

Synchronisation

Evaluation

Optimierung

Thread-APIs

Beispiel

Aufgabe 4

22.01.2009Praktikum 4 - Programmierung auf Mehrkernarchitekturen

2

Motivation

Leistungssteigerung in Rechensystemen

The free lunch is over

Keine automatische Leistungssteigerung durch Erhöhung der Taktfrequenz

Leistungssteigerung nur noch durch Einsatz von parallelenArchitekturen

stetig steigende Anzahl an Prozessorkernen pro Rechenknoten

Grundlegende Problem

Aufwendige Programmierung

Kommunikation

Arbitrierung Auflösen von Zugriffskonflikten (z.B. bei Bussystemen) auf geteilte Ressourcen

möglichst gerechte Zuteilung von Ressourcen auf verschiedene Benutzer z.B. Token-Verfahren (LAN: FDDI vs. CSMA/CD-Verfahren)


3

BeispielanwendungenParallelisierung von Programmen

Mandelbrot-Menge

Modellierung der Wärmeausbreitung

Jacobi-Verfahren

Gauß-Seidel-Verfahren

SOR-Methoden

Lattice-Boltzmann-Methoden

Matrix-Matrix-Multiplikation


4

Prozesse, Threads, Chunks und Fiber

Prozess:

ein Programm, welches durch ein Betriebssystem verwaltet wird

besitzt einen eigenen Adressraum (Heap) und verwendet vom Betriebssystem verwaltete Ressourcen

Thread:

Ausführungsstrang für Prozesse und Teilprozesse, welche Anweisungen des Programms ausführen.

besitzen einen eigenen Program Counter und einen privaten Speicherbereich (Stack). Teilen allerdings die anderen Ressourcen des Prozesses …inklusive dem Heap.

sind die natürliche Ausführungseinheit für parallele Programme auf Hardware mit geteiltem Speicher.

Chunk:

logischer Informationsblock innerhalb der Datenstruktur (Dateistruktur), der unabhängig vom Dateninhalt ist

besitzt immer den gleichen Aufbau

besteht aus einer Sequenz von Datenpaketen


6

Prozesse, Threads, Chunks und Fiber

Fiber:

Threads (Scheduling) im User Kontext

besonders leichtgewichtiger Ausführungsstrang (Ausführungseinheit)

Teilen des Adressraums wie bei Threads

Unterschied: kooperatives Multitasking (Threads: präemptives Multitasking)

Threads hängen vor allem von dem Thread Scheduler des Kernel ab – teuer

Fibers werden nicht aufwändig vom Betriebssystem verwaltet und synchronisiert, sondern durch die Anwendung – billig

Sequentielle Ausführung von (einer Anzahl von) Fibers innerhalb eines Threads

Aktivieren sich gegenseitig (Übergabe der Kontrolle an anderen Fiber)

Ähnliches Konzept wie Koroutinen

Koroutinen sind Sprachkonstrukt – Art des Kontrollflusses

Fibers – Konstrukt auf Systemebene zur Implementierung einer Koroutine


7

Parallelisierung

Partitionierungsstrategien

Ziel: Identifizieren unabhängiger Berechnungen/Primitiven (primitive tasks)

1. Domänendekomposition = Datenparallelität

Gleiche Operation

angewandt auf alle Daten

z.B. Iteratormodell – unabhängige Schleifenausführung

2. Funktionale Dekomposition bzw. Dekomposition von Aufgaben = Taskparallelität

Jede Workunit/Thread führt eine einzigartige Aufgabe aus

Unabhängige Teilprogramme


8

call fooxx(fv,fx)

call fooxy(fv,fy)

call fooxz(fv,fz)

for (y=0; y<nLines; y++)

genLine(model,im[y]);

Synchronisierung

Sperr-/Synchronisierungs-Objekt

Mögliche Definition:

Ein Programmkonstrukt, welches den gleichzeitigen(multithreaded) globalen Zugriff auf geteilte Datenkoordiniert

Etwas informeller:

Etwas was dem Programmierer erlaubt zu verhindern, dass zwei Threads gleichzeitig dieselbe Variable ändern


9

Granularität

Granularität von parallelen Arbeitseinheiten

Finden der richtigen Größe für die chunks zur Einteilung der parallelenArbeit kann schwierig werden

Zu große chunks können zu ungleicher Lastverteilung (load imbalance) führen

Zu kleine chunks können zu viel Overhead bei der Synchronisation führen

Eine dynamische Anpassung basierend auf den Daten und dem System hilft, die richtige Balance zu finden und den Synchronisationsaufwand zureduzieren

Granularität von Synchronisation/Blockierung

Synchronisation sollte in kleinst möglichen Einheiten erfolgen

Wenn die Einheiten zu groß sind, wird die Ausführung serialisiert, da andereThreads auf die Sperren warten

Synchronisation sollte so selten wie möglich erfolgen

Wenn zu häufig, kann der Synchronisations-Overhead die Kosten dominieren


10

Goldene Regeln

James Reinders http://www.ddj.com/hpc-high-performance-computing/201804248

1. Think parallel.

2. Program using abstraction.

3. Program in tasks (chores), not threads (cores).

4. Design with the option to turn concurrency off.

5. Avoid using locks.

6. Use tools and libraries designed to help with concurrency.

7. Use scalable memory allocators.

8. Design to scale through increased workloads.


11

http://www.ddj.com/hpc-high-performance-computing/201804248







Evaluation – Metriken

verschiedene Dimensionen

Laufzeit

Zeitpunkte

ab Start des Programms

ab Start des Threads

ab Eintreffen einer Anfrage

bis zur Ausgabe aller Antworten

bis zur Ausgabe der ersten Antwort

bis zum Ende des Programms

Kommunikation

…

Privacy


12

Optimierung

Optimierung vielfältig

1. Lohnt sich Parallelisierung?

Mehraufwand für Synchronisierung, Erzeugen von Threads, Mehraufwand wegen False-sharing (Cache pinging)

Sequentielle prozessorientierte Verarbeitung

ein Prozess verarbeitet alle Daten für einen Schritt bevor er nächsten Schritt übergeht

Blockierung kann nicht auftreten: Vorteil bei Abhängigkeiten zwischen Daten (z.B. nicht kommutative Operationen)

Programmcode wird weniger oft geladen

keine Parallelisierung

Möglichkeiten zur Parallelisierung eines Programms analysieren


13

Optimierung

Prozessaufteilung in Threads

Datenorientiert: gesamten Prozess parallelisieren

Datenaufkommen in Teilmengen aufteilen

eindimensional: horizontale oder vertikale Partitionierung von Tabellen

mehrdimensional: räumliche Aufteilung von Matrizen

Taskorientiert: verschiedene Funktionen auf gleichen Daten

Synchronisierung

nicht nötig bei unabhängiger Verarbeitung von Teilmengen

einfach aber nicht unbedingt billig bei map/reduce Ansatz

Erzeuger-Konsument-Prinzip (mit gemeinsamen Ergebnisstack) ist ein Konzept zur Optimierung abhängiger Threads

Partitionierung so wählen, dass abhängige Daten durch möglichst einen Prozessor/Kern verarbeitet werden

im Allgemeinen steigt der Aufwand mit dem Grad an Abhängigkeit und sinkt mit der Größe der Partition

Optimum bei unabhängigen Threads mit gleichem Code: Anzahl Threads = Anzahl Kerne

Threadblockierung vermeiden (geteilter L2-Cache mit Cachelinegröße Prefetching kann bei Schreiben im L1 Cache zu Blockierung anderer Kerne führen)


14

Optimierung

Datentransport

Caching-Verhalten, …

Lastausgleich

Ausführungsplan

z.B. Sprünge wie if vermeiden

…


15

Speicherhierarchie


16

Überblick über Parallelisierung und

Optimierung

Sprachen und APIs

MPI (Message Passing Interface) Single Program Multiple Data (SPMD)

OpenMP-Compiler GCC 4.2

Programme zur Optimierung von parallelen Programmen

Intel VTune

Intel Thread Checker

Optimierung

Algorithmische Ebene

OS-Ebene

Cache


17

Thread-Schnittstellen

Betriebssysteme bieten Schnittstellen zum Erzeugen,

Verwalten und Auflösen von Threads

Windows threading API

Posix threads (Pthreads)

…

Vorteil von Bibliotheken:

viel/genaue Kontrolle über die Threads


18

OpenMP

Compiler-Erweiterung für C++ und Fortran (www.openmp.org)

ermöglicht Parallelisierung von Code-Stücken

Makros: #pragma omp ...

(von unwissenden Compilern ignoriert)

plattform-übergreifend, von allen großen Compilern inzwischen unterstützt:

gcc, Intel, Microsoft, Sun, IBM, Spezial-Hersteller

Fork-Join-Parallelismus (parallele Regionen, Barrieren, …, shared/private data, …)


19

#include <omp.h>

#include <iostream>

int main() {

#pragma omp parallel

{

std::cout << omp_get_thread_num() << " von " << omp_get_num_threads() << std::endl;

}

return 0; }

MPI – Message Passing Interface

Standard, der den Nachrichtenaustausch bei parallelen Berechnungen auf verteilten Computersystemen beschreibt

MPI-Applikation besteht in der Regel aus mehreren miteinander kommunizierenden Prozessen

werden alle zu Beginn der Programmausführung parallel gestartet

arbeiten gemeinsam an einem Problem

nutzen zum Datenaustausch Nachrichten, welche explizit von einem zum anderen Prozess geschickt werden


20

MPI – Message Passing Interface –

Program Parallelization

1. Adaptation von array-Deklarationen

Lokale Größe verteilter arrays umfasst nur den Teil derDatenstruktur, welcher dem Prozess zugewiesen wurde.

2. Indextransformation

Globale Indizes werden auf Tupel von Knotennummer und lokalem Index abgebildet.

3. Lastverteilung

Berechnungen werden von dem Prozess ausgeführt, welchem die entsprechende Variable zugewiesen wurde.

4. Kommunikation

Der Zugriff auf array-Elemente anderer Prozesse muss durcheinen Nachrichtenaustausch (message passing) implementiertwerden.


21

MPI – Message Passing Interface

Point-to-Point communication

Collective communication

Communicators

Process topologies

User-defined data types

Operations and properties of the execution environment

Profiling interface

Dynamic process creation

One-sided communication

Parallel IO

www-unix.mcs.anl.gov/mpi/


22

MPI-Beispiel


23

#include "mpi.h"#include <stdio.h>#include <string.h>

int main(int argc, char *argv[]){

char message[20];int myrank, tag=99;MPI_Status status;

MPI_Init(&argc, &argv);MPI_Comm_rank(MPI_COMM_WORLD, &myrank);

if (myrank == 0) {strcpy(message, "Hello, there");MPI_Send(message, strlen(message)+1, MPI_CHAR, 1, tag, MPI_COMM_WORLD);

}else {

MPI_Recv(message, 20, MPI_CHAR, 0, tag, MPI_COMM_WORLD, &status);printf("received \"%s\"\n", message);

}

MPI_Finalize();return 0;

}

Pthread

POSIX Threads oder Pthreads – POSIX Standard fürThreads

Pthread definiert eine Schnittstelle

zum Erzeugen, Manipulieren und Verwalten von Threats

Pthreads meist verwendet in Unix-ähnlichen POSIX Systemen wieLinux und Solaris

Microsoft Windows Implementierungen existieren ebenfalls

z.B. pthreads-w32 unterstützt eine Teilmenge der Pthread API

Pthreads definiert Menge an C-Typen, Funktionen und Konstanten

Implementiert durch den pthread.h Header und einer Thread-Bibliothek

Synchronisierung mittels Mutex und Signalen


24

Pthread

Ermöglicht Erzeugung, Ausführung, Suspension, Terminierung und Kommunikation von Threads

wichtigste Konstrukte: pthread_create() und pthread_join()

Tutorials:

http://www.yolinux.com/TUTORIALS/LinuxTutorialPosixThreads.html

https://computing.llnl.gov/tutorials/pthreads/

http://www.thinkbrown.com/programming/pthreads.pdf

Kompilierung:

C compiler: cc -pthread HelloWorldThreads.c

C++ compiler: g++ -pthread HelloWorldThreads.c


25




Pthread

Thread-Synchronisation: Die Thread-Bibliothek

bietet drei Mechanismen zur Synchronisierung:

mutex – mutual exclusion Sperre: Verhindert Zugriff

auf Variablen durch andere Threads. Dies erzwingt

einen exklusiven Zugriff eines Thread auf eine Variable

oder eine Menge von Variablen.

join – Die Funktion pthread_join(threadid, …) blockiert

den aufrufenden Thread bis der Thread mit der

angegebenen threadid terminiert.

condition variable – Datentyp pthread_cond_t


26

Pthreads – Beispiel

#define _GNU_SOURCE

#define __USE_GNU

#include <unistd.h>

#include <stdio.h>

#include <stdlib.h>

#include <pthread.h>

#include <errno.h>

#include <sched.h>

#define NUM_CORES 2

#define NUM_THREADS 4

#define USE_MUTEX

#define USE_AFFINITY

pthread_mutex_t global_mutex =

PTHREAD_MUTEX_INITIALIZER;

pthread_cond_t global_cond =

PTHREAD_COND_INITIALIZER;

int printingOnStream = 1;

22.01.2009

27

Praktikum 4 - Programmierung auf Mehrkernarchitekturen


void * HelloWorldThreadFunc(void*);

int main(int argc, char ** argv)

{

int i;

pthread_t thread[NUM_THREADS];

int threadId[NUM_THREADS];

for(i=0; i < NUM_THREADS; ++i)

{

threadId[i] = i % NUM_CORES;

}


{

if(pthread_create(&thread[i],NULL,&HelloWorldThreadFunc,&threadId[i])!=0)

{

perror(NULL);

exit(-1);

}

}

printingOnStream = 0;


{

pthread_join(thread[i],NULL);

}

exit(0);

}

22.01.2009

28



void * HelloWorldThreadFunc(void* ptr)

{

#ifdef USE_AFFINITY

int cpu_id = *((int*)ptr);

cpu_set_t mask;

CPU_ZERO(&mask);

CPU_SET(cpu_id,&mask);

fprintf(stderr,"Set Affinity to %d thread %#08X\n",cpu_id,pthread_self());

sched_setaffinity(0,sizeof(mask),&mask);

#endif

#ifdef USE_MUTEX

pthread_mutex_lock(&global_mutex);

while(printingOnStream!=0)

{

pthread_cond_wait(&global_cond,&global_mutex);

}


pthread_mutex_unlock(&global_mutex);

#endif

22.01.2009

29



fprintf(stdout,"Hello world from thread %#08X. Wait 2sec ... ",pthread_self());

sleep(2);

fprintf(stdout,"finished wait\n");

#ifdef USE_MUTEX


pthread_cond_broadcast(&global_cond);

#endif

pthread_exit(NULL);

}

22.01.2009

30


Pthreads – Beispielohne Mutex

[1019]> gcc -o HelloWorldThreads HelloWorldThreads.c –pthread

[1020]> ./HelloWorldThreads

Hello world from thread 0XB7DBFB90. Wait 2sec ... Hello world from

thread 0XB75BEB90. Wait 2sec ... Hello world from thread 0XB6DBDB90.

Wait 2sec ... Hello world from thread 0XB65BCB90. Wait 2sec ... finished

wait

finished wait

finished wait

finished wait


31

Pthreads – Beispielmit Mutex und Affinity

[1021]> g++ -o HelloWorldThreads HelloWorldThreads.c -pthread-DUSE_MUTEX -DUSE_AFFINITY

[1022]> ./HelloWorldThreads

Set Affinity to 0 thread 0XB7DBBB90

Set Affinity to 1 thread 0XB75BAB90

Set Affinity to 0 thread 0XB6DB9B90

Set Affinity to 1 thread 0XB65B8B90

Hello world from thread 0XB7DBBB90. Wait 2sec ... finished wait

Hello world from thread 0XB75BAB90. Wait 2sec ... finished wait

Hello world from thread 0XB6DB9B90. Wait 2sec ... finished wait

Hello world from thread 0XB65B8B90. Wait 2sec ... finished wait


32

Übungen

~fünf


XML-Parsing

22.01.2009

33

4. Übung – AufgabenstellungVerbrecherjagd

Praktikum 4 - Programmierung auf Mehrkernarchitekturen 22.01.2009

34

Unschuldige

PolizeiKriminelle

4. Übung – AufgabenstellungVerbrecherjagd


35

Unschuldige

PolizeiKriminelle

4. Übung – AufgabenstellungVerbrecherjagd – Matrix als Eingabe


36

Unschuldige

PolizeiKriminelle

4. Übung – AufgabenstellungVerbrecherjagd – Scannen der Matrix


37

Unschuldige

Polizei

Scannen eines Quadranten nach Personen

Kriminelle

4. Übung – AufgabenstellungVerbrecherjagd – Ergebnis des Scanvorgangs


38

Unschuldige

PolizeiKriminelle

Quadranten in denen Personen auftauchen

Quadranten in denen Personen verschwinden

4. Übung – Aufgabenstellung

Verbrecherjagd – Typerkennung der erkannten

Personen


39

Kriminelle

Unschuldige

Polizei

Quadranten mit Kriminellen

Quadranten mit Polizisten


Verbrecherjagd – Bewegungserkennung


40

Kriminelle

Unschuldige

Polizei

Quadranten mit auftauchenden Kriminellen

Quadranten mit auftauchenden Polizisten

Bewegung: Ein Personentyp verschwindet und taucht in einem benachbarten Quadranten auf

in der ersten Matrix kein Verschwinden v. Personen keine Bewegung

4. Übung – AufgabenstellungVerbrecherjagd – Scannen der Folgematrix


41

Unschuldige

PolizeiKriminelle

Scannen eines Quadranten

4. Übung – AufgabenstellungVerbrecherjagd – Ergebnis des Scanvorgangs


42

Unschuldige

Polizei

Quadranten in denen Personen auftauchen

Kriminelle

Quadranten in denen Personen verschwinden


Verbrecherjagd – Typerkennung der erkannten

Personen


43

Unschuldige

PolizeiKriminelle

Quadranten mit Kriminellen

Quadranten mit Polizisten


Verbrecherjagd – Bewegungserkennung


44

Unschuldige

PolizeiKriminelle

Quadranten mit auftauchenden Kriminellen

Quadranten mit auftauchenden Polizisten

Bewegung: Ein Personentyp verschwindet und taucht in einem benachbarten Quadranten auf

4. Übung – AufgabenstellungVerbrecherjagd – Scannen nach Schlüsselereignis


45

Unschuldige

PolizeiKriminelle

Schlüsselereignis

Schlüsselereignis = Aufeinanderzubewegen

von Polizist und Kriminellen

Senden einer

Benachrichtigung


Programmierung eines Programms zur

Verbrecherjagd unter einer Mehrkernarchitektur

Eingabe

Geordnete Liste von Matrizen

Jede Matrix beinhaltet Informationen über das Auftauchen oder Verschwinden von Personen sowie Merkmale zur Identifizierung von Polizisten und Kriminellen

Das Verschwinden und gleichzeitige Auftauchen einer Person in einem Nachbarquadranten beschreibt eine Bewegung

Bewegungen können horizontal, vertikal oder diagonal erfolgen

Schlüsselereignis

Ein Verbrecher und ein Polizist bewegen sich auf direktem Weg aufeinander zu

Ausgabe

Eine Nachricht sobald das Schlüsselereignis auftritt und eine Beschreibung der dazugehörigen Bewegungen des Polizisten und des Kriminellen

Entwurf und Beschreibung eines Algorithmus zur Lösung des Problems sowie einer Parallelisierungstrategie

Abgabe von mind. zwei (animierten) Folien zum Vorlesungstermin vor Ablauf der Abgabefrist

Implementierung des Algorithmus

unter C (C++) unter Verwendung von Pthreads

Messung der Ausführungszeit


46


Programmierung eines Programms zur

Verbrecherjagd unter einer Mehrkernarchitektur

Hinweise

In main() erzeugen Sie mehrere Erzeuger- und

Verbraucher-Threads (Producer/Consumer), welche die

entsprechenden Methoden ausführen.

Bauen Sie in Ihre Threads geeignete Ausgaben ein, so

dass Sie den Programmablauf verfolgen können.


47


Umgebung

Zander

64 Bit Suse Linux Enterprise 10.3

4 CPU a 2 Kerne von Opteron

L1 Cache 64 Bit


48

Literaturangaben


James Reinders http://www.ddj.com/hpc-high-performance-computing/201804248

http://www.openmp.org http://www-unix.mcs.anl.gov/mpi/




Charles Congdon “Multithreaded Programming –Quickstart”, A Dr. Dobb’s Journal, Vendor Perspectives NetSeminar, Sponsored by Intel, May 2006

22.01.2009

49








http://www.openmp.org/

http://www-unix.mcs.anl.gov/mpi/








Literaturangaben


Multi-Core Processors – Multi-ThreadedProgramming, Supercomputing 2008 Summer Workshop, GVSU

Josef Weidendorfer, Sequentielle Optimierung –Analysewerkzeuge und Cache-Optimierung, Praktikum Hochleistungsarchitekturen, Sommer 2007

22.01.2009

50

PRAKTIKUM ZUR VL - hu-berlin.de · MPI (Message Passing Interface) Single Program Multiple Data (SPMD) OpenMP-Compiler GCC 4.2 Programme zur Optimierung von parallelen Programmen

Documents