Parallele externer Gedächtnis

In Informatik, a PEM -Modell (Parallele External Memory) ist ein Cache-Awesare, Externer Speicher abstrakte Maschine.^[1] Es ist die parallelmorbende Analogie zum Einzelprozessor Externer Speicher (EM) Modell. In ähnlicher Weise ist es die von Cache-bewusstes Analogie zur Cache Parallele Zufallszugriffsmaschine (KINDERWAGEN). Das PEM -Modell besteht aus einer Reihe von Prozessoren, zusammen mit ihren jeweiligen privaten Caches und einem gemeinsamen Hauptgedächtnis.

Modell

Definition

Das PEM -Modell^[1] ist eine Kombination aus dem EM -Modell und dem PRAM -Modell. Das PEM -Modell ist ein Berechnungsmodell, das besteht ${\ displayStyle p}$ Prozessoren und zweistufig Speicherhierarchie. Diese Gedächtnishierarchie besteht aus einer großen Externer Speicher (Hauptspeicher) der Größe ${\ displayStyle n}$ und ${\ displayStyle p}$ klein interne Erinnerungen (Caches). Die Prozessoren teilen den Hauptspeicher. Jeder Cache ist exklusiv für einen einzelnen Prozessor. Ein Prozessor kann nicht auf den Cache eines anderen zugreifen. Die Caches haben eine Größe ${\ displayStyle m}$ was in Größenblöcken verteilt ist ${\ displayStyle B}$. Die Prozessoren können nur Vorgänge für Daten ausführen, die sich in ihrem Cache befinden. Die Daten können zwischen dem Hauptspeicher und dem Cache in Größe der Größe übertragen werden ${\ displayStyle B}$.

E/A -Komplexität

Das Komplexitätsmaß des PEM -Modells ist die E/A -Komplexität,^[1] Dies bestimmt die Anzahl der parallelen Blöcke zwischen dem Hauptspeicher und dem Cache. Während eines parallelen Blocks kann jeder Prozessor einen Block übertragen. Also wenn ${\ displayStyle p}$ Prozessoren laden parallelly einen Datenblock der Größe ${\ displayStyle B}$ Bilden Sie das Hauptgedächtnis in ihre Caches, es wird als E/A -Komplexität von betrachtet ${\ displayStyle o (1)}$ nicht ${\ displayStyle o (p)}$. Ein Programm im PEM -Modell sollte die Datenübertragung zwischen Hauptspeicher und Caches minimieren und so viel wie möglich mit den Daten in den Caches arbeiten.

Konflikte lesen/schreiben

Im PEM -Modell gibt es keine Direkter Kommunikationsnetzwerk zwischen den P -Prozessoren. Die Prozessoren müssen indirekt über das Hauptgedächtnis kommunizieren. Wenn mehrere Prozessoren versuchen, denselben Block im Hauptspeicher gleichzeitig auf Konflikte zuzugreifen/zu schreiben^[1] geschehen. Wie im Pram -Modell werden drei verschiedene Variationen dieses Problems berücksichtigt:

• Concurrent Read Concurrent Write (CRCW): Der gleiche Block im Hauptspeicher kann von mehreren Prozessoren gleichzeitig gelesen und geschrieben werden.
• Gleichzeitige Read Exclusive Write (Crew): Der gleiche Block im Hauptspeicher kann von mehreren Prozessoren gleichzeitig gelesen werden. Nur ein Prozessor kann jeweils in einen Block schreiben.
• Exklusive Read Exclusive Write (EREW): Der gleiche Block im Hauptspeicher kann nicht von mehreren Prozessoren gleichzeitig gelesen oder verfasst werden. Nur ein Prozessor kann gleichzeitig auf einen Block zugreifen.

Die folgenden zwei Algorithmen^[1] Lösen Sie die Crew und das Problem, wenn ${\ displayStyle p \ leq b}$ Prozessoren schreiben gleichzeitig in denselben Block. Ein erster Ansatz ist die Serialisierung der Schreibvorgänge. Nur ein Prozessor nach dem anderen schreibt in den Block. Dies führt zu insgesamt von insgesamt ${\ displayStyle p}$ Parallelblocktransfers. Ein zweiter Ansatz braucht ${\ displayStyle o (\ log (p))}$ Parallelblocktransfers und ein zusätzlicher Block für jeden Prozessor. Die Hauptidee besteht darin, die Schreibvorgänge in a zu planen binäre Baummode und allmählich die Daten in einen einzelnen Block kombinieren. In der ersten Runde ${\ displayStyle p}$ Prozessoren kombinieren ihre Blöcke in ${\ displayStyle p/2}$ Blöcke. Dann ${\ displayStyle p/2}$ Prozessoren kombinieren die ${\ displayStyle p/2}$ Blöcke in ${\ displayStyle p/4}$. Dieses Verfahren wird fortgesetzt, bis alle Daten in einem Block kombiniert werden.

Vergleich mit anderen Modellen

Modell	Multi-Core	Cache-Awesare
Zufallszugriffsmaschine (RAM)	Nein	Nein
Parallele Zufallszugriffsmaschine (KINDERWAGEN)	Ja	Nein
Externer Speicher (EM)	Nein	Ja
Parallele externer Gedächtnis (PEM)	Ja	Ja

Beispiele

Multiway -Partitionierung

Lassen ${\ displayStyle m = \ {m_ {1}, ..., m_ {d-1} \}}$ Seien Sie ein Vektor von D-1-Pivots, die in zunehmender Reihenfolge sortiert sind. Lassen ${\ displayStyle a}$ ein ungeordneter Satz von N -Elementen sein. Eine D-Way-Partition^[1] von ${\ displayStyle a}$ Ist ein Satz ${\ displaystyle \ pi = \ {a_ {1}, ..., a_ {d} \}}$ , wo ${\ displaystyle \ cup _ {i = 1}^{d} a_ {i} = a}$ und ${\ displayStyle a_ {i} \ cap a_ {j} = \ leereSet}$ zum ${\ displayStyle 1 \ leq i <j \ leq d}$. ${\ displayStyle a_ {i}}$ wird der I-Th-Eimer genannt. Die Anzahl der Elemente in ${\ displayStyle a_ {i}}$ ist größer als ${\ displayStyle m_ {i-1}}$ und kleiner als ${\ displayStyle m_ {i}^{2}}$. Im folgenden Algorithmus^[1] Die Eingabe wird in n/p-Größe zusammenhängende Segmente unterteilt ${\ displayStyle s_ {1}, ..., s_ {p}}$ im Hauptgedächtnis. Der Prozessor, den ich in erster Linie im Segment arbeitet ${\ displayStyle s_ {i}}$. Der Multiway -Partitionierungsalgorithmus (PEM_DIST_SORT^[1]) verwendet ein PEM Präfix -Summe Algorithmus^[1] Berechnung des Präfixsumme mit dem optimalen ${\ displayStyle o \ links ({\ frac {n} {pb}}+\ log (p) \ rechts)}$ E/O -Komplexität. Dieser Algorithmus simuliert einen optimalen Pram -Präfix -Summenalgorithmus.

// Parallelly eine D-Way-Partition in den Datensegmenten berechnen ${\ displayStyle s_ {i}}$ für jeden Prozessor i parallel tun     Lesen Sie den Vektor von Pivots ${\ displayStyle m}$ in den Cache. Trennwand ${\ displayStyle s_ {i}}$ in D -Eimer und Vektor lassen ${\ displayStyle m_ {i} = \ {j_ {1}^{i}, ..., j_ {d}^{i} \}}$ Seien Sie die Anzahl der Elemente in jedem Eimer.Ende für Führen Sie die PEM -Präfix -Summe auf dem Satz der Vektoren aus ${\ displaystyle \ {m_ {1}, ..., m_ {p} \}}$ gleichzeitig. // Verwenden Sie den Präfix -Summenvektor, um die endgültige Partition zu berechnenfür jeden Prozessor i parallel tun     Schreiben Sie Elemente ${\ displayStyle s_ {i}}$ in Speicherorte angemessen durch ${\ displayStyle m_ {i-1}}$ und ${\ displayStyle m_ {i}}$.Ende für Verwenden der Präfix -Summen in gespeicherten in ${\ displayStyle m_ {p}}$ Der letzte Prozessor P berechnet den Vektor ${\ displayStyle B}$ von Eimergrößen und gibt es zurück.

Wenn der Vektor von ${\ displayStyle d = o \ links ({\ frac {m} {b}} \ rechts)}$ Pivots M und der Eingangssatz A befinden sich in zusammenhängendes Speicher, dann kann das D-Way-Partitionierungsproblem im PEM-Modell mit gelöst werden $oder Rechts)}$ E/O -Komplexität. Der Inhalt der endgültigen Eimer muss sich in einem zusammenhängenden Speicher befinden.

Auswahl

Das Auswahlproblem geht es darum, den k-ten kleinsten Element in einer ungeordneten Liste zu finden ${\ displayStyle a}$ von Größe ${\ displayStyle n}$. Der folgende Code^[1] benutzt von Pramsort Das ist ein praktischer optimaler Sortieralgorithmus, der hereinläuft ${\ displayStyle o (\ log n)}$, und AUSWÄHLEN, was ein Cache-optimaler Einzelprozessor-Auswahlalgorithmus ist.

wenn ${\ displayStyle n \ leq p}$ dann   ${\ displayStyle {\ texttt {pramsort}} (a, p)}$  Rückkehr ${\ displayStyle a [k]}$ Ende wenn  // Median von jedem finde ${\ displayStyle s_ {i}}$ für jeden Prozessor ${\ displayStyle i}$ parallel tun   ${\ displaystyle m_ {i} = {\ texttt {select}} (s_ {i}, {\ frac {n} {2p}})}$ Ende für  // Mediane sortieren${\ displaystyle {\ texttt {pramsort}} (\ lbrace m_ {1}, \ dots, m_ {2} \ rbrace, p)}$ // Partition um Median der Mediane aufteilt${\ displayStyle t = {\ texttt {pempartition}} (a, m_ {p/2}, p)}$ wenn ${\ displayStyle k \ leq t}$ dann   Rückkehr ${\ displayStyle {\ texttt {pemSelect}} (a [1: t], p, k)}$ anders   Rückkehr ${\ displayStyle {\ texttt {pemSelect}} (a [t+1: n], p, k-t)}$ Ende wenn 

Unter der Annahme, dass der Eingang in zusammenhängendes Speicher gespeichert ist, wird PEMSELECT hat eine E/A -Komplexität von:

$oder$

Verteilungsart

Verteilungsart Partitionen eine Eingabeliste ${\ displayStyle a}$ von Größe ${\ displayStyle n}$ hinein ${\ displayStyle d}$ Disjunkte Eimer ähnlicher Größe. Jeder Eimer wird dann rekursiv sortiert und die Ergebnisse werden zu einer voll sortierten Liste kombiniert.

Wenn ${\ displayStyle p = 1}$ Die Aufgabe wird an einen Cache-optimalen Einzelprozessor-Sortieralgorithmus delegiert.

Ansonsten der folgende Algorithmus^[1] wird genutzt:

// Probe ${\ displaystyle {\ tfrac {4n} {\ sqrt {d}}}}$ Elemente von ${\ displayStyle a}$ zum jeder Prozessor ${\ displayStyle i}$ parallel tun  wenn ${\ displayStyle m <| s_ {i} |}$ dann  ${\ displayStyle d = m/b}$         Belastung ${\ displayStyle s_ {i}}$ in ${\ displayStyle m}$-Greize Seiten und sortieren Sie Seiten einzeln anders  ${\ displayStyle d = | s_ {i} |}$         Laden und sortieren ${\ displayStyle s_ {i}}$ als einzelne Seite Ende wenn     Wählen Sie jeden aus ${\ displayStyle {\ sqrt {d}}/4}$Das Element von jeder sortierten Speicherseite in zusammenhängenden Vektor ${\ displayStyle r^{i}}$ von ProbenEnde für  parallel tun     Vektoren kombinieren ${\ displayStyle r^{1} \ dots r^{p}}$ in einen einzigen zusammenhängenden Vektor ${\ displaystyle {\ mathcal {r}}}$     Machen ${\ displayStyle {\ sqrt {d}}}$ Kopien von ${\ displaystyle {\ mathcal {r}}}$: $oder$ Ende tun // Finden ${\ displayStyle {\ sqrt {d}}}$ Pivots ${\ displaystyle {\ mathcal {m}} [j]}$ zum ${\ displayStyle j = 1}$ zu ${\ displayStyle {\ sqrt {d}}}$ parallel tun  $oder \ tfrac {j \ cdot 4n} {d}})}$ Ende für Packen Sie die Drehpunkte in zusammenhängender Array ein ${\ displaystyle {\ mathcal {m}}}$ // Partition ${\ displayStyle a}$Umdrehungen in Eimer ${\ displaystyle {\ mathcal {b}}}$ $oder$ // rekursive Eimer sortierenzum ${\ displayStyle j = 1}$ zu ${\ displayStyle {\ sqrt {d}}+1}$ parallel tun     rekursiv anrufen ${\ displayStyle {\ texttt {pemdistsort}}}$ auf Eimer ${\ displayStyle j}$von Größe ${\ displaystyle {\ mathcal {b}} [j]}$     Verwendung $oder$ Prozessoren, die für Elemente im Eimer verantwortlich sind ${\ displayStyle j}$ Ende für 

Die I/O -Komplexität von Pemdistsort ist:

${\displaystyle O\left(\left\lceil {\frac {N}{PB}}\right\rceil \left(\log _{d}P+\log _{M/B}{\frac {N}{ Pb}} \ rechts)+f (n, p, d) \ cdot \ log _ {d} p \ rechts)}$

wo

${\displaystyle f(N,P,d)=O\left(\log {\frac {PB}{\sqrt {d}}}\log {\frac {N}{P}}+\left\lceil { \ frac {\ sqrt {d}} {b}} \ log p+{\ sqrt {d}} \ log b \ rechts \ rceil \ rechts)}}$

Wenn die Anzahl der Prozessoren ausgewählt wird $oder$und ${\ displayStyle m <b^{o (1)}}$ Die I/O -Komplexität lautet dann:

$oder$

Andere PEM -Algorithmen

PEM -Algorithmus	E/A -Komplexität	Einschränkungen
Zusammenführen, sortieren[1]	${\ displayStyle o \ links ({\ frac {n} {pb}} \ log _ {\ frac {m} {b} {\ frac {n} {b} \ rechts) } _ {P} (n)}$	${\ displaystyle p \ leq {\ frac {n} {b^{2}}}, m = b^{o (1)}}$
Listenranking[2]	${\ displayStyle o \ links ({\ textrm {sort}} _ {p} (n) \ rechts)}$	$oder$
Euler Tour[2]	${\ displayStyle o \ links ({\ textrm {sort}} _ {p} (n) \ rechts)}$	${\ displaystyle p \ leq {\ frac {n} {b^{2}}}, m = b^{o (1)}}$
Ausdrucksbaum Auswertung[2]	${\ displayStyle o \ links ({\ textrm {sort}} _ {p} (n) \ rechts)}$	$oder$
Finden a Mst[2]	$oder {pb}} \ rechts)}$	$oder )}}$

Wo ${\ displaystyle {\ textrm {sort}} _ {p} (n)}$ ist die Zeit, die es braucht, um zu sortieren ${\ displayStyle n}$ Artikel mit ${\ displayStyle p}$ Prozessoren im PEM -Modell.

Siehe auch

• Parallele Zufallszugriffsmaschine (KINDERWAGEN)
• Zufallszugriffsmaschine (RAM)
• Externer Speicher (EM)

Verweise