Parallelisierung von Gitterbasisreduktionen - CDC

Parallelisierung von
Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
Diplomarbeit
im Fachgebiet Theoretische Informatik - Kryptographie und
Computeralgebra
vorgelegt von:
Studienbereich:
Matrikelnummer:
Prüfer:
Betreuer:
Özgür Dagdelen
Mathematik
1199868
Prof. Dr. Johannes Buchmann
Michael Schneider
Mai 2009
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
Zusammenfassung
In dieser Ausarbeitung stellen wir die erste Parallelisierung des bekannten BKZ
Algorithmus vor. Es ist bereits bekannt, dass für die besten Ergebnisse den kürzesten
Vektor eines Gitters zu finden, meist die Wahl auf den BKZ Algorithmus trifft.
Allerdings sind aus Laufzeitgründen keine beliebige Blockgrößen anwendbar.
Durch die Parallelisierung schaffen wir vor allem für den exponentiellen Anteil der
Laufzeit, genauer die ENUM Prozedur, eine besonders effiziente Beschleunigung.
Tests zeigen, dass die Effizienz mit stetig steigender Blockgröße gegen 1 konvergiert
und wir damit die maximale Beschleunigung erreichen.
Es bleibt abzuwarten, inwiefern mit diesem neuen Ansatz die Sicherheit vorhandener
Kryptosysteme in Frage gestellt wird.
Abstract
In this work we present the first parallelization of the BKZ algorithm. The BKZ
algorithm is known for giving best results to the problem of finding short vectors
in a lattice. However, it is not possible to choose arbitrary blocksizes because the
running time is affected.
By parallelizing the algorithm we achieve a notably efficient acceleration of the
exponential part of the algorithm, more precisely the ENUM procedure. Our tests
show that the efficiency of our algorithm converges to 1 while the blocksize increases.
Thereby we achieve the best possible speed up.
It remains to be seen how this new approach affects the security of existent cryptosystems.
Özgür Dagdelen
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
Danksagung
Ich möchte hier die Personen erwähnen, die mich in meiner Diplomarbeit sowie im
Studium unterstützten.
Als erstes möchte ich meine Freundin Fatima Sialiti für ihre Unterstützung und Motivationshilfen während der Arbeit danken. Außerdem danke ich ihr für ihre Geduld
und Rücksicht für die Zeit, welche ich für diese Ausarbeitung benötigte.
Weiter bedanke ich mich bei meinem Betreuer Michael Schneider, der mir mit Rat
und Tat beistand und sein Gehör schenkte. Er war immer ansprechbar und half
mir über die komplette Zeit aus meiner Arbeit einen Erfolg zu machen. Prof. Dr.
Johannes Buchmann möchte ich meinen Dank aussprechen, der durch seine Vorlesungen mir die nötige Inspiration schenkte, um mich mit der Kryptographie näher zu
beschäftigen, wie auch Dr. Evangelos G. Karatsiolis für seine Ratschläge, die nicht
nur meine Diplomarbeit betrafen, sondern auch meine weitere Zukunft.
Für das fleißige Korrekturlesen lobe ich an dieser Stelle Jochen Huber sowie Felix
Derwenskus. Sie waren auch diejenigen, welche mir Abwechslung während dieser
Zeit boten, so dass nicht nur die Diplomarbeit meinen Lebensinhalt füllte.
Euch allen danke ich und ich hoffe, dass diese Arbeit in eurem Sinne ist.
Özgür Dagdelen
I
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
Eidesstattliche Erklärung
Eidesstattliche Erklärung
Ich versichere hiermit, dass ich meine Diplomarbeit mit dem Thema
Parallelisierung von Gitterbasisreduktionen
- Paralleler BKZ - Algorithmus
selbständig verfasst und keine anderen als die angegebenen Quellen und Hilfsmittel
benutzt habe. Die Arbeit wurde bisher keiner anderen Prüfungsbehörde vorgelegt
und auch nicht veröffentlicht.
Darmstadt, den 7. Mai 2009
Özgür Dagdelen
Özgür Dagdelen
II
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
Inhaltsverzeichnis
Inhaltsverzeichnis
Eidesstattliche Erklärung
II
Abbildungsverzeichnis
VI
Tabellenverzeichnis
VII
1. Einleitung
1
2. Grundlagen der Gittertheorie und Gitterreduktionen
4
2.1. Notationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4
2.2. Gittertheorie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
2.3. Orthogonalisierung QR . . . . . . . . . . . . . . . . . . . . . . . . . .
8
2.4. Algorithmische Probleme in einem Gitter . . . . . . . . . . . . . . .
10
2.5. Gitterreduktionsbegriffe . . . . . . . . . . . . . . . . . . . . . . . . .
11
3. Sequentielle Algorithmen zur Gitterbasisreduktion
13
3.1. LLL Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14
3.2. SE Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
17
3.3. BKZ Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19
3.4. Weitere Block basierte Algorithmen
23
. . . . . . . . . . . . . . . . . .
4. Parallele Algorithmen zur Gitterbasisreduktion
24
4.1. Alltausch Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . .
26
4.2. Die parallele Version des SE Algorithmus
30
. . . . . . . . . . . . . . .
5. Paralleler BKZ Algorithmus
41
5.1. Paralleler LLL Reduktionsalgorithmus LLLpar . . . . . . . . . . . . .
43
5.2. ENUMpar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
43
6. Implementierung und Diskussion
57
6.1. Übersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
57
6.2. Die Prozedur LLLpar . . . . . . . . . . . . . . . . . . . . . . . . . . .
58
6.3. Die Prozedur ENUMpar . . . . . . . . . . . . . . . . . . . . . . . . .
64
Özgür Dagdelen
III
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
Inhaltsverzeichnis
6.4. Hauptprozedur parBKZ . . . . . . . . . . . . . . . . . . . . . . . . .
67
7. Zusammenfassung und Ausblick
70
Literaturverzeichnis
72
A. Anhang
Özgür Dagdelen
i
IV
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
LISTE DER ALGORITHMEN
Liste der Algorithmen
1.
Gram-Schmidt Orthogonalisierung . . . . . . . . . . . . . . . . . . . .
8
2.
Größenreduktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11
3.
LLL - Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14
4.
Tiefe Einfügungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16
5.
Schnorr Euchner (SE) - Algorithmus . . . . . . . . . . . . . . . . . . .
18
6.
BKZ - Algorithmus
. . . . . . . . . . . . . . . . . . . . . . . . . . . .
19
7.
BASIS - Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . .
20
8.
ENUM - Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . .
22
9.
Alltausch Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . .
27
10.
Größenreduktion zur parallelen Ausführung . . . . . . . . . . . . . . .
27
11.
Orthogonalisierungsabschnitt des SE Algorithmus . . . . . . . . . . .
33
12.
Größenreduktionsabschnitt des SE Algorithmus . . . . . . . . . . . . .
33
13.
Paralleler BKZ - Algorithmus . . . . . . . . . . . . . . . . . . . . . . .
42
14.
Serieller ENUM - Algorithmus . . . . . . . . . . . . . . . . . . . . . .
45
15.
Paralleler ENUM - Algorithmus (1.Ansatz) . . . . . . . . . . . . . . .
51
16.
ENUM Thread (Initialisierungen) . . . . . . . . . . . . . . . . . . . .
52
17.
ENUMpar Thread (Initialisierungen) . . . . . . . . . . . . . . . . . .
55
18.
ENUMpar - Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . .
56
Özgür Dagdelen
V
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
Abbildungsverzeichnis
Abbildungsverzeichnis
4.1. Neuberechnung der Skalarprodukte . . . . . . . . . . . . . . . . . . .
32
4.2. Ablaufdiagramme für die parallele Größenreduktion . . . . . . . . .
34
4.3. Parallele Berechnung der µk,j . . . . . . . . . . . . . . . . . . . . . .
35
4.4. Größenreduktion für n = 6 und k = 5
36
. . . . . . . . . . . . . . . . .
4.5. Parallele Berechnung der 20. Zeile der Matrix R und den GramSchmidt Koeffizienten . . . . . . . . . . . . . . . . . . . . . . . . . .
39
5.1. Suchbaum eines ENUM Aufrufs . . . . . . . . . . . . . . . . . . . . .
46
5.2. Ausführungsschritte des parallelen ENUMs im Vergleich zur sequentiellen Version . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
52
5.3. Worst Case Beispiel des ersten Ansatzes von ENUMpar . . . . . . .
54
6.1. Laufzeiten der Skalarproduktberechnung sowie der Reduktionsphase
64
6.2. Laufzeiten des SEpar sowie die erreichten Beschleunigungen . . . . .
64
6.3. Laufzeiten der Aufzählverfahren ENUM sowie ENUMpar sowie erreichte Effizienz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
67
6.4. Laufzeiten des BKZ sowie BKZpar für kleine Blockweiten . . . . . .
69
6.5. Laufzeiten des BKZpar sowohl mit ENUM als auch mit ENUMpar .
69
6.6. Laufzeiten des BKZ sowie BKZpar für große Blockweiten . . . . . . .
69
Özgür Dagdelen
VI
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
Tabellenverzeichnis
Tabellenverzeichnis
6.1. Attribute der Klasse SEpar . . . . . . . . . . . . . . . . . . . . . . .
60
6.2. Methoden der Klasse SEpar . . . . . . . . . . . . . . . . . . . . . . .
61
6.3. Attribute der Klasse ENUMpar . . . . . . . . . . . . . . . . . . . . . .
65
6.4. Methoden der Klasse ENUMpar . . . . . . . . . . . . . . . . . . . . . .
66
6.5. Attribute der Klasse BKZpar . . . . . . . . . . . . . . . . . . . . . . .
68
6.6. Methoden der Klasse BKZpar . . . . . . . . . . . . . . . . . . . . . .
68
Özgür Dagdelen
VII
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
1. Einleitung
1. Einleitung
Die Sicherheit vieler Kryptosysteme beruht bis heute auf Problemen, welche in der
Komplexitätsklasse NP-vollständig liegen. Darunter fallen Probleme wie das Faktorisierungsproblem, der diskrete Logarithmus, das Rucksackproblem und viele mehr.
In dieser Arbeit befinden sich weitere NP-vollständige Probleme, die sich mit Gittern
beschäftigen. Unter randomisierter Reduktion gehören die Probleme SVP (Shortest
Vector Problem), CVP (Closest Vector Problem) und SBP (Smallest Basis Problem)
zu dieser Komplexitätsklasse. Genauer befasst sich diese Arbeit mit SVP und als
Nebenprodukt mit SBP, dem Problem die kleinste mögliche Basis für ein jeweiliges
Gitter zu finden. Dabei arbeiten wir an einer schnellen und bestmöglichen Lösung.
Kryptosysteme wie GGH [GGH96], NTRU [HPS98], RSA [RSA78] sowie das AjtaiDwork Kryptosystem [AD97] können unter anderem durch eine Lösungsinstanz des
SVP gebrochen werden. Siehe auch in [Ngu99], [JS98] und [NS00] sowie [NS01] für
Anwendungsbeispiele des SVP und ihre Realisierungen. Es ist also möglich, durch
einen effizienten Algorithmus zum Lösen des SVP die Sicherheit dieser Kryptosysteme in Frage zu stellen. Das Lösen des SVP findet nicht nur in der Kryptographie
Anwendung. In Rucksackproblemen wie auch in vielen Themen aus der Mathematik wie beispielsweise in Diophantischen Approximationen und in der Faktorisierung
von Polynomen kommen Lösungen einer SVP Instanz zu tragen.
Da das SVP NP-vollständig ist und damit nur mit exponentieller Laufzeit gelöst
werden kann, wird in der Praxis häufig versucht das γ-SVP zu lösen, welches nicht
nach dem kleinsten Gittervektor sucht, sondern nach einem Gittervektor möglichst
nah am kürzesten Vektor.
Der erste Durchbruch im Auffinden kürzester Gitterbasisvektoren gelang 1982 in einer Arbeit von Lenstra, Lenstra und Lovász [LLL82], welche den ersten Algorithmus
in polynomieller Laufzeit präsentierten. Es handelt sich dabei um den namhaften LLL
Algorithmus. LLL besitzt jedoch einen exponentiellen Approximationsfaktor zu den
kürzesten Vektoren der Basis. Zu dieser Zeit verfolgten viele das Ziel diesen Algorithmus zu optimieren, wodurch viele neue effizientere und leistungsfähigere Algorithmen entstanden. Diese werden in dieser Arbeit kurz zusammengefasst vorgestellt.
Özgür Dagdelen
1
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
1. Einleitung
Ein wichtiger unter diesen Algorithmen ist der BKZ Algorithmus, welcher momentan
die besten Ergebnisse liefert. Dabei verwendet er die Unterfunktion ENUM, welche
den kürzesten Vektor in Teilabschnitten der Basisvektoren findet.
In den 90er Jahren begannen Autoren die Laufzeit der Gitterbasisreduktionsalgorithmen zu verkürzen, indem sie diese Algorithmen parallelisierten. Dabei werden
Teilschritte parallel auf mehreren Prozessoren ausgeführt, um somit Laufzeit zu
sparen. Dabei gibt es verschiedene Möglichkeiten, wie eine solche Parallelisierung
realisiert werden kann. Die Umgebung dabei spielt eine große Rolle. In einem Parallelrechner sind schnellere Kommunikationen zwischen verschiedenen Prozessen zu
erwarten als bei Rechnern, welche durch ein lokales Netzwerk verbunden sind. Die
Ergebnisse und Komplikationen beim Parallelisieren werden in den nächsten Kapiteln diskutiert.
Diese Arbeit wird einen bereits bestehenden Reduktionsalgorithmus für Gitterbasisvektoren parallelisieren, welcher nach derzeitigem Kenntnisstand noch nicht in dieser
Art existiert. Dabei wird ein sequentieller Algorithmus gewählt, der besonders gute
Ergebnisse liefert und durch eine Parallelisierung noch zusätzlich eine Optimierung
der Laufzeit erfahren soll. Wir entschieden uns für den BKZ Algorithmus.
Als nächstes folgt eine kurze Zusammenfassung der Inhalte mit welchen sich die
folgenden Kapiteln beschäftigen.
Im Kapitel 2 werden kurz Begriffe und Definitionen in der Gittertheorie sowie mathematische Grundlagen angesprochen, welche für das Verständnis der weiteren Kapitel
von Bedeutung sind. Hinzu kommen ausgewählte interessante Problemstellungen in
der Gittertheorie, die als Basis für viele Kryptosysteme fungieren.
Eine Übersicht wichtiger sequentieller Algorithmen, welche unter anderem weitere
Erwähnung in den darauf folgenden Kapiteln erlangen, wird im Kapitel 3 gegeben.
Desweiteren ist dort eine kompakte und für diese Arbeit ausgelegte Analyse der
einzelnen Algorithmen zu finden.
In Kapitel 4 werden die ersten Versuche und Ergebnisse paralleler Algorithmen vorgestellt. Zunächst werden die allgemeinen Grundlagen für die Parallelisierung von
Algorithmen angesprochen. Dabei werden Entwicklungsumgebung oder Problemstellungen beim Parallelisieren genannt. Des Weiteren werden die Realisierbarkeit
und Erfolge der gegebenen parallelen Implementierungen vorgestellt.
Der Fokus dieser Arbeit liegt im Kapitel 5. Hier wird ein neuer paralleler Algorithmus
vorgestellt, welcher aus dem sequentiellen Algoritmus BKZ entstanden ist. Dazu
wurden sowohl sequentielle Abschnitte mit bereits bestehenden parallelen Elementen
Özgür Dagdelen
2
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
1. Einleitung
ausgetauscht, als auch weitere neue erstmals vorgestellte parallele Ansätze eingebaut.
Darunter fällt vor allem das parallele Aufzählverfahren ENUMpar. Dieses leitet sich
vom ENUM ab und beschleunigt deutlich die Laufzeit. Diese werden detailiert in
diesem Kapitel präsentiert.
Im Kapitel 6 werden Informationen zur Realisierung des neuen Algorithmus gegeben
und die Evaluation präsentiert.
Im letzten Kapitel folgt abschließend die Zusammenfassung dieser Arbeit und es
werden mögliche Grenzen gezeigt sowie ein Ausblick geboten.
Özgür Dagdelen
3
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
2. Grundlagen der Gittertheorie und Gitterreduktionen
2. Grundlagen der Gittertheorie und
Gitterreduktionen
Hier sollen die Grundkenntnisse über die Gittertheorie und einige mathematische
Operationen vermittelt werden, deren Verständnis für die darauf folgenden Kapitel
essentiell ist. Dazu gehören zuerst einige Notationen, welche über die ganze Arbeit
durchgängig genutzt werden. Hinzu kommen die mathematischen Grundlagen, sowie die für eine Gitterbasisreduktion relevante QR-Zerlegung. Schließlich folgen die
bereits in der Einleitung genannten Problemstellungen in der Gittertheorie. Zum
Schluss werden Begriffe der Gitterreduktionen vorgestellt.
2.1. Notationen
Im Folgenden bezeichnen wir die klassischen Mengen wie in der Mathematik üblich.
Das soll bedeuten, dass N die Bezeichnung für die natürlichen Zahlen ist und analog
dazu bezeichnen Q und R die rationalen bzw. die reellen Zahlen.
Wir verwenden drei verschiedene Arten des Rundens. Sei r ∈ R, dann bezeichnen
wir mit brc das Abrunden und dre das Aufrunden auf die nächste ganze Zahl z ∈ Z.
Häufiger wird man drc vorfinden. Hier wird die erste Stelle nach dem Komma untersucht. Wenn sie kleiner als fünf ist, wird abgerundet, ansonsten aufgerundet. Als
Beispiel erhalten wir die folgenden Ergebnisse: b5.7c = 5, d3.2e = 4, d5.4c = 5, sowie
d5.5c = 6. Im Fall negativer Zahlen ergibt sich d−5.5c = −6 sowie d−5.4c = −5.
Ein Element aij einer Matrix A ∈ Rn×k befindet sich in Zeile i und Spalte j. Wenn
wir jedoch eine ganze Spalte benennen wollen, verwenden wir ai für den i. Spaltenvektor der Matrix. Somit gilt A = (a1 , . . . , ak ) mit a1 , . . . , ak ∈ Rn . Weiter sei A−1
die Inverse, det(A) die Determinante und At die Transponierte der Matrix A.
Zu den wichtigsten Vektoroperationen gehören das Skalarprodukt zweier Vektoren
sowie die Norm eines Vektors. Wir verwenden für das Skalarprodukt der Vektoren
Özgür Dagdelen
4
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
2. Grundlagen der Gittertheorie und Gitterreduktionen
a, b ∈ Rn die Schreibweise ha, bi. Mit kak bezeichnen wir die
Norm des Vektors a,
qP
p
n
2
wobei wir als Norm die euklidische Norm kak = ha, ai =
i=1 ai meinen.
2.2. Gittertheorie
In diesem Abschnitt soll die Terminologie in der Gittertheorie angeführt werden.
Hier werden die wichtigsten Definitionen und Begriffe erläutert. Auf eine detaillierte
Zusammenfassung der Gittertheorie mit weiteren Sätzen und Beweisen wird auf das
Skript [May05] verwiesen.
Definition 2.1. Wir bezeichnen die Menge L ⊂ Rn als Gitter, falls
L=
( k
X
i=1
)
xi bi | xi ∈ Z, i = 1, . . . , k, k ≤ n ,
wobei b1 , . . . , bk ∈ Rn linear unabhängige Vektoren sind.
Mit anderen Worten ist ein Gitter L eine Menge, welche durch die Vektoren
b1 , . . . , bk ∈ Rn aufgespannt wird, wobei als Koeffizienten nur ganze Zahlen in
Frage kommen. Formal ausgedrückt ist ein Gitter L eine diskrete additive abelsche
Untergruppe des Rn . Die Vektoren b1 , . . . , bk ∈ Rn werden dabei als Basis des
Gitters L bezeichnet.
Mit dim(L) bezeichnen wir die Gitterdimension. Sie wird durch die Anzahl der
Basisvektoren des Gitters L bestimmt. Falls das Gitter L ⊂ Rn genau n linear
unabhängige Vektoren besitzt, so spricht man von einem Gitter mit vollem Rang.
Im weiteren Verlauf dieser Arbeit besitzen Gitter einen vollen Rang, sofern wir nicht
explizit darauf hinweisen.
Wie bereits erwähnt, lässt sich jedes Gitter L durch eine Basis B charakterisieren. Jedoch besitzt jedes Gitter keine eindeutige Basis. Jede Basis kann durch eine
unimodulare Transformation verändert werden und bleibt dennoch eine Basis
für das jeweilige Gitter. Unter unimodularen Transformationen einer Basismatrix
verstehen wir
eine Permutation der Basisvektoren und
die Addition eines Vielfachen eines Basisvektors zu einem anderem Basisvek-
tor.
Özgür Dagdelen
5
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
2. Grundlagen der Gittertheorie und Gitterreduktionen
Diese unimodularen Transformationen sind realisierbar, indem die Basis B eines Gitters L mit einer unimodularen Matrix T multipliziert wird. Jede quadratische Matrix
T ist genau dann eine unimodulare Transformationsmatrix, wenn gilt: det(T ) = ±1.
Beispiel 2.1. Sei L ⊂ Rn ein Gitter mit zugehöriger Basismatrix

2 4 6



B = 1 3 3  .
0 0 1
Dann spannen die Spaltenvektoren der Matrizen B 0 und B 00 das selbe Gitter wie B
auf, wobei B 0 und B 00 wie folgt definiert sind:


 

2 4 6
1 −2 −3
2 0 0


 

B 0 = 1 3 3 0 1
0  = 1 1 0
0 0 1
0 0
1
0 0 1
|
{z
}
Determinante=1



2 0 0


 

B 00 = 1 1 0 −1 1 0 = 0 1 0
0 0 1
0 0 1
0 0 1
{z
}
|
2 0 0

1
0 0

Determinante=1
Definition 2.2. Sei L ⊂ Rn ein Gitter mit zugehöriger Basis B ∈ Rn×k . Dann wird
die Gitterdeterminante folgendermaßen definiert:
1/2
det(L) = det(BB t )
Im Falle eines Gitters mit vollem Rang gilt auch det(L) = det(B). Die Gitterdeterminante ist unabhängig von der Wahl der Basis. Eine unimodulare Transformation
der Basis B des Gitters L ändert nicht ihre Gitterdeterminante.
In vielen Anwendungen ist eine kleine“ Basis wünschenswert, also eine Basis mit
”
Basisvektoren, welche bezüglich ihrer Norm klein sind. Mit Hilfe der Orthogonalitätsdefektes kann eine Aussage gemacht werden, inwiefern die Basis B eines Gitters
L gut“ gewählt ist.
”
Definition 2.3. Sei L ⊂ Rn ein Gitter mit zugehöriger Basismatrix B n×k . Dann
definieren wir mit Orthogonalitätsdefekt von B folgende Größe:
Qk
dft(B) =
Özgür Dagdelen
i=1 kbi k
.
det(L)
6
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
2. Grundlagen der Gittertheorie und Gitterreduktionen
Wir bezeichnen eine Basismatrix B 0 besser reduziert als die Basismatrix B eines
Gitters, falls dft(B 0 ) < dft(B) gilt. Wenn wir das Beispiel √
2.1 betrachten, erhalten
√
wir mit det(L) = 2 die Orthogonalitätsdefekte dft(B) =
dft(B 00 )
= 1. Wir schließen daraus, dass die Basis
B 00
5 230
2 ,
dft(B 0 ) =
5
2
und
besser reduziert ist.
Eine obere Grenze der Gitterdeterminante wird durch die Hadamardsche Ungleichung gegeben.
Satz 2.1. Für ein Gitter L ⊂ Rn mit zugehöriger Basismatrix B ∈ Rn×k gilt die
folgende Ungleichung:
det(L) ≤
k
Y
i=1
kbi k
wobei Gleichheit nur erreicht wird, falls die Vektoren bi mit i = 1, . . . , k paarweise
orthogonal zueinander sind.
Aus Beispiel 2.1 sehen wir, dass die Basisvektoren von B 00 paarweise orthogonal sind.
Dadurch lässt sich schließen, dass det(L) = 2 gilt.
In der Praxis und vor allem in dieser Diplomarbeit interessieren wir uns für weitgehend reduzierte und paarweise orthogonale Basisvektoren eines Gitters, welches dem
wichtigem algorithmischem Problem γ-SBP beziehungsweise SBP entspricht.
Die Längen der kürzesten Vektoren eines Gitters werden als sukzessive Minima bezeichnet. In SBP werden genau diese Vektoren mit der Länge der sukzessiven Minima
gesucht oder aber der kürzeste Vektor beim SVP.
Definition 2.4. Sei L ⊂ Rn ein k - dimensionales Gitter. Wir bezeichnen mit
λi (L) für i ≤ k den minimalen Radius um den Nullpunkt, so dass dieser Kreis i
linear unabhänige Vektoren enthält. Man bezeichnet mit λi (L) das i-te sukzessive
Minimum.
Im Beispiel 2.1 erkennen wir leicht an B 00 , dass λ1 = 1, λ2 = 1 und λ3 = 2 gilt.
Im Folgenden führen wir die Definition der Hermite-Konstante ein. Das Ziel vieler Reduktionsalgorithmen liegt darin, diesem Wert durch die Approximation des
kürzesten Gittervektores nahe zu kommen.
Definition 2.5. Die Hermite-Konstante γn ist für n ∈ N definiert:
γn = sup
Özgür Dagdelen
λ1 (L)2 n
L
⊂
R
ist
Gitter
mit
vollem
Rang
.
(det L)2 7
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
2. Grundlagen der Gittertheorie und Gitterreduktionen
Bemerkung 2.1. Es ist bewiesen, z.B. in [Sch01], dass die Hermite-Konstante γn
nach oben beschränkt ist durch
γn ≤
4
n 2
2n
· Γ(1 + ) n ≤
+ O(1) ≈ 0.2342n + O(1).
π
2
eπ
2.3. Orthogonalisierung QR
Durch die Reduktion der Gitterbasisvektoren sucht man nach weitgehend orthogonalen und kurzen Basisvektoren. Mit Hilfe der QR - Zerlegung wird eine gegebene
Basis orthogonalisiert. Genauer wird die Matrix Q gesucht, welche die Bedingung
B = QR erfüllt. Dabei ist R eine obere Dreiecksmatrix, welche in den Diagonalen
nur Einsen besitzt. Diese Matrix können wir als die unimodulare Transformationsmatrix ansehen, mit deren Hilfe wir die gesuchte orthogonale Matrix Q erhalten. Mit
Q haben wir nun unsere gewünschte neue Basis, bei der die Vektoren paarweise orthogonal zueinander sind. Jedoch ist es nicht immer möglich eine ganzzahlige Basis
zu finden, in der alle Basisvektoren paarweise orthogonal sind. Das liegt daran, dass
wir nicht wie im allgemeinen Fall der QR-Zerlegung rationale Zahlen in der Matrix
R verwenden dürfen, sondern uns auf ganze Zahlen beschränken. Aber sie gibt uns
eine Tendenz sich möglichst nahe einer orthogonalen Matrix zu nähern.
Algorithmus 1 zeigt die Gram-Schmidt Methode zur QR - Zerlegung, die unter
anderen die häufigste Verwendung in den Gitterbasisreduktionsalgorithmen findet.
Algorithmus 1 : Gram-Schmidt Orthogonalisierung
Eingabe : Basis B = (b1 , . . . , bn ) ∈ Rn
Ausgabe : Orthogonalisierung B ∗ = (b∗1 , . . . , b∗n ) ∈ Rn
1
2
3
b∗1 := b1
für (i := 2 bis n) tue
für (j := 1 bis i − 1) tue
µi,j :=
4
Ende
5
6
7
b∗i := bi −
Ende
hbi ,b∗j i
2
kb∗j k
Pi−1
∗
j=1 µi,j bj
Die Anzahl der arithmetischen Operationen in der Gram-Schmidt Methode beträgt
O(n).
Özgür Dagdelen
8
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
2. Grundlagen der Gittertheorie und Gitterreduktionen
Wir bezeichnen mit µi,j die Gram-Schmidt Koeffizienten und mit R = (µi,j )1≤i,j≤n
die Matrix der Gram-Schmidt Koeffizienten. Nun lässt sich die Gitterbasis B durch
folgende Transformation orthogonalisieren:
B = (b1 , . . . , bn ) = (b∗1 , . . . , b∗n )RT .
(2.1)
Bei der Realisierung in Computersystemen wird man bei der Ausführung der GramSchmidt Methode die entstehenden Zahlen runden müssen, da nur eine begrenzte Genauigkeit für die verwendeten Datentypen bestehen. Wir verwenden also nur
gerundete Werte. Für jede Zahl existiert daher ein Fehler ε ≤ 2−t , wobei t die
Bit-Genauigkeit angibt. Es muss in Betracht gezogen werden, dass sich der Rundungsfehler mit fortlaufenden Operationen auf diesen Zahlen fortsetzt.
Es wurde bereits gezeigt, dass die Gram-Schmidt Methode numerisch instabil ist
[GV96], sofern nicht genügend Bit-Genauigkeit zur Verfügung steht. Das Ausweichen auf eine höhere Genauigkeit benötigt jedoch wiederum mehr Laufzeit. Dies
ist der Grund, weswegen viele Gitterbasisreduktionsalgorithmen auf andere Methoden der QR-Zerlegung ausweichen. Darunter sind die wichtigsten die Householder
Transformation, als auch die Givensrotation zu nennen.
Givensrotationen sind numerisch stabil, jedoch sollten sie nur mit Gleitkommaarithmetik verwendet werden, da sie mit exakter Arithmetik große Zahlen erzeugen können. Es werden
n(n−1)
2
Zeilenoperationen für eine Orthogonalisierung durch-
geführt. Givensrotationen eignen sich auch gut zum Parallelisieren. Weitere Informationen dazu befinden sich in [Wie94] sowie [Hec95].
Die arithmetischen Operationen liegen für die Householder Transformation in der
Größenordnung 43 k 3 + O(k 2 ), wobei k die Gitterdimension angibt. Bei einer Verwendung einer Bit-Genauigkeit von 53 bleiben Householder Transformationen stabil bis
zur Dimension 400 [KS01b]. Algorithmen zur Householder Transformation werden
in [Sch07] vorgestellt.
Eine weitere Methode zur Orthogonalisierung bildet die sogenannte Cholesky Zerlegung B = RRT . Der Algorithmus wird in [NS05] illustiert. Der Vorteil dieser
Methode liegt darin, dass nur
1 3
3k
+ O(k 2 ) Operationen benötigt werden. Jedoch
benötigt dieses Verfahren die Grammatrix G(b1 , . . . , bn ) = (hbi , bj i)1≤i,j≤n . Diese
Matrix besitzt eine wesentlich höhere Kondition, als die der QR-Zerlegung. Außerdem verlangt die Anwendung der Cholesky Zerlegung eine positiv definite Matrix.
Özgür Dagdelen
9
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
2. Grundlagen der Gittertheorie und Gitterreduktionen
2.4. Algorithmische Probleme in einem Gitter
In der Gittertheorie findet man unter anderem drei wichtige Problemstellungen,
welche NP-vollständig sind. In dieser Passage sollen diese Probleme kurz skizziert
werden.
Definition 2.6. Sei eine Basis B für ein k-dimensionales Gitter L ⊂ Rn gegeben.
Ist nach einem Gittervektor mit der Länge λ1 in L gefragt, so spricht man vom
Kürzester-Vektor Problem ( SVP).
Beim γ-SVP wird nach einem Vektor mit einer Länge von höchstens γ · λ1 gesucht.
Eng verknüpft mit dem SVP ist das Problem, den am nächsten liegenden Gitterpunkt
zu einem gegebenen Vektor in Rn zu finden.
Definition 2.7. Sei eine Basis B für ein k-dimensionales Gitter L ⊂ Rn , sowie
ein (Target-) Vektor t ∈ Rn gegeben. Ist ein Gittervektor u 6= 0 gesucht, welcher die
Bedingung
ku − tk = min kv − tk
v∈L
erfüllt, so spricht man vom Nächster-Vektor Problem ( CVP).
Beim γ-CVP genügt es einen Vektor u 6= 0 zu finden, der folgende Bedingung erfüllt:
ku − tk ≤ γ · min kv − tk .
v∈L
Das SVP kann beispielsweise durch Umformulierung gelöst werden, indem nach einer
Lösung in einer CVP Instanz gesucht wird. Das Gleiche gilt auch im umgekehrten
Fall.
Definition 2.8. Sei ein k-dimensionales Gitter L ⊂ Rn gegeben. Im Kleinste-
Basis Problem ( SBP) wird nach einer Basis B = (b1 , . . . , bd ) gesucht, welche
die folgenden Bedingungen erfüllt:
kb1 k = λ1
..
.
kbk k = λk
Im γ-SBP langt es dem sukzessiven Minima möglichst nahe zu kommen, oder genauer
kbi k ≤ γ · λi für i = 1 . . . k zu erfüllen.
Özgür Dagdelen
10
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
2. Grundlagen der Gittertheorie und Gitterreduktionen
In dieser Arbeit werden sequentielle und parallele Algorithmen vorgestellt, welche
das γ-SVP adressieren und auch eine γ-SBP Lösung als Beiprodukt liefern. Dazu
wird ein neuer paralleler Algorithmus vorgestellt und die Ergebnisse präsentiert.
2.5. Gitterreduktionsbegriffe
Das SBP Problem befasst sich mit dem Auffinden kürzester Basisvektoren. Allein das
Auffinden des kürzesten Vektors in einem Gitter ist schwierig und besitzt zur Lösung
nur Algorithmen mit exponentieller Laufzeit. Außer dem Orthogonalitätsdefekt einer
Basis existieren noch weitere Begriffe der Reduziertheit, um eine Basis bezüglich
ihrer Güte zu beschreiben. Nun werden diese kurz hier zusammengefasst.
Definition 2.9. Sei L ⊂ Rn ein Gitter mit Basis B = (b1 , . . . , bk ) ∈ Rn×k und
zugehöriger Gram-Schmidt Matrix B ∗ = (b∗1 , . . . , b∗k ) ∈ Rn×k , dann gilt die Basis B
als LLL-reduziert mit Reduktionsparameter δ, falls gilt:
|µi,j | ≤
1
2
für 1 ≤ j < i ≤ k
(2.2)
und
2
2
δ b∗i−1 ≤ kb∗i k2 + µ2i,i−1 b∗i−1 für 2 ≤ i ≤ k.
(2.3)
Die Gleichung (2.2) wird auch Größenreduktion genannt.
Durch die Gram-Schmidt Koeffizienten kann leicht die Größenreduktion vorgenommen werden. Dabei muss lediglich die Matrix R aus der QR - Zerlegung von rechts
an die Basis B multipliziert werden. Da jedoch die Gram-Schmidt Koeffizienten keine ganzen Zahlen sind, müssen wir die entsprechenden Werte auf die nächste ganze
Zahl runden (siehe Algorithmus 2).
Algorithmus 2 : Größenreduktion
Eingabe : Basis B = (b1 , . . . , bn ) ∈ Rn , Gram-Schmidt Koeffizienten
(µi,j )1≤i,j≤n
Ausgabe : größenreduzierte Basis B = (b1 , . . . , bn ) ∈ Rn
1
2
3
4
5
für (i := 1 bis n) tue
für (j := i − 1 bis 1) tue
bi := bi − dµi,j c bj
Ende
Ende
Özgür Dagdelen
11
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
2. Grundlagen der Gittertheorie und Gitterreduktionen
Viele Reduktionsalgorithmen setzten diese zwei Axiome (2.2) sowie (2.3) als Vorraussetzung für ihre Ergebnisbasis. Der erste Algorithmus, der diese Bedingungen
erfüllen konnte, war der LLL Algorithmus [LLL82].
Eine stärkere Reduktion einer Basis erhält man durch die Bedingung bekannt als
Hermite und Korkine-Zolotarev (HKZ).
Definition 2.10. Sei L ⊂ Rn ein Gitter mit Basis B = (b1 , . . . , bn ) ∈ Rn×n und
zugehöriger Gram-Schmidt Matrix B ∗ = (b∗1 , . . . , b∗n ) ∈ Rn×n , dann gilt die Basis
B als HKZ-reduziert, falls gilt:
|µi,j | ≤
1
2
für 1 ≤ j < i ≤ n
(2.4)
und
kb∗i k = λ1 (πi (L))
wobei πi : Rn → span(b1 , . . . , bi )⊥
für 1 ≤ i ≤ n,
(2.5)
für 1 ≤ i ≤ n für die orthogonale Projektion
steht.
Die HKZ Bedingung gilt als der stärkste Reduktionsbegriff. Damit ist aber eine hohe
Komplexität aufgrund der NP-Härte des SVP bzw. SBP zu erwarten.
Ein weiterer Begriff der Reduktion wurde in [SE91] eingeführt. Die Idee war dabei
eine HKZ-Reduktion nicht über die ganze Basismatrix durchzuführen, sondern nur
in Blöcken mit festgelegter Blockgröße β.
Definition 2.11. Sei L ⊂ Rn ein Gitter mit Basis B = (b1 , . . . , bn ) ∈ Rn×n und
zugehöriger Gram-Schmidt Matrix B ∗ = (b∗1 , . . . , b∗n ) ∈ Rn×n , dann gilt die Basis
B als β-BKZ-reduziert, falls gilt:
|µi,j | ≤
1
2
für 1 ≤ j < i ≤ n
(2.6)
und
kb1 k ≤ λ1 (Li (b1 , . . . , bmin(i+β,n) ))
für 1 ≤ i < n,
(2.7)
wobei Li die Abkürzung für πi (L) steht.
Viele Algorithmen haben ihre eigene Definition der Reduziertheit. Diese werden hier
aber nicht alle eingeführt. In einer Übersicht im Anhang werden die verschiedenen
Algorithmen mit ihrer Definition der Reduziertheit genannt.
Özgür Dagdelen
12
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
3. Sequentielle Algorithmen zur Gitterbasisreduktion
3. Sequentielle Algorithmen zur
Gitterbasisreduktion
Gitterbasisreduktionsalgorithmen nehmen das Komplexitätsproblem SVP in Angriff.
Jedoch auf Grund der exponentiellen Laufzeit begnügen sie sich mit γ-SVP. Diese
Algorithmen lassen sich in zwei verschiedene Kategorien einordnen. Zum einen gibt
es die Algorithmen, die auf die Optimierung der Laufzeit fokussieren. Sie nehmen dabei in Kauf, nicht die besten Ergebnisse zu erzielen bzw. ein vergleichsweise größeres
γ im γ-SVP zu erhalten. Man erhofft sich dadurch auch Gitter in größeren Dimensionen oder aber auch mit größeren Einträgen reduzieren zu können. Dabei versucht
man beispielsweise das Gitter in Blöcken zu reduzieren und dann zusammenzuführen
oder aber man lockert den Reduktionsbegriff ein wenig, um damit Laufzeit bei
schwierigen Operationen zu sparen. Auf der anderen Seite verfolgen Algorithmen
das Ziel möglichst kurze Gitterbasisvektoren auszugeben. Selbstverständlich funktioniert das nur auf Kosten der Laufzeit. Es muss also darauf geachtet werden, dass
deren Laufzeit nicht exponentiell wird. Des Öfteren existieren Parameter mit denen
man die Güte der Gitterbasisvektoren beeinflussen kann. Je kürzer man die Vektoren
wünscht, desto längere Laufzeiten müssen erwartet werden.
Die kommenden Kapitel behandeln hauptsächlich Gitter L ⊂ Zn , statt L ⊂ Rn . Fast
alle Algorithmen sind dafür konzipiert. Die Komplexität des Problems wird dadurch
nicht wesentlich niedriger, aber auf Grund der Tatsache, dass Kryptosysteme und
viele andere algorithmische Probleme auf ganzzahligen Argumenten basieren, können
wir mit dieser Annahme arbeiten.
Weiter folgen einige sequentielle Gitterbasisreduktionsalgorithmen, welche für die
weitere Arbeit relevant sind oder aber bedeutsame Erfolge in diesem Themengebiet
erlangen konnten.
Özgür Dagdelen
13
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
3. Sequentielle Algorithmen zur Gitterbasisreduktion
3.1. LLL Algorithmus
Den ersten Meilenstein im Reduzieren von Gittervektoren erreichten die drei Wissenschaftler Lenstra, Lenstra und Lovász. In ihrer Arbeit [LLL82] präsentierten sie
den ersten Algorithmus, welcher in polynomieller Laufzeit in der Gitterdimension
terminiert. Der LLL Algorithmus verwendet dabei die Orthogonalisierung (Alg. 1),
sowie die Größenreduktion (Alg. 2) aus dem Kapitel 2.
Algorithmus 3 : LLL - Algorithmus
Eingabe : Basis B = (b1 , . . . , bk ) ∈ Zn×k des Gitters L ⊂ Zn , δ mit
1
4 <δ ≤1
Ausgabe : LLL -reduzierte Basis B = (b1 , . . . , bk ) ∈ Zn×k mit
Reduktionsparameter δ
1
2
3
4
5
6
7
8
9
10
11
12
13
14
i := 2
Berechnung von µ1,1 , µ2,1 , µ2,2
solange i ≤ k tue
Größenreduktion bi
für j := 1 bis i − 1 tue
Aktualisierung des µi,j
Ende
wenn (δ · kbi−1 k2 ≤ µ2i,i−1 · kbi−1 k2 + kbi k2 ) dann
i := i + 1
sonst
vertausche bi , bi−1
i := max(i − 1, 2)
Ende
Ende
Der hier präsentierte LLL-Algorithmus [Fil02] arbeitet in Stufen. Dabei wird in jedem Schleifendurchlauf (Zeilen 3 − 14) der i. Spaltenvektor reduziert und die Gram-
Schmidt Koeffizienten µi,1 , . . . , µi,i−1 aktualisiert. Anschließend wird in den Zeilen
8 − 13 die Tauschbedingung geprüft und falls nötig vorgenommen. Ausserdem gilt
in jedem Schleifenaufruf für i die Invariante, dass die Spaltenvektoren b1 , . . . , bi−1
bereits LLL-reduziert sind. Mit diesem Algorithmus erfüllt die Ausgabebasis die Bedingungen (2.2) sowie (2.3) aus der LLL-Reduziertheit.
Um über die Güte der gewonnenen LLL-reduzierten Basisvektoren eine Aussage machen zu können, ist die folgende Bemerkung nützlich.
Özgür Dagdelen
14
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
3. Sequentielle Algorithmen zur Gitterbasisreduktion
Bemerkung 3.1. Sei B = (b1 , . . . , bk ) eine LLL-reduzierte Basis mit Reduktionsparamter δ. Weiter sei α = (δ − 14 )−1 . Dann gelten zu den Aussagen (2.2) und (2.3)
noch folgende Eigenschaften [Fil02]:
kb1 k2 ≤ α
kbi k
k
Y
i=1
kbi k
2
2
k−1
2
2
det(L) k
≤ αk−1 λi (L)2
2
≤ αj−1 b∗j kbi k2 ≤ α
k(k−1)
2
(3.1)
für i = 1, 2 . . . , k
(3.2)
für 1 ≤ i ≤ j ≤ k
(3.3)
det(L)2 .
(3.4)
Wie bereits erwähnt liegt ein großer Teil des Erfolgs von LLL daran, dass es polynomiell in seiner Laufzeit terminiert. Das beweist der folgende Satz [Wie94]:
Satz 3.1. Sei M = maxi=1...n kbi k2 sowie der Reduktionsparameter δ < 1. Al-
gorithmus 3 benötigt O(n4 log(M )) arithmetische Operationen, um eine gegebene
Gitterbasis b1 , . . . , bn zu reduzieren.
Beweis. Die Idee liegt darin eine obere Schranke für die Anzahl an möglichen durchführbaren Tauschoperationen anzugeben. So lässt sich zeigen, dass die Tauschoperationen höchstens O(n2 logδ M ) mal ausgeführt werden. Da wir pro Tausch maximal O(n2 ) arithmetische Operationen für die Größenreduktion und Orthogonalisierung in einer Stufe vornehmen, folgt damit die Behauptung einer Komplexität von
O(n4 log(M )), siehe [Wie94].
Es existiert noch eine Erweiterung des LLL Algorithmus. Diese wird deep insertion“
”
beziehungsweise Tiefe Einfügungen“ genannt. Dabei fügt man den im Schritt i
”
größenreduzierten Gitterbasisvektor bi direkt in die ihm entsprechende Position j
nach den Höhenquadraten sortiert mit j < i ein, so dass kein weiterer Tausch nach
vorne der Basis stattfinden würde. Um dies zu realisieren, genügt es den Algorithmus
4 mit der Tauschkomponente (Zeile 8 − 13) im LLL Algorithmus auszutauschen.
Dies befördert die gefundenen kurzen Vektoren schneller in die vorderen Positionen,
nimmt damit aber auch eine super-polynomielle Laufzeit in Kauf. Durch Einführung
einer festen Schranke für die Einfügeposition im deep insertion“ bleibt die Laufzeit
”
weiterhin polynomiell.
Özgür Dagdelen
15
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
3. Sequentielle Algorithmen zur Gitterbasisreduktion
Algorithmus 4 : Tiefe Einfügungen
1
2
3
4
5
6
7
8
9
10
11
12
c := kb∗i k2
m := 1
solange m < i tue
wenn (δ · kb∗m k2 ≤ c) dann
c := c − µ2i,m · kb∗m k2
m := m + 1
sonst
(b1 , . . . , bi ) := (b1 , . . . , bm−1 , bi , bm , . . . , bi−1 )
i := max(m − 1, 2)
Ende
Ende
i := i + 1
Mit dieser Methode lassen sich noch bessere Ergebnisse erzielen, als mit dem original
LLL Algorithmus (siehe Bermerkung 3.1). Theoretisch kann die Güte der Ergebnisbasis selbst gewählt werden, jedoch ist auf Grund der Laufzeit nicht jede Güte
realisierbar.
Der LLL Algorithmus arbeitet numerisch stabil, da nur ganze Zahlen in der Basis
verwendet werden und damit die resultierende Orthogonalisierung rationale Zahlen
besitzen. Diese können exakt berechnet werden, wobei wir damit auf das vielleicht
größte Problem dieses Ansatzes kommen. Die exakte Berechnung der Gram-Schmidt
Koeffizienten verlangt viel Laufzeit. Es wäre daher erstrebenswert, die Basis exakt
zu halten, aber alle weiteren Berechnungen approximiert auszuführen. Sicherlich
müssen dafür neue Maßnahmen durchgeführt werden, um die resultierenden Approximationsfehler klein zu halten und keine falschen Tauschs durchzuführen. Somit ist
die numerische Stabilität nicht von vornherein sichergestellt. Es gibt viele Ansätze
basierend auf dem LLL Algorithmus, welche aber mit Approximationen arbeiten,
die die Laufzeit für die Gitterbasisreduktion deutlich verringern. Unter anderem der
folgende Ansatz von Schnorr und Euchner [SE91], der nach seinen Erfindern SE
Algorithmus genannt wird.
Ein anderer Ansatz beschäftigt sich mit einer anderen Möglichkeit die QR-Zerlegung
stabil durchzuführen und verwendet statt der üblichen Gram-Schmidt Methode eine in Kapitel 2.3 angedeutete Householder Transformation. Diese wird hier jedoch
nicht weiter diskutiert. Für weitere Informationen wird auf [Sch06b], sowie [Sch07]
verwiesen.
Özgür Dagdelen
16
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
3. Sequentielle Algorithmen zur Gitterbasisreduktion
3.2. SE Algorithmus
Aus der Tatsache, dass der LLL Algorithmus sehr langsam mit exakter Arithmetik
arbeitet und daher eher ein theoretisch interessanter Algorithmus ist, entstand ein
neuer Algorithmus, welcher diese Schwäche überwindet und mit Gleitkommaarithmetik für die Basis und die Gram-Schmidt Koeffizienten arbeitet. Jedoch müssen
Reduktionen an der Basis exakt vorgenommen werden, um nicht das Gitter zu
verfälschen. Genau wie der LLL Algorithmus besitzt auch der Algorithmus 5 das
selbe stufenweise Vorgehen zum Auffinden kürzester Gitterbasisvektoren.
Im Algorithmus 5 bezeichnen wir die Approximation eines Vektors bi mit b0i . Damit
behalten wir im Speicher sowohl die exakte Basis als auch eine Instanz der Basis in
Gleitkommazahlen. Exakte Berechnungen werden nur in wenigen und notwendigen
Fällen ausgeführt, um damit die kostspieligen Operationen weitgehend zu umgehen.
Dieser Algorithmus kann zu einer Endlosschleife führen, falls die Genauigkeit nicht
hoch genug ist. Aber eine hohe Bit-Genauigkeit verlangsamt wiederum auch die
durchzuführenden Operationen.
Um die Rundungsfehler klein zu halten und folglich die Stabilität des Algorithmus
zu gewährleisten, sind einige zusätzliche Bedingungen zu betrachten. In drei Fällen
lassen sich die Vorbeugungen zu Rundungsfehlern einteilen:
In Zeilen 8 − 12 werden die Skalarprodukte der approximierten Basisvektoren
berechnet. Wenn jedoch ein zu kleines Ergebnis verglichen mit ihrer Länge
auftritt, so müssen die Skalarprodukte exakt berechnet werden. Damit sollen
größere Ungenauigkeiten vermieden werden.
In Zeile 21 wird ein eventuell zu hoher Gram-Schmidt Koeffizient entdeckt und
führt in Zeile 28 zu einer Dekrementierung der Laufvariable. Ein so großer
Koeffizient kann durch fortlaufende Rundungsfehler entstehen und andere Koeffizienten stark beeinflussen.
In Zeile 26 wird die Basis in Gleitkommazahlen aktuell gehalten. Dies ist not-
wendig, sobald eine Reduktion in dieser Stufe stattfand.
Obwohl der Algorithmus von Schnorr und Euchner eine ähnliche Vorgehensweise zur
Reduzierung von Gitterbasisvektoren wie der LLL Algorithmus besitzt, existiert zu
diesem Algorithmus allerdings noch kein Beweis zur polynomiellen Laufzeit. Doch
in der Praxis kann man mit deutlichen Geschwindigkeitsgewinnen gegenüber dem
LLL Algorithmus rechnen.
Özgür Dagdelen
17
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
3. Sequentielle Algorithmen zur Gitterbasisreduktion
Algorithmus 5 : Schnorr Euchner (SE) - Algorithmus
Eingabe : Basis B = (b1 , . . . , bn ) ∈ Zn×k des Gitters L ∈ Zn , δ mit
1
4 <δ ≤1
Ausgabe : LLL-reduzierte Basis B = (b1 , . . . , bk ) ∈ Zn×k mit
Reduktionsparameter δ
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
k := 2
für i := 1 bis n tue b0i

1 ···
 .. . .
(µi,j )1≤i,j≤n :=  .
.
:= (bi )0

0
.. 
.
0 ··· 1
solange k ≤ n tue
wenn (k = 2) dann c1 := kb01 k2
ck := kb0k k2
für j := 1 bis k − 1 tue
−τ
wenn (|b0k T b0j | ≤ 2 2 kb0k k b0j ) dann
s := (bk T bj )0
sonst
s := (b0k T b0j )
Ende
P
µk,j := (s − j−1
i=1 µj,i µk,i ci )/cj
ck := ck − µ2k,j cj
Ende
Fc := false, Fr := false
für j := k − 1 bis 1 tue
wenn (|µk,j | > 21 ) dann
µ := dµk,j c
Fr := true
τ
wenn (µ > 2 2 ) dann Fc := true
µk := µk − µµj
bk := bk − µbj
Ende
Ende
wenn (Fr ) dann b0k := (bk )0
wenn (Fc ) dann
k := max(k − 1, 2)
sonst
wenn (δck−1 ≥ ck + µ2k,k−1 ck−1 ) dann
tausche bk , bk−1
tausche b0k , b0k−1
k := max(k − 1, 2)
sonst
k := k + 1
Ende
Ende
Ende
Özgür Dagdelen
18
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
3. Sequentielle Algorithmen zur Gitterbasisreduktion
3.3. BKZ Algorithmus
Zuvor haben wir die Gitterbasisreduktionsalgorithmen in zwei verschiedene Kategorien aufgeteilt. Der BKZ Algorithmus (Block Korkin Zolotarev) gehört zweifelsfrei
in die Kategorie, welche nach möglichst kurzen Gittervektoren strebt. Eingeführt
wurde der Algorithmus von Schnorr und Euchner [SE91] und baut auf der Idee auf
in Blöcken eine HKZ Reduktion durchzuführen, statt über die komplette Basis. Mit
Blöcken meinen wir eine Auswahl an Gittervektoren aus der Gitterbasis. In Blöcken
mit Blockgröße β kann der exponentielle Anteil der HKZ Reduktion kontrolliert werden. Der Algorithmus 6 beschreibt den BKZ Algorithmus bereits mit Verbesserungen
vorgeschlagen von Hörner in [Hör94].
Algorithmus 6 : BKZ - Algorithmus
Eingabe : Basis B = (b1 , . . . , bk ) ∈ Zn×k des Gitters L ⊂ Zn , δ mit
1
0
4 < δ ≤ 1, δ < 1, 2 < β < k
Ausgabe : β-BKZ-reduzierte Basis B = (b1 , . . . , bk ) ∈ Zn×k mit
Reduktionsparameter δ
1
2
3
4
5
6
7
8
9
10
LLL(b1 , . . . , bk , δ)
z := 0
j := 0
solange z < m − 1 tue
j := j + 1
m := min(j + β − 1, k)
wenn (j = k) dann
j := 1
m := β
Ende
11
(uj , . . . , um , c̄) =ENUM(j, m)
12
h := min(m + 1, k)
13
14
15
16
17
18
19
20
21
wenn (δ 0 · cj > c̄) dann
(bj , . . . , bm ) = BASIS(uj , . . . , um , bj , . . . , bm )
LLL(b1 , . . . , bh , δ) auf Stufe j − 1
z := 0
sonst
z := z + 1
LLL(b1 , . . . , bh , δ) auf Stufe h − 1
Ende
Ende
Zuerst findet eine LLL-Reduktion über der kompletten Basis statt, um die Höhenquadrate kb∗1 k2 , . . . , kb∗n k2 zur Verfügung zu stellen. Diese werden wir für die Un-
Özgür Dagdelen
19
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
3. Sequentielle Algorithmen zur Gitterbasisreduktion
terfunktion ENUM benötigen. Dabei ist die LLL-Reduktion austauschbar, d.h. wenn
es effizientere Alternativen gibt, so können diese statt der LLL-Reduktion benutzt
werden. Danach werden Schritt für Schritt Vektoren gesucht, welche den Ausdruck
Pm Pm
2
∗ 2
m−j+1 \{0} minimieren. Dies übers=j ( i=s xi µi,s ) kbs k für (xj , . . . xm ) ∈ Z
nimmt die ENUM Funktion. Der gewonnene neue Vektor wird in die Basis an Position j eingefügt, sobald er zuvor mit der Methode BASIS umgeformt wurde. Danach
findet wieder eine LLL-Reduktion bis zum Blockende statt, so dass sie aktuell gehalten wird.
Algorithmus 7 : BASIS - Algorithmus
Eingabe : (uj , . . . , um ) ∈ Zm−j−1 , (bj , . . . , bm )
Ausgabe : neue Basisvektoren (bj , . . . , bm )
Pm
neu :=
1 bj
t=j ut bt
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
solange um = 0 tue
m := m − 1
Ende
i := m − 1
solange |um | > 1 tue
solange ui = 0 tue
i := i − 1
Ende
q := dum /ui c
ui := uk − q · ui
um := ualt
i
bm := q · bm + bi
bi := balt
m
Ende
für t = m bis j + 1 tue
bt := bt−1
Ende
bj := bneu
j
Der Algorithmus 8 findet den Vektor mit dem kleinsten Höhenquadrat durch ganzzahlige Linearkombination der gegebenen Vektoren. Je größer dabei die Differenz
der unteren und oberen Schranke beim Aufruf ist, desto kürzere Basisvektoren als
auch längere Laufzeiten können erwartet werden. Wenn der Algorithmus 8 auf die
komplette Basis angewendet werden würde, dann bekäme man als Ausgabe den
Vektor bneu
mit kbneu
1
1 k = λ1 , aber auf Grund dessen, dass der BKZ Algorithmus
mit Approximationen für die Gram-Schmidt Koeffizienten arbeitet, erhält man nur
näherungsweise dieses Ergebnis. Siehe dazu [PS08].
Özgür Dagdelen
20
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
3. Sequentielle Algorithmen zur Gitterbasisreduktion
Die Vorgehensweise von ENUM kann man sich so vorstellen, dass ein Suchbaum mit
Tiefensuche durchlaufen wird und dabei Teilbäume weggelassen werden, wenn sie
nicht zu einem neuen Minimum führen. In den Blättern des Baumes befinden sich
die möglichen Linearkombinationen der Vektoren. Der Algorithmus wird detaillierter
im Kapitel 5.2 beschrieben.
Der hier vorgestellte Algorithmus 8 wird in der Praxis aus Performancegründen
noch weiter entwickelt. Im Gegensatz zum Original werden nicht alle Möglichkeiten
betrachtet, die zu einer kürzeren Lösung führen können, sondern bei kleiner Wahrscheinlichkeit auf Erfolg wird der Teilbaum abgeschnitten. Damit kann unnötiger
Berechnungsaufwand gespart werden. Viele Schnittmöglichkeiten sind in [Hör94] beschrieben.
Die beste bekannte obere Schranke für die Güte der Ausgabebasis wurde in [Sch87]
(n−1)/(β−1)
mit einem Approximationsfaktor ≤ γβ
gezeigt. Jedoch wie auch beim LLL
Algorithmus sind die theoretischen Annahmen viel zu pessimistisch. Theoretisch
kommt der Approximationsfaktor des BKZ Algorithmus dem vom Slice Reduction
aus [GN08a] nahe. Dennoch liegt der BKZ Algorithmus bei der Anwendung mit
seinen Ergebnissen vorne, siehe [GN08b]. Heute gilt BKZ als der Algorithmus, der
in der Praxis den erfolgsversprechendsten Vektor in einem Gitter bzgl. ihrer Länge
liefert.
Jedoch muss mit Blockgrößen β > 25 die Erfahrung gemacht werden, dass in BKZ
die ENUM Aufrufe die meiste Zeit in Anspruch nehmen und nicht mehr in akzeptabler Laufzeit durchführbar ist. Hierin ist unter anderem die Motivation dieser
Arbeit begründet, einen der kürzesten Vektoren liefernden sequentiellen Algorithmus BKZ zu parallelisieren, um den Geschwindigkeitsgewinn möglicherweise auch
dazu zu nutzen, die Blockgröße β zu erweitern und dennoch in praktikabler Laufzeit
zu bleiben.
Özgür Dagdelen
21
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
3. Sequentielle Algorithmen zur Gitterbasisreduktion
Algorithmus 8 : ENUM - Algorithmus
Eingabe : j, m mit 1 ≤ j < m ≤ k, Höhenquadrate cj , . . . , cm
Ausgabe : uj , . . . , um , c̄
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
{** Vektoren wie u besitzen Indizes von j bis m + 1
c̄ := cj
ũ := (1, 0, . . . , 0), u := (1, 0, . . . , 0), δ := (1, 0, . . . , 0)
y := (0, . . . , 0), ∆ := (0, . . . , 0), v := (0, . . . , 0)
s := j, t := j
**}
solange t ≤ m tue
c̃t := c̃t+1 + (ũt + yt )2 · ct
wenn (c̃t < c̄) dann
wenn (t > j) dann
t := t P
−1
yt := si=t+1 ũi µi,t
ũt := d−yt c , vt := d−yt c
∆t := 0
wenn (ũt > −yt ) dann
δt := −1
sonst
δt := 1
Ende
sonst
c̄ := c̃j
u := ũ
Ende
sonst
t := t + 1, s := max(s, t)
wenn (t < s) dann
∆t := −∆t
Ende
wenn (∆t δt ≥ 0) dann
∆t := ∆t + δt
Ende
ũt := vt + ∆t
Ende
Ende
Özgür Dagdelen
22
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
3. Sequentielle Algorithmen zur Gitterbasisreduktion
3.4. Weitere Block basierte Algorithmen
Einige Algorithmen basieren darauf, Reduktionen auf Blöcken auszuführen und diese Ergebnisse zusammenzuführen. Darunter sind Algorithmen wie Semi-Block 2k
Reduktion, Primal Dual Reduktion, Sampling Reduction bzw. RSR sowie SLLL zu
nennen.
Semi-Block 2k Reduktion verfolgt das Ziel möglichst kurze Gittervektoren zu finden.
Es erreicht bei einer Laufzeit mit akzeptablem Parameter k = 24 eine Approximation
des ersten Vektors der Ausgabebasis b1 , . . . , bk mit kb1 k2 ≤ (βk /δ)1/k · λ1 (L)2
wobei k/12 < βk < (1 + k2 )2 ln 2−1/k gilt. Dafür werden HKZ Reduktionen in Blöcken
der Dimension 2k ausgeführt.
Eine etwas bessere Approximation wird mit dem Algorithmus Primal Dual Reduktion erreicht. Die Vorgehensweise hier ist ähnlich. In Blöcken wird sowohl eine HKZ
Reduktion auf der Basis mit Blockgröße k als auch eine auf dem dualen Gitter mit
Blockgröße k durchgeführt. Zusammengefasst sind die Algorithmen Semi-Block 2k
Reduktion, Primal Dual Reduktion und weitere in [Sch06a] zu finden.
In [Sch03] wird eine neue Methode namens Sampling Reduction oder auch Random
Sampling Reduction vorgestellt. Durch [BL06] wurden noch weitere Verbesserungen vorgeschlagen. Der Algorithmus ruft mehrmals eine Unterfunktion SHORT auf,
welche kurze Vektoren mit hoher Wahrscheinlichkeit erzeugt. Oft genug ausgeführt,
können damit immer kürzere Vektoren gefunden werden und damit die gesamte
Gitterbasis miminiert werden. Implementierung und Tests findet man in [Lud05].
Im Gegensatz zu den kürzlich vorgestellten Algorithmen, fällt der SLLL Algorithmus [KS02], [KS01a] und [Sch06b] durch deutlich kürzere Laufzeiten auf. Mit einer
Approximation von kbj k2 ≤ αn−1 δ −7n λ2j für j = 1, . . . , n liegt die Güte der Ausgabebasis jedoch unter der des LLL Algorithmus. Allerdings könnte der SLLL eine
bessere Alternative sein, denn mit O(n4 log n) arithmetischen Operationen ist er
deutlich schneller als die LLL -Alternative. Zudem wird eine weitaus kleinere BitGenauigkeit benötigt. Mit 7n + 2 log M Bits arbeitet SLLL numerisch stabil.
SLLL führt in diesen Blöcken lokale LLL Reduktionen aus, merkt sich die für die Basisumwandlung benötigte unimodulare Transformationsmatrix und führt anschließend
ein globales Update aus. Ausserdem werden die Transformationsmatritzen durch eine Methode TriSeg klein gehalten, damit Gleitkommafehler eingeschränkt werden
können und die genannten Bits für SLLL ausreichen. Eine Implementierung und
Evaluation des SLLL befindet sich in [Fil02].
Özgür Dagdelen
23
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
4. Parallele Algorithmen zur Gitterbasisreduktion
4. Parallele Algorithmen zur
Gitterbasisreduktion
Bevor wir einige parallele Algorithmen zur Gitterbasisreduktion vorstellen, wird
zunächst die Motivation und Idee der Parallelisierung erläutert. In vielen Algorithmen und Operationen werden ihre Rechenschritte üblicherweise sequentiell abgearbeitet, wobei diese Operationen nicht zwingend voneinander abhängig sind. Nehmen
wir beispielsweise einen binären Suchbaum, in welchem wir einen bestimmten Begriff
suchen. In einem ungeordnetem Baum müssten wir so alle Blätter durchsuchen und
hätten im schlimmsten Fall 2n Vergleiche, wobei n die Tiefe des Baumes angibt.
Wenn wir jedoch an der Wurzel entscheiden, dass der linke Teilbaum von einem
Prozessor und der rechte Teilbaum von einem anderem Rechner durchsucht werden
soll, so könnten wir die Laufzeit halbieren. Diese Idee der Parallelisierung löste bei
vielen Wissenschaftlern den Anreiz aus, vorhandene sequentielle Algorithmen mit
Einsatz mehrerer Prozessoren zu beschleunigen.
Obwohl sich das genannte Beispiel des Suchbaums effizient parallelisieren lässt, lassen sich nicht alle Algorithmen so leicht parallelisieren und vor allem kann nicht
erwartet werden, dass mit Einsatz von n Prozessoren auch ein Geschwindigkeitsgewinn von n · 100% vorliegt. Hierfür kann es unterschiedliche Gründe geben. Es
gibt eine Reihe von Operationen, die zwingend der Reihe nach abgearbeitet wer-
den müssen, um die korrekte Ausführung des Algorithmus zu gewährleisten. Mit
anderen Worten sind dies kontextabhängige Operationen, welche erst mit gewissem
Vorwissen ausgeführt werden können.
Nehmen wir als Beispiel die Gitterbasisreduktion. Bevor wir die Basisvektoren reduzieren können, müssen wir zuvor die Orthogonalisierung durchführen. Wir können
die Orthogonalisierung nicht ohne Weiteres dem einen Prozessor und die Reduktion
einem weiteren Rechner zur Abarbeitung übergeben. Daher ist das Parallelisieren immer eine Herausforderung. Die Umformulierung des Algorithmus ist in den meisten
Fällen notwendig, um die zeitkritische Menge an Operationen klein zuhalten. Damit
Özgür Dagdelen
24
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
4. Parallele Algorithmen zur Gitterbasisreduktion
folgt auch die Herausforderung möglichst großen Geschwindigkeitsgewinn zu erhalten, indem sowohl wenige sequentielle Abschnitte vorhanden sind, als auch möglichst
viele Prozessoren zum Einsatz kommen.
Die Parallelisierung besitzt Qualitätskenngrößen: Beschleunigung und Effizienz. Die
Beschleunigung gibt dabei den Geschwindigkeitsgewinn beim Einsatz mehrerer Prozessoren wieder. Mit Effizienz bezeichnen wir die Beschleunigung dividiert durch die
Anzahl der eingesetzten Prozessoren. Mit einer Effizienz von 1.0 wäre ein Algorithmus perfekt parallelisiert worden. In der Regel fällt die Effizienz stetig mit steigender
Prozessoranzahl, da mit einer höheren Anzahl an Prozessoren ein größerer Overhead
verbunden ist.
Wichtig bei der Parallelisierung von Algorithmen ist das verwendete parallele Programmiermodell. Wie bereits erwähnt werden mehrere Berechnungselemente (Prozessoren) in einer Parallelumgebung genutzt. Weiter kann jeder dieser Prozessoren
einen lokalen Speicher besitzen oder aber sie agieren auf einem gemeinsamen Speicher. Dies wiederum zwingt zur Synchronisation der Daten. Im Falle eines lokalen
Speichers wird eine Kommunikation der Daten zwischen den Prozessoren notwendig sein. Zusammengefasst finden sich die folgenden parallelen Programmiermodelle
[Hec95]:
MIMD (Multiple Instruction, Multiple Data) arbeiten mit einer asynchronen
Parallelität, d.h. jeder Prozessor kann seine eigenen Programme ausführen.
Zudem besitzt es eventuell einen gemeinsamen Speicher oder teilt Information
mittels Nachrichtenaustausch mit.
In SIMD (Singe Instruction, Multiple Data) können deutlich mehr Prozessoren
im Gegensatz zu MIMD eingesetzt werden. Allerdings sind dies sehr einfache
Prozessoren, die alle die selben Operationen ausführen. Gesteuert werden diese
Prozessoren von einem Steuerwerk. Im Vergleich zu MIMD besitzen SIMD
Systeme mehr Prozessoren und kürzere Kommunikationszeiten, müssen aber
mit langsameren Prozessoren für arithmetische Operationen arbeiten.
An und für sich ist ein Workstationnetz ein MIMD Modell mit verteiltem
Speicher. So werden mehrere Workstations über ein Kommunikationskanal
verbunden. Der Vorteil in der Verwendung eines Workstationsnetz liegt darin, dass sehr viele Rechner für Berechnungen genutzt werden können. Jedoch
kann man einen hohen Kommunikationsoverhead erwarten. Dieses Modell ist
eher für Programme geeignet, die wenig Kommunikation zwischen Rechnern
benötigen und wo Operationen effizient auf viele Prozessoren verteilen lassen.
Özgür Dagdelen
25
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
4. Parallele Algorithmen zur Gitterbasisreduktion
Heute befinden sich in jedem Haushalt Rechner, die mit Multi-Kern-Prozes-
soren arbeiten. In diesen Rechnern ist es möglich mehrere Prozesse gleichzeitig
auszuführen, indem die Operationen auf die verschiedenen Kerne verteilt werden. Jeder Kern ist eine Prozessoreinheit. Die Einteilung geschieht allgemein
durch das Betriebssystem. Durch ihre Einfachheit und der häufigen Begebenheit dieses Modells wird in dieser Arbeit zum Parallelisieren im Kapitel 5 das
Multi-Kern Modell verwendet.
Nun folgen einige parallele Ansätze für Gitterbasisreduktionsalgorithmen. Darunter der speziell für den parallelen Zweck erfundene Alltausch Algorithmus und die
Parallelisierung des sequentiell schnellen Schnorr-Euchner Algorithmus.
4.1. Alltausch Algorithmus
In einer Arbeit von Gilles Villard entstand der erste Ansatz des Alltausch Algorithmus [Vil92]. Zuerst noch in exakter Arithmetik, kam wenig später von Heckler und
Thiele die Version mit Gleitkommaarithmetik. Der Alltausch Algorithmus ist unter anderem aus der Idee entstanden möglichst viele Prozessoren nutzen zu können,
um die Beschleunigung zu erhöhen. Die Variante der Parallelisierung des SE Algorithmus lässt bis zu n Prozessoren simultan arbeiten, wobei n für die Dimension
des Gitters steht. Der Alltausch Algorithmus soll es möglich machen bis zu n2 und
mehr Prozessoren zu nutzen. Dabei arbeitet er im Gegensatz zum SE nicht mehr in
Stufen. Stattdessen wird die Orthogonalisierung und Längenreduktion über die ganze Matrix ausgeführt, da eine stufenweise Orthogonalisierung keine n2 Prozessoren
einsetzten lässt. Der Algorithmus 9 aus [HT93] soll hier den Alltausch Algorithmus mit Nutzung von Gleitkommazahlen darstellen. Wir bezeichnen dabei mit B 0
die approximierte Basis von B und entsprechend die Vektoren und Gram-Schmidt
Koeffizienten.
Der Alltausch Algorithmus arbeitet in je zwei Stufen (gerade, ungerade). Die Einführung der Phasen ermöglicht es, so viele Vertauschungen simultan auszuführen
ohne in Überschneidungen zu geraten. Im idealen Fall können somit n/2 Prozessoren
gleichzeitig einen Tausch ausführen.
In jeder Phase wird anders als im SE Algorithmus die Orthogonalisierung und
Größenreduktion über die komplette Basis vorgenommen. Somit akkumulieren sich
keine Rundungsfehler, welche möglicherweise im vorherigen Schritt auftraten. Die
Orthogonalisierung selbst wird mittels Givensrotationen realisiert (siehe Kapitel
2.3). Der Vorteil hierbei ist, dass Givensrotationen sowohl numerisch stabil, als auch
Özgür Dagdelen
26
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
4. Parallele Algorithmen zur Gitterbasisreduktion
Algorithmus 9 : Alltausch Algorithmus
Eingabe : Basis B = (b1 , . . . , bk ) ∈ Zn×n des Gitters L ⊂ Zn
Ausgabe : Nach Alltausch reduzierte Basis B = (b1 , . . . , bn ) ∈ Zn×n
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
phase := 0
solange Tausch möglich tue
B 0 = (B)0
Orthogonalisierung mittels Givensrotationen
Größenreduktion der Basis (b1 , . . . , bn ) (siehe Alg. 10)
wenn (phase = 0) dann
2
tausche bi , bi+1 für i ungerade und kb∗i k2 > 2 b∗i+1 phase := 1
sonst
2
tausche bi , bi+1 für i gerade und kb∗i k2 > 2 b∗i+1 phase := 0
Ende
Ende
Orthogonalisierung
Größenreduktion
gut parallelisierbar sind. Dabei können sogar bis zu n2 Prozessoren eingesetzt werden.
Die Größenreduktion muss für eine parallele Ausführung auch angepasst werden.
Für eine Parallelisierung nutzen wir den Algorithmus 10. Hier können bis zu n
Prozessoren gleichzeitig die Spalten reduzieren. Man muss jedoch damit auch in
Kauf nehmen, dass Reduktionen von Spalten durch noch nicht reduzierte Spalten
stattfinden. Das wiederum kann zu größeren Zahlen als im sequentiellen Fall führen,
da nicht mit optimalen Werten reduziert wird.
Algorithmus 10 : Größenreduktion zur parallelen Ausführung
1
2
3
4
5
6
7
für e := 2n − 1 bis 3 tue
für j := max(1, e − n) bis (e − 1)/2 tue
k := e − j
bk := bk − dµj,k c · bj
µk := µk − dµj,k c · µj
Ende
Ende
Hier muss die Matrix spaltenweise auf die Prozessoren verteilt sein. Den Schritt in
den Zeilen 3−5 führt jeder Prozessor für sich selbst aus und tauscht mit den anderen
Prozessoren die aktualisierten Spalten aus.
Özgür Dagdelen
27
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
4. Parallele Algorithmen zur Gitterbasisreduktion
Implementierungen und Tests für die parallele Umsetzung des Alltausch Algorithmus
sind [Hec95] und [Wie94] zu entnehmen.
Bemerkung 4.1. Die Komplexität der Orthogonalisierung und Größenreduktion
pro Phase im Alltausch Algorithmus liegt bei
O(n3 ) arithmetischen Operationen in Verwendung von einem Prozessor
O(n2 ) arithmetischen Operationen in Verwendung von O(n) Prozessoren
O(n) arithmetischen Operationen in Verwendung von O(n2 ) Prozessoren
Nun müssen wir noch die Anzahl maximal auftauchender Phasen bestimmen, um
eine Aussage über die Kompexität des kompletten Alltausch Algorithmus machen zu
können. Der folgende Satz gibt eine obere Schranke für das Auffinden eines genügend
kurzen Vektors.
Satz 4.1 ([Hec95]). Nach höchstens n log M Alltauschphasen gilt
kb∗1 k2 · kb∗2 k2 · . . . · kb∗i k2 ≤
für 1 ≤ i ≤ n und c =
2i
4 i(n−i)
· c 2 · (det L) n
3
(4.1)
32
9 .
Beweis. Siehe Beweis zu Satz 3.10 aus [Hec95].
Setzt man i = 1 im Satz 4.1, so findet man einen kurzen Vektor b1 ∈ L mit
r
kb1 k ≤
1
4 n−1
· c 4 (det L) n
3
in O(n log
qM ) Alltauschphasen. Der Approximationsfaktor des Alltausch Algorithmus mit
4
3
·c
n−1
4
= 0.84 · 1.373n ist verglichen mit dem LLL Algorithmus für δ =
3
4
mit 0.84 · 1.189n (siehe Glg. (3.1)) etwas höher.
Damit kommen wir zum nächsten Satz über die Komplexität des Alltausch Algorithmus.
Satz 4.2. Der Alltausch Algorithmus benötigt zum Finden eines kurzen Vektors
O(n4 log M ) arithmetische Operationen in Verwendung von einem Prozessor
O(n3 log M ) arithmetische Operationen in Verwendung von O(n) Prozessoren
O(n2 log M ) arithmetische Operationen in Verwendung von O(n2 ) Prozessoren
Özgür Dagdelen
28
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
4. Parallele Algorithmen zur Gitterbasisreduktion
Beweis. Mit der Tatsache, dass n log M Alltauschphasen genügen, um einen kurzen Vektor zu erhalten und mit Bemerkung 4.1 lassen sich leicht die angegebenen
arithmetischen Operationen zeigen.
Für eine korrekte Ausführung des Tauschs reicht es nicht aus nur die Tauschbe
√ dingung kb∗i k > 2 b∗i+1 zu erfüllen. In exakter Arithmetik führt die Bedin-
gung immer zu einem sinnvollen Tausch, jedoch kann in Gleitkommaarithmetik die
Tauschbedingung auf Grund von Rundungsfehlern erfüllt werden und führt dement-
sprechend zu einer Verschlechterung der Ergebnisbasis. Für die richtige Ausführung
des Tauschs muss zur Tauschbedingung noch zusätzlich
c·n·u·
√
M ≤ kbi k
mit c = 300, n die Anzahl an Basisvektoren, u = 2−τ die Maschinenzahl und
M = maxi=1...n bi gelten ([Hec95], Satz 3.15).
1998 präsentierte Susanne Wetzel [Wet98] einen neuen Ansatz, um den Alltausch
Algorithmus zu generalisieren. Statt wie im Alltausch Algorithmus phasenweise
Tauschvorgänge mit je 2 Vektoren in n/2 parallenen Prozessen durchzuführen, wird
versucht in l Blöcken der Länge m lokale LLL Reduktionen parallel auszuführen.
Anschließend werden Grenzübergänge für mögliche Vertauschungen untersucht. Sei
erwähnt, dass mit m = 2 der original Alltausch Algorithmus und mit m = n der LLL
Algorithmus zu Stande kommt. Diese Version von [Wet98] besitzt die selbe asymptotische Komplexität wie der Alltausch Algorithmus. Nach den Simulationen zu
Folge werden keine besonderen Erfolge damit erzielt. Demzufolge würde man mit
Blockgröße 2 die größte Beschleunigung erfahren.
Der Ansatz vom Alltausch Algorithmus ist vielversprechend, aber die Komplexitäten
die hier versprochen werden, sind nur mit Vorsicht anzunehmen. Tatsächlich befindet
sich die Anzahl arithmetischer Operationen in dieser Komplexitätsklasse. Allerdings
sind für die Laufzeitbestimmung von parallelen Algorithmen außer den arithmetischen Operationen auch die Kommunikationszeit essentiell und des Öfteren maßgebend. Genaueres lässt sich in [Hec95] nachlesen. Desweiteren fanden die Tests und
Ideen auf Gittern statt, welche für heutige Verhältnisse kleine Dimensionen besitzen. Ob auch Gitter mit Dimensionen größer als 500 realsitisch mit dieser Anzahl an
arithmetischen Operationen ausgeführt werden können, scheint unrealistisch. Zumal
n2 Prozessoren in diesem Fall einer Prozessoranzahl von 250000 entsprechen würden.
Daher sehen wir diesen Algorithmus auch als eher theoretisch an, zumindest in ihren
Versprechungen paralleler Laufzeit.
Özgür Dagdelen
29
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
4. Parallele Algorithmen zur Gitterbasisreduktion
4.2. Die parallele Version des SE Algorithmus
Der SE Algorithmus aus Kapitel 3.2 ist bereits ein schneller Algorithmus. Er arbeitet
im Gegensatz zum Alltausch Algorithmus in Stufen und führt für die Orthogonalisierung und Größenreduktion pro Stufe O(n2 ) arithmetische Operationen aus. Offensichlich könnte man auf die Idee kommen mit ausreichender Menge an Prozessoren
diese Schritte in O(n) parallel ausgeführten arithmetischen Schritten durchzuführen.
Dazu existieren bereits zwei vorgestellte Modelle. Das eine Modell basiert auf einem
MIMD Programmiermodel und beschreibt die Vorgehensweise und notwendingen
Kommunikationen in den Arbeiten [Hec95] und [Wie94]. Im November 2008 wurde
in einem technischen Bericht [BW08] ein neuer Ansatz der Parallelisierung des SE
Algorithmus vorgestellt. Das hier verwendete Programmiermodel basiert auf Multikern Prozessoren. Die Implementierung dieses Ansatzes fand auf einem System mit
vier Kernen statt.Wir fassen hier beide Ansätze zusammen und gehen genauer auf
letzteren in Kapitel 5.1 ein.
Wir stellen nun das erste Modell in einer MIMD Programmierumgebung vor. In diesem Modell wird auf ein lineares Feld von Prozessoren zur Kommunikation zurückgegriffen. Dies ist eine sehr einfache Verbindungsstruktur und hat zufolge, dass Nachrichten von einem Ende zum anderen Ende der Prozessoren alle innerhalb liegenden
Prozessoren überqueren muss. Diese Eigenschaft muss genutzt werden, damit jeder
Prozessor aus den gesendeten Nachrichten eine ihm hilfreiche Information entnehmen kann.
Wie bereits erwähnt liegt die Herausforderung darin die Orthogonalisierung und
Größenreduktion pro Stufe mit bis zu n Prozessoren zu parallelisieren und dabei die
Kommunikationskosten so gering wie möglich zu halten. Wir gehen bei der Darstellung dieses Modells wie folgt vor: Seien wir in der momentanen Stufe k ≤ n. Zuerst
fassen wir den Wissensstand jedes Prozessors in dieser Stufe k zusammen. Darauf
folgend präsentieren wir die Vorgehensweise der Berechnung der Skalarpodukte, sowie der Gram-Schmidt Koeffizienten µj,k für j = 1, . . . , k − 1. Zu jedem Schritt
stellen wir ein kleines Beispiel mit n = 6 und k = 5 in einem Ablaufdiagramm dar.
Zuletzt zeigen wir die parallele Ausführung der Größenreduktion.
Wissensstand: Zu Beginn der Stufe k besitzen die Prozessoren 1, . . . , n folgende
Information:
Özgür Dagdelen
30
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
4. Parallele Algorithmen zur Gitterbasisreduktion
Prozessor 1
den Wert Index k
Zeile 1 der Gitterbasis in genauer Darstellung b1,1 , . . . , bn,1
sowie in Gleitkommadarstellung b01,1 , . . . , b0n,1
Zeile 1 der Gram-Schmidt Koeffizientenmatrix µ2,1 , . . . µk−1,1
Höhenquadrat kb∗1 k2
den Wert kb01 k2
..
.
Prozessor k − 2
..
.
den Wert Index k
Zeile k − 2 der Gitterbasis in genauer Darstellung
b1,k−2 , . . . , bn,k−2
sowie
in
Gleitkommadarstellung
b01,k−2 , . . . , b0n,k−2
Zeile k − 2 der Gram-Schmidt Koeffizientenmatrix µk−1,k−2
Spalte
k − 2
der
Gram-Schmidt
Koeffizientenmatrix
µk−2,1 , . . . , µk−2,k−3
2
Höhenquadrat b∗k−2 2
den Wert b0k−2 Prozessor k − 1
den Wert Index k
Zeile k − 1 der Gitterbasis in genauer Darstellung
b1,k−1 , . . . , bn,k−1
sowie
in
Gleitkommadarstellung
b01,k−1 , . . . , b0n,k−1
Spalte
k − 1
der
Gram-Schmidt
Koeffizientenmatrix
µk−1,1 , . . . , µk−1,k−2
2
Höhenquadrat b∗k−1 Prozessor k
den Wert Index k
Zeile k der Gitterbasis in genauer Darstellung b1,k , . . . , bn,k
sowie in Gleitkommadarstellung b01,k , . . . , b0n,k
..
.
Prozessor n
..
.
den Wert Index k
Zeile n der Gitterbasis in genauer Darstellung b1,n , . . . , bn,n
sowie in Gleitkommadarstellung b01,n , . . . , b0n,n
Özgür Dagdelen
31
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
4. Parallele Algorithmen zur Gitterbasisreduktion
Zeit t
k+1 arithmetische Operationen
Berechnung
Prozessor 1
JA
b5,1 · b1,1
..
.
b5,1 · b5,1
b4,1 · b4,1
kb∗5 k
Prozessor 2
Berechnung
JA
b5,2 · b1,2
..
.
b5,2 · b5,2
b4,2 · b4,2
kb∗5 k
Prozessor 3
Berechnung
JA
b5,3 · b1,3
..
.
b5,3 · b5,3
b4,3 · b4,3
kb∗5 k
Prozessor 4
Berechnung
JA
b5,4 · b1,4
..
.
b5,4 · b5,4
b4,4 · b4,4
kb∗5 k
Prozessor 5
Berechnung
JA
b5,5 · b1,5
..
.
b5,5 · b5,5
b4,5 · b4,5
Berechnung
Prozessor 6
b5,6 · b1,6
..
.
b5,6 · b5,6
b4,6 · b4,6
Abbildung 4.1.: Neuberechnung der Skalarprodukte
In der Stufe k findet zuerst die Orthogonalisierung (Algorithmus 11) statt. Dazu
werden anfangs die Skalarprodukte berechnet (Zeile 2-6). Die Vorgehensweise zur
Berechnung der Skalarprodukte in der Parallelisierung unterscheidet sich von der
sequentiellen Version. Dabei geht man wie folgt vor:
1. Jeder Prozessor i mit 1 ≤ i ≤ n berechnet für die Skalarprodukte
D
b0k , b0j
E
mit j < k nur die Multiplikationen der i-ten Komponente. Anschließend findet
eine Aufsummerierung der Werte duch eine Multinode-Akkumulation“ statt.
”
2. Nach den Berechnungen sendet Prozessor k den Wert kb0k k2 zum Prozessor 1
über Prozessoren k − 1, . . . , 2.
3. Prozessor 1 entscheidet, ob eine Neuberechnung nötig ist:
ja → Sende ein ”ja” zu Prozessoren 2, . . . , n, so dass alle Prozessoren das
Skalarprodukt mit exakten Werten neuberechnen.
nein → Keine Operation ausführen.
Özgür Dagdelen
32
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
4. Parallele Algorithmen zur Gitterbasisreduktion
Algorithmus 11 : Orthogonalisierungsabschnitt des SE Algorithmus
1
2
3
4
5
6
7
8
9
für j := 1 bis k − 1 tue
wenn (|b0k T b0j | ≤ 2
−τ
2
kb0k k b0j ) dann
s := (bk T bj )0
sonst
s := (b0k T b0j )
Ende
P
µk,j := (s − j−1
i=1 µj,i µk,i ci )/cj
2
ck := ck − µk,j cj
Ende
Die Abbildung 4.1 zeigt die Vorgehensweise für ein Beispiel, falls eine Neuberechnung
der Skalarprodukte notwendig war.
Weiter müssen die Gram-Schmidt Koeffizienten und die Höhenquadrate aktualisiert
werden. Dies geschieht im Algorithmus 11 in den Zeilen 7 − 8. Da jeder Prozessor
j ≤ k − 1 bereits die Gram-Schmidt Koeffizienten µj,i für i < j kennt, kann die
parallele Berechnung der µk,j für 1 ≤ j ≤ k − 1 wie in Abbildung 4.3 präsentiert
stattfinden.
Die Orthogonalisierung in der Stufe k ist damit abgeschlossen. Nun muss noch die
Größenreduktion stattfinden. Die Reduktion findet gemäß Algorithmus 12 statt.
Die parallele Vorgehensweise und die Kommunikation zwischen den Prozessoren ist
durch die Ablaufdiagramme in 4.2 illustiert.
Algorithmus 12 : Größenreduktionsabschnitt des SE Algorithmus
1
2
3
4
5
6
7
8
9
für j := k − 1 bis 1 tue
wenn (|µk,j | > 12 ) dann
µ := dµk,j c
Fr := true
τ
wenn (µ > 2 2 ) dann Fc := true
µk := µk − µµj
bk := bk − µbj
Ende
Ende
Das folgende Beispiel mit n = 6 und k = 5 soll den Ablauf der parallelen Größenreduktion skizzieren (siehe Abbildung 4.4).
Özgür Dagdelen
33
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
4. Parallele Algorithmen zur Gitterbasisreduktion
Prozessor k
Prozessor k-1
Prozessor i
Start
µ = ⌈µk,k−1 ⌋
R e d u z i e r e µk,k−1
R e d u z i e r e bk,k−1
Prüfe Tauschbedingung
k, k − 1
nein
Nachricht von
Prozessor i+1
empfangen?
ja
Sende an Prozessor i-1, i+1
den Wert µ
Tasch ja/nein
Warte auf Ereignis
Sende Nachricht
weiter an
Prozessor i-1
|µ| > 0 . 5
nein
(a)
ja
Prozessor i
µk,i
bk,i
Reduziere
Reduziere
nein
Nachricht von
Prozessor i-1
empfangen?
Nachricht von
Prozessor i-1
empfangen?
nein
|µ| > 0 . 5
ja
ja
nein
ja
Falls nötig:
Neuberechnung
Falls nötig:
Neuberechnung
bk,i
Sende Nachricht
weiter an
Prozessor i+1
bk,i
µ = ⌈µk,i ⌋
R e d u z i e r e µk,i
R e d u z i e r e bk,i
Sende Nachricht
weiter an
Prozessor i+1
Sende Nachricht
an Prozessor i-1, i+1
den Wert
µ
Warte auf Ereignis
Warte auf Ereignis
(b)
(c)
Abbildung 4.2.: Ablaufdiagramme:
(a) beschreibt die Startoperationen
(b) die Aktionen eines Prozessors i mit i ≥ k − 1
(c) die Aktionen eines Prozessors i mit 1 ≤ i < k − 1
Özgür Dagdelen
34
Özgür Dagdelen
Prozessor 6
Prozessor 5
Prozessor 4
Prozessor 3
Prozessor 2
Prozessor 1
µ5,1
µ5,1 · b21
µ25,1 · b21
Berechnung
N1
N1
N1
N1
N1
−µ2,1 · µ5,1 b21
µ5,2 := µ5,2
Berechnung
N2
N3
Abbildung 4.3.: Parallele Berechnung der µk,j
−µ4,2 · µ5,2 b22
−µ4,3 · µ5,3 b23
µ5,4 := µ5,4
−µ4,1 · µ5,1 b21
Berechnung
µ5,4 := µ5,4
N3
Berechnung
N3
µ5,4 := µ5,4
µ5,3
µ5,3 · b23
µ25,3 · b23
Berechnung
Berechnung
N2
−µ3,2 · µ5,2 b22
µ5,3 := µ5,3
−µ3,1 · µ5,1 b21
Berechnung
N2
µ5,3 := µ5,3
N2
Berechnung
µ5,2
µ5,2 · b22
µ25,2 · b22
Berechnung
µ5,3
µ5,3 · b23
µ25,3 · b23
Berechnung
N4
N4
Zeit t
kb∗5 k
Berechnung
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
4. Parallele Algorithmen zur Gitterbasisreduktion
35
Özgür Dagdelen
Prozessor 6
Prozessor 5
Prozessor 4
Prozessor 3
Prozessor 2
Prozessor 1
kb∗5 k
µ5,4 , b5,4
Tausch
ja/nein
⌈µ5,4 ⌋
Berechnung
N4
N4
N4
N4
N4
N4
µ5,3 , b5,3
Reduziere
⌈µ5,3 ⌋
N3
Reduktion nötig!
N3
N3
N3
N3
N3
b5,4
b5,6
Berechnung
wenn nötig:
b5,5
µ5,2 , b5,2
Reduziere
⌈µ5,2 ⌋
N2
Reduktion nötig!
Berechnung
wenn nötig:
Berechnung
wenn nötig:
µ5,2 , b5,2
Berechnung
wenn nötig:
µ5,1 , b5,1
Berechnung
wenn nötig:
N2
N2
N2
b5,3
µ5,1 , b5,1
Reduziere
⌈µ5,1 ⌋
N2
b5,4
b5,6
Berechnung
wenn nötig:
b5,5
Berechnung
wenn nötig:
N1
Reduktion nötig!
Berechnung
wenn nötig:
Berechnung
wenn nötig:
N2
µ5,1 , b5,1
Berechnung
wenn nötig:
Abbildung 4.4.: Größenreduktion für n = 6 und k = 5
b5,6
Berechnung
wenn nötig:
b5,5
Berechnung
wenn nötig:
µ5,3 , b5,3
Berechnung
wenn nötig:
µ5,2 , b5,2
Berechnung
wenn nötig:
µ5,1 , b5,1
Berechnung
wenn nötig:
Zeit t
N1
N1
N1
b5,2
N1
b5,3
N1
b5,4
N2
b5,6
Berechnung
wenn nötig:
b5,5
Berechnung
wenn nötig:
Berechnung
wenn nötig:
Berechnung
wenn nötig:
Berechnung
wenn nötig:
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
4. Parallele Algorithmen zur Gitterbasisreduktion
36
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
4. Parallele Algorithmen zur Gitterbasisreduktion
Komplexität. Für die Orthogonalisierung benötigt man die Berechnung der Skalarprodukte und die Bestimmung der Gram-Schmidt Koeffizienten. Sofern keine Neuberechnung der Skalarprodukte notwendig ist, benötigt man k + 1 arithmetische
Operationen mit einer abschließenden Aufsummierung der Werte in n − 1 Schritten.
Im Falle einer notwendigen Neuberechnung der Skalarprodukte müssen n + k − 1
Nachrichten zur Kommunikation gesendet werden bevor der Prozessor n die Berechnung des exakten Skalarproduktes starten kann. Dazu werden wieder k + 1
arithmetische Operationen durchgeführt. Für die parallele Berechnung der GramSchmidt Koeffizienten µk,j muss zunächst der Prozessor k für die erste Nachricht
k − 1 Kommunikationsschritte warten. Danach folgen in gleichem Zeitabschnitten
k − 1 Nachrichten bis der Prozessor k mit der Berechnung von kb∗k k2 beginnen und
damit die Orthogonalisierung abschließen kann. Nach jeder Nachricht müssen die
Prozessoren j mit j < k konstant viele artihmetische Operationen ausführen. Somit lässt sich die Orthogonalisierung in n + 6k arithmetischen Operationen1 auf
Gleitkommazahlen sowie mit n + 6k Kommunikationsaustauschen realisieren.
Für die Größenreduktion muss Prozessor 1 zuerst k−2 Kommunikationsschritte warten und dann k−2 Nachrichten nacheinander annehmen, bis seine Größenberechnung
beginnen kann. Seine Daten müssen bis zum Prozessor n gesendet werden. Insgesamt
dauert die Größenreduktion daher 2(k − 2) + n Zeitschritte1 .
Die Gesamtkosten1 in einer Stufe k sowohl für die Orthogonalisierung, als auch für
die Größenreduktion unter Verwendung von n Prozessoren liegen bei
3n + 10k arithmetischen Operationen auf Gleitkommazahlen,
2n + 2k arithmetischen Operationen auf exakten Werten, sowie
2n + 9k Kommunikationsschritten.
Somit wären wir nun bei einer Komplexität von O(n) für die Orthogonalisierung
sowie Größenreduktion pro Stufe angelangt. Wir haben damit eine lineare Beschleunigung gegenüber der seriellen Ausführung unter Verwendung von n Prozessoren
erreicht.
Es existieren nach unserem Kenntnisstand bisher keine Implementierungen dieses
Ansatzes. Somit können wir auch keine Aussagen darüber treffen, welche Beschleunigung wir in der Praxis zu erwarten hätten und inwieweit die Kommunikationskosten
die Laufzeit beeinflussen.
1
Wir vernachlässigen konstante Terme und gehen von keiner Neuberechnung der Skalarprodukte
aus.
Özgür Dagdelen
37
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
4. Parallele Algorithmen zur Gitterbasisreduktion
Der zweite Ansatz. Die vermutlich erste Implementierung einer parallelen Version
des Schnorr-Euchner Algorithmus wurde in [BW08] vorgestellt. Unter Verwendung
einer Multikern Prozessor Architektur erfolgte die parallele Gitterbasisreduktion unter Verwendung eines gemeinsames Speichers. Mittels POSIX Threads wurden die
vorhandenen Prozessorkerne zur Ausführung von Programmcode in Gang gesetzt.
Die Nutzung eines gemeinsamen Speichers kann Kommunikationskosten verringern,
da die Daten nicht ausgetauscht werden müssen, damit jeder Prozessor auf den
neuesten Stand bleibt. Aber es muss dennoch eine Synchronisation der Daten stattfinden, um zu verhindern, dass parallel auf ein Element der Basismatrix oder der
Gram-Schmidt Koeffizientenmatrix geschrieben wird. Dafür werden Sperren (barriers) und Mutexe verwendet, welche beim Einsatz die Datenelemente blockt, wenn
ein Zugriff darauf erfolgt. Jedoch sollten diese mit Vorsicht verwendet werden, da
der Einsatz vieler dieser Bausteine eine Verzögerung vorruft und damit eine Laufzeit
bestimmende Operation wird.
Die Funktionsweise ist der des vorherigen ähnlich. In jeder Stufe wird zuerst der
Skalarproduktabschnitt parallel ausgeführt, gefolgt von der Bestimmung der GramSchmidt Koeffizienten und zuletzt die Reduktion. Die Vorgehensweise für die drei
Abschnitte wird hier zusammengefasst vorgestellt.
Die Skalarproduktberechnung findet nach Algorithmus 11 (Zeile 1 − 6) statt. Hier
müssen k − 1 Skalarprodukte berechnet werden. Da die Berechnungszeiten für Skalarprodukte auf Grund von möglichen Neuberechnungen oder verschiedenen Zahlen-
größen stark variieren können, ist es sinnvoll statt alle Skalarproduktberechnungen
auf die Anzahl vorhandener Prozessoren aufzuteilen, Pakete von einer festen Anzahl
ssp von Skalarprodukten zu erstellen und diese von den Prozessoren ausführen zu
lassen. So müssen Prozessoren seltener und kürzer auf andere Prozessoren warten,
um mit der Orthogonalisierung fortzufahren. Anders wie zuvor müssen im Falle einer
notwendigen Neuberechnung nicht alle Prozessoren die Neuberechnungen ausführen.
Das ist wiederum ein Laufzeitgewinn.
Die Orthogonalisierung in Stufe k unterscheidet sich von der vorherigen Version.
Auch hier wird eine Schranke so für die sequentielle Berechnung der Gram-Schmidt
Koeffizienten µk,j für j = 1 .D. . k − 1E verwendet. Sei in Rk,j mit 1 ≤ j < k ≤ n
der Wert des Skalarprodukts b0k , b0j festgelegt. Die Vorgehensweise ist dabei wie
folgt:
2
1. Berechne sequentiell µk,1 , . . . , µk,so und die Höhenquadrate kb∗1 k2 , . . . , b∗so 2. Verteile die Teilsbearbeitungen der Rk,so +1 , . . . , Rk,k−1 gleichmäßig auf alle
Prozessoren. Teilsbearbeitungen sind hier als die Reduktionen der Rk,j mit
Özgür Dagdelen
38
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
4. Parallele Algorithmen zur Gitterbasisreduktion
j > so nur unter Verwendung der µk,1 , . . . , µk,so und der Rk,1 , . . . , Rk,so zu
Po
Rk,m µj,m .
verstehen, d.h. Rk,j = Rk,j − sm=1
3. Nun werden die Berechnungen der Rk,so +1 , . . . , Rk,2so sequentiell abgeschlossen
und die µk,so +1 , . . . , µk,2so berechnet.
4. Nun wird in Schritt 2 wieder angesetzt, wobei eine Verschiebung um so stattfand. Nun werden die Teilsbearbeitungen der Rk,2so +1 , . . . , Rk,k−1 mit Hilfe von
Rk,so +1 , . . . , Rk,2so und µk,so +1 , . . . , µk,2so parallel auf den Prozessoren durchgeführt.
5. Die letzten 2 Schritte wiederholen sich bis alle Gram-Schmidt Koeffizienten
berechnet wurden.
Eine Veranschaulichung für die parallele Berechnung einer Zeile der Matrix R sowie
für die Gram-Schmidt Koeffizienten gibt die Abbildung 4.5. Hier wird die Schranke
so = 5 verwendet und die Gram-Schmidt Berechnung der Stufe 20 dargestellt, wobei
4 Prozessoren zur Verfügung stehen.
Die Größenreduktion teilt sich in zwei Abschnitte. In dieser Version werden die
Reduktionen der Gram-Schmidt Koeffizienten getrennt von den Reduktionen der
Gitterbasisvektoren ausgeführt. Zuerst werden die Gram-Schmidt Koeffizienten µ
reduziert. Dies verlangt eine Speicherung der dµc für die folgende Reduktion des
Gitterbasisvektors bk .
Abbildung 4.5.: Parallele Berechnung der 20. Zeile der Matrix R und den GramSchmidt Koeffizienten
Özgür Dagdelen
39
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
4. Parallele Algorithmen zur Gitterbasisreduktion
Die Vorgehensweise der Aktualisierung der Gram-Schmidt Koeffizienten ist der Orthogonalisierung ähnlich. Sie unterscheidet sich lediglich beim Verteilen der Elemente
an die vorhandenen Prozessoren. Auch hier wird eine Schranke sµ verwendet, welche
den sequentiellen Anteil des Algorithmus bestimmt. Die Reduktion des Gittervektors geschieht zeilenweise. Jeder Prozessor aktualisiert die ihm zugeteilen Zeilen des
Gittervektors.
Algorithmen und Implementierungen für die Version des parallelen SE Algorithmus
können aus [BW08] entnommen werden.
Getestet wurde die Implementierung auf Matrizen mit Zahlen der Bitlänge 1000.
Zudem wurden für die Approximationen Datentypen für Gleitkommaarithmetik mit
einer Bit-Genauigkeit von 128 verwendet, welches um einiges langsamer als der bevorzugte Datentyp double ist. Diese Wahl ist jedoch für die Anwendung der parallelen Algorithmen vorteilhaft, da die Ausführungszeiten für jeden Prozessor lang
genug sind, dass der entstehende Overhead durch die parallele Implementierung vernachlässigt werden kann. Eine Verwendung des Datentyps double beschleunigt die
Operationen auf den approximierten Werten deutlich, so dass eine Parallelisierung
sogar eine Verzögerung und damit eine längere Laufzeit erzeugen kann. Entsprechend [BW08] wurden mit 2 Prozessoren eine Beschleunigung von 1.75 und mit 4
Prozessoren eine Beschleunigung von 3 erreicht. Das entspricht einer Effizienz von
0.875 für 2 und einer Effizienz von 0.75 für 4 Prozessoren. Die Tests sind auf unimodulare Gitter sowie Rucksackgittern durchgeführt worden. Diese Gitter sind in der
Praxis selten vorzufinden und ob diese Ergebnisse auch für echte Praxisfälle erreicht
werden, kann hier nicht beantwortet werden. Dennoch scheint diese erste Implementierung vielversprechend zu sein und hat uns motiviert diesen Ansatz teilweise in
der parallelen Version des BKZ Algorithmus, welcher im Kapitel 5 vorgestellt wird,
zu verwenden.
Özgür Dagdelen
40
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
5. Paralleler BKZ Algorithmus
5. Paralleler BKZ Algorithmus
In diesem Kapitel stellen wir einen neuen parallelen Algorithmus zur Gitterbasisreduktion vor. Unser Algorithmus basiert auf dem BKZ Algorithmus (siehe Kapitel 3.3). Der Fokus dieser Diplomarbeit ist nicht die Beschleunigung eines bereits
schnellen Algorithmus. Vielmehr interessant sind Algorithmen die besonders gute
Ergebnisse liefern, da sie eine mögliche Gefahr für die Sicherheit vieler Kryptosysteme bedeuten können. Die wahrscheinlich besten Ergebnisse gelingen durch den
BKZ Algorithmus. Die sequentielle Arbeitsweise und Resultate vom BKZ wurden im
Kapitel 3.3 beschrieben. Dies gab uns die Motivation an einer Parallelisierung des
BKZ Algorithmus zu arbeiten. Die Erfolge des BKZ hängen stark mit der verwendeten Blockgröße zusammen. Eine Erhöhung der Blockgröße bringt deutlich mehr
Laufzeit mit sich. Dieser parallele Ansatz soll die Schranke βs = 25 noch weiter
höher ansetzen. Die Schranke βs gibt eine obere Grenze für die Blockgröße an, in
welcher der BKZ Algorithmus die Gitterbasisvektoren mit einer akzeptabler Laufzeit
reduzieren kann. Mit einer Blockgröße β > 25 kann mit einer drastischen Laufzeiterhöhung gerechnet werden. Wenn wir jedoch die Operationen des BKZ auf mehrere
Prozessoren verteilen, so erreichen wir durch diese Beschleunigung eine Erhöhung
der Schranke βs . Diese dadurch erreichbare bessere Approximation des kürzesten
Vektors im Gitter könnte neue Sicherheitsfragen verschiedener Kryptosysteme wie
beispielsweise NTRU aufstellen.
Der BKZ Algorithmus besteht grundsätzlich aus drei Bausteinen. Zum einen der verwendete LLL Algorithmus für die LLL-Reduktion im BKZ. Desweiteren die Bausteinelemente BASIS und ENUM. Die Methode BASIS, welche einen Vektor umformt,
um diesen in die Gitterbasis hinzuzufügen, ersetzen wir durch einen weiteren LLL
Aufruf. Nach [Hör94] wird die Methode BASIS eingeführt, da sie eine Beschleunigung gegenüber dem LLL erreichen soll. Wir konnten diese These nicht bestätigen
und verwendeten weiterhin ein LLL Aufruf. Dies macht es nun notwendig ein resultierenden Nullvektor, da lineare Abhängigkeit durch das Hinzufügen des neuen
Vektors auftritt, zu entfernen. Algorithmus 13 beschreibt unsere parallele Version
des BKZ Algorithmus.
Özgür Dagdelen
41
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
5. Paralleler BKZ Algorithmus
Algorithmus 13 : Paralleler BKZ - Algorithmus
Eingabe : Basis B = (b1 , . . . , bk ) ∈ Zn×k des Gitters L ⊂ Zn , δ mit
1
0
4 < δ ≤ 1, δ < 1, 2 < β < k
Ausgabe : β-BKZ-reduzierte Basis B = (b1 , . . . , bk ) ∈ Zn×k mit
Reduktionsparameter δ
1
2
3
4
5
6
7
8
9
10
LLLpar(b1 , . . . , bk , δ)
z := 0
j := 0
solange z < m − 1 tue
j := j + 1
m := min(j + β − 1, k)
wenn (j = k) dann
j := 1
m := β
Ende
11
(uj , . . . , um , c̄) = ENUMpar(j, m)
12
h := min(m + 1, k)
13
14
15
16
17
18
19
20
21
22
23
wenn (δ 0 · cj > c̄) dann
P
= ki=j ui bi
bneu
j
LLLpar(b1 , . . . , bj−1 , bneu
, bj , . . . , bh , δ) auf Stufe j − 1
j
z := 0
Entferne aus der resultierenden Basis den Nullvektor
LLLpar(b1 , . . . , bh , δ) auf Stufe j − 1
sonst
z := z + 1
LLLpar(b1 , . . . , bh , δ) auf Stufe h − 1
Ende
Ende
Aus Algorithmus 13 kann man leicht entnehmen, dass sowohl der verwendete LLL
als auch die ENUM Funktion parallelisiert werden müssen. Die restlichen Operationen sind nicht parallelisierbar bzw. die Laufzeit ist so gering, dass sich eine parallele
Ausführung nicht lohnt. In den folgenden Unterkapiteln stellen wir diese Parallelisierung dieser Methoden vor. Im Kapitel 6 wird die Umsetzung unseres neuen parallelen
Gitterbasisreduktionsalgorithmus präsentiert und die Evaluierung vorgestellt.
Özgür Dagdelen
42
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
5. Paralleler BKZ Algorithmus
5.1. Paralleler LLL Reduktionsalgorithmus LLLpar
Für die Methode LLLpar kommt jeder parallele LLL Algorithmus in Frage. Die einzige Bedingung für den Einsatz ist die Geschwindigkeit des Algorithmus sowie die
Approximationsgüte. Die Approximationsgüte ist aus dem Grund wichtig, da sie
die Laufzeit der ENUMpar Prozedur beeinflussen kann. Je besser die Reduktion
ist, desto eher werden die kürzesten Vektoren aus Linearkombination der vorderen
Vektoren gewonnen. Dazu folgt mehr im Kapitel 5.2.
Allerdings sollte im Vordergrund der Geschwindigkeitsfaktor des Algorithmus stehen. Eine LLL Reduktion mit tiefen Einfügungen würde nicht viel Sinn für die Verwendung im BKZ geben, da sie schon fast selbstständig ähnliche Ergebnisse liefert
und es nicht vorteilhaft in die BKZ Laufzeit eingehen würde.
Für unseren Zweck nutzen wir den parallelen SE Algorithmus. Da jedoch keine Implementierung des SE zugänglich war, haben wir nach dem Algorithmus in Kapitel
4.2 die Implementierung vorgenommen. Genauere Details zur Implementierung und
Vorstellung der Evaluierung befindet sich im darauf folgenden Kapitel 6.
5.2. ENUMpar
In diesem Kapitelabschnitt wird tiefgründiger auf die ENUM Prozedur, ihre Funktionsweise und Komplexität eingegangen sowie die Fehleranalyse angesprochen. Anschließend wird der erste Ansatz für die Parallelisierung des ENUMs vorgestellt.
Die Ideen zur Umsetzung sowie Schwierigkeiten und Vorteile beschrieben. Zu dem
ersten Ansatz präsentieren wir zusätzliche Optimierungsmöglichkeiten, welche uns
schlussendlich den Algorithmus ENUMpar liefert.
Die Prozedur ENUM führt eine vollständige Aufzählung nach dem Prinzip der Tiefensuche durch. Dabei wird nach einem Vektor x ∈ Zd gesucht, welcher folgende
Gleichung erfüllt:
X
X
=
min
u
b
x
b
i i ,
i i
d
(5.1)
u∈Z
wobei (b1 , . . . , bd ) die Basisvektoren eines Gitters L sind. Die Gleichung (5.1) lässt
sich auch umformulieren, womit die eigentliche Vorgehensweise des ENUMs ersichtlich wird. Seien µ ⊂ Rd×d die Gram-Schmidt Koeffizienten und die zur Orthogonali-
Özgür Dagdelen
43
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
5. Paralleler BKZ Algorithmus
sierung gehörigen (b∗1 , . . . , b∗d ). So ist die Lösung x ∈ Zd der Gleichung (5.1) ebenso
die Lösung folgender Gleichung:
d
X
(xi +
i=1
d
X
s=i+1
X
µs,i xs )2 · kb∗i k2 = min ui bi .
d
(5.2)
u∈Z
Im BKZ ruft man die ENUM Prozedur mit einer festen Blockgröße auf und rotiert
das Fenster zyklisch. So muss man eine untere und obere Schranke der Basisvektoren
aufrufen. Sei j die untere sowie k die obere Schranke des aufzurufenden Block für
ENUM, dann wird x ∈ Zk−j+1 gesucht mit:
k
X
i=1
(xi +
k
X
s=i+1
µs,i xs )2 · kb∗i k2 =
X
ui bi .
k−j+1
min
(5.3)
u∈Z
Die ENUM Prozedur wurde bereits kurz im Kapitel 3.3 vorgestellt. Sie arbeitet dabei
so, dass ein Suchbaum durchlaufen wird und das aktuelle Minimum c̄ sowie der Konstellationsvektor x ∈ Zk−j+1 mitgeführt werden. In dem Suchbaum befinden sich in
den Blättern fertige Konstellationen und können Kandidaten für ein mögliches Mini-
mum des Gitters sein. Ist man jedoch in einem inneren Knoten des Baumes, z.B. auf
der Stufe i mit 1 < i ≤ k, so ist nur die Konstellation (xi+1 , . . . , xk ) festgelegt und der
nächste Schritt wäre xi zu berechnen. Springt man von einem tieferen Knoten i nach
oben zu i+1, sind verschiedene Möglichkeiten für das neue xi+1 möglich. Es existieren
Varianten von ENUM, welche nach dem Schema 0, 1, −1, 2, −2, . . . l, −l den Folge-
knoten angeben. Die Schranke l gibt die mögliche Anzahl an, welche
Verbesseq eine
2
rung des aktuellen Minimums bringen können. Es gilt l ≤ 1 + 2 c̄/ b∗i [PS08].
Jedoch muss man feststellen, dass unnötige Teilbäume durchsucht werden, wenn man
nach diesem Schema vorgeht. Beispielsweise werden Konstellationen (−1, 2, 1) sowie
(1, −2, −1) durchlaufen, obwohl sie nur negiert sind und somit den selben Vektor
nur mit vertauschtem Vorzeichen darstellen.
Die vorliegende Arbeit beschäftigt sich mit Algorithmus 14 aus [Bac98] mit einigen
Änderungen. Hier werden die nächsten xi inkrementiert, sobald aus einer tieferen
Stufe zurück auf xi gesprungen wird. Das verhindert unnötiges Finden trivialer negierter Lösungen. Zusätzlich gilt in jedem Knoten, dessen Unterbäume keine neue
Minimalstelle bieten können, die Abbruchbedindung mit (x̃t + yt ) ≥ −0.5, welche
angepasst an numerischer Stabilität so gewählt wird. Erst dann wird in die nächst
höher liegende Stufe gesprungen.
Das Beispiel 5.1 soll die Vorgehensweise der Durchsuchung des Suchbaums verdeutlichen.
Özgür Dagdelen
44
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
5. Paralleler BKZ Algorithmus
Algorithmus 14 : Serieller ENUM - Algorithmus
Eingabe : Gram-Schmidt
Koeffizienten (µi,j )1≤i,j≤n , Höhenquadrate
∗2
2
∗
bj , . . . , kbk k , Schranken j und k
Ausgabe : Konstellationskoeffizienten xj , . . . , xk ∈ Z, c̄ ∈ R
2
∗
c̄
:=
bj 1
 
0
 .. 
x := x̃ := y := l :=  . 
0
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
computeVar := false
t := j
solange t <= k tue
wenn computeVar = true dann
P
yt = ki=t+1 x̃i µi,t
q
c̄−li+1
−1
x̃t = −yt −
lt
Ende
x̃t = x̃t + 1
lt = lt+1 + (x̃t + yt )2 kb∗t k2
computeVar := false
wenn lt < c̄ dann
wenn t > j dann
computeVar := true
t := t − 1
sonst
c̄ := lt
x := x̃
Ende
Ende
wenn computeVar = false dann
wenn (x̃t + yt ) ≥ −0.5 dann
t := t + 1
Ende
Ende
Ende
Özgür Dagdelen
45
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
5. Paralleler BKZ Algorithmus
Beispiel 5.1. Sei im folgendem

16 5 0

B =3
0
kb∗1 k2 ≈ 16, 2788,


6 5

1
 98
M =  265
1 1
3
53
kb∗2 k2 ≈ 5, 0753,

0
0
1

0
6745
6826
1
kb∗3 k2 ≈ 0, 0121.
So lässt sich der Suchbaum eines ENUM Aufrufs mit j = 1 und k = 3 durch die
Abbildung 5.1 beschreiben. Im Knoten des Graphen steht auf Stufe i das Konstellationselement xi . Anhand der gerichteten Kanten können die Schritte mitverfolgt
werden. Teilbäume die nicht durchsucht werden müssen, da sie keine Verbesserung
einer neuen Minimalstelle bringen können, werden durch eine unterbrochene Kante
gekennzeichnet. Dick umrandete Knoten sind momentane Minimalstellen.
Abbildung 5.1.: Suchbaum eines ENUM Aufrufs
Komplexität. Die Prozedur ENUM findet den kürzesten Vektor in einem Gitter
bzw. einem Block von Gittervektoren. Daher strebt sie nach einer Lösung des SVP
Problems. Die Schwierigkeit dieses Problems wurde bereits diskutiert und damit
folgt die exponentielle Laufzeit von ENUM. Dennoch gehört sie zu den schnellsten
SVP Lösern.
An sich terminiert die ENUM Prozedur schneller, je besser die Eingangsbasis mittels
LLL-Reduktion reduziert wurde. Linearkombinationen der vorderen Basisvektoren
liefern bereits ein gutes Minimum, so dass die Prüfung der hinteren Vektoren auf
ein mögliches neues Minimum verhindert werden kann. Dies bedeutet einen deutlich
kleineren Suchbaum für die ENUM Prozedur.
Özgür Dagdelen
46
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
5. Paralleler BKZ Algorithmus
Eine Alternative zu ENUM bietet das Verfahren von Finke und Pohst [FP85]. Allerdings zeigen die Ausarbeitungen [Bac98], sowie [PS08], dass die Laufzeit dieses
Verfahrens in der Praxis nicht an die des ENUMs heranreichen können. Trotz allem
läuft ENUM mit wachsender Blockgröße nicht mehr in akzeptabler Laufzeit. Um
dem entgegen zu wirken, wurden Schnittvarianten des ENUMs entwickelt, welche
Teilbäume in denen keine große Wahrscheinlichkeit auf Erfolg für ein neues Minimum besteht einfach abgeschnitten werden. Sicherlich kann dadurch die einzige
Lösung des SVP verloren gehen, aber in Anbetracht der Laufzeit sind Schnittvarianten in großen Blockgrößen eine geeignetere Wahl.
Schnittvarianten wurden in [Hör94] vorgestellt. Darunter sind verschiedene Stutzvarianten als auch die Version, welche nach der Gaußschen Volumenheuristik arbeitet,
präsentiert. Tests dazu sind in [Bac98] zu finden. In dieser Arbeit nutzen wir jedoch
keine Schnittvarianten, um keine mögliche Lösung zu übersehen. Unsere Ansätze
lassen sich aber leicht für ENUM Prozeduren mit Schnitt übertragen.
Fehleranalyse.
Die ENUM Prozedur erlaubt das SVP möglichst schnell zu lösen,
wobei die exponentielle Laufzeit dennoch gegeben ist. Bemerkenswert ist, dass wir
nur dann auch wirklich den Vektor mit minimaler Länge der Vektoren gewinnen,
wenn wir sowohl für die Gram Schmidt Koeffizienten als auch für die Höhenquadrate
die exakten Werte verwenden. Es muss auch innerhalb der ENUM Operationen mit
exakter Arithmetik gearbeitet werden. Durch die Approximationen können Rundungsfehler deutliche Auswirkungen haben. Vor allem kann dadurch die wirkliche
Mininumstelle entweder übersehen werden oder aber durch einen Vektor mit einer
größeren Länge innerhalb des Algorithmus überschrieben werden. Satz 5.1 gibt eine
obere Schranke für die Güte der ENUM Ausgabe unter Verwendung von Gleitkommaarithmetik.
Seien die Basisvektoren b1 , . . . , bk des Gitters L bereits mit Reduktionsparameter
δ LLL - reduziert und die Gram-Schmidt Koeffizienten beschränkt durch µi,j ≤ 0.51.
Sei weiterhin ρ = (1 + 0.51) √ 1
. Dann gilt folgender Satz:
δ−0.512
Satz 5.1 ([PS08],Thm. 3). Nutzen wir Algorithmus 14 mit Gleitkommaarithmetik
P
und sei γ = k i xi bi k die Länge des gefundenen Vektors. Weiter sei k die Gitterdimension und λ die Länge des kürzesten Vektors. Dann gilt:
λ2 ≤ γ 2 ≤ (1 + 4k2−τ ) · λ2 + Cρk 2−τ (1 + k2−τ ),
(5.4)
wobei τ die Bit-Genauigkeit angibt und C = O(1) gilt.
Özgür Dagdelen
47
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
5. Paralleler BKZ Algorithmus
Wir können daraus schliessen, dass unsere ENUM Prozedur innerhalb des BKZ Algorithmus keine Verwendung als SVP Löser in Blöcken von Gittervektoren findet,
sondern eher (1 + ε)-SVP Instanzen für kleine ε löst.
Es besteht die Möglichkeit einige Verbesserungen unter Annahme der Nutzung von
Gleitkommaarithmetik zu erreichen. Dafür müssen wir im Algorithmus 14 in Zeile
18 eine zusätzliche Bedingung prüfen, bevor wir die Minimalstelle überschreiben. Es
können bessere Ergebnisse erwartet werden, wenn wir zuvor die Bedingung
n
n
X
X
x̃i bi ≤ x i bi i=1
i=1
in exakter Arithmetik überprüfen. Für Instanzen des SVP, in der die Gittervektoren
mit dem ersten Gitterbasisvektor beginnen, ist dies tatsächlich realisierbar und die
zusätzlichen exakten Berechnungen lassen sich in akzeptabler Laufzeit durchführen.
Mit ausreichender Genauigkeit kann damit sogar SVP exakt gelöst werden.
Bedauerlicherweise werden im BKZ die meisten ENUM Aufrufe nicht beginnend
beim ersten Basisvektor gestartet. Die Ausgabe dieser ENUM Aufrufe ist kein kürzester Gittervektor, welcher durch Linearkombination der bj , . . . , bk darstellbar ist,
sondern ein Gittervektor, der als kürzester Vektor anzusehen ist, sobald dieser zusätzlich durch die Gittervektoren b1 , . . . , bj−1 größenreduziert ist. Diese zusätzliche Bedingung ist nicht kostengünstig in jedem ENUM Aufruf zu überprüfen, wenn wir
auf ein Kandidaten einer neuen Minimalstelle stoßen. In unserer Implementierung
verzichten wir auf diese aufwändige Zusatzprüfung.
Wir verwenden aus Laufzeitgründen den Datentyp double und erreichen daher eine
Genauigkeit von 53 Bits. Nach [PS08] erreichen wir eine Korrektheitsgarantie unseres ENUMs für eine Dimension ≈ 45. Allerdings sind in den praktischen Fällen
eine weitaus größere obere Schranke für eine korrekte Berechnung des SVP nachweisbar.
Der erste Ansatz zur Parallelisierung.
Nachdem wir die Funktionsweise des EN-
UMs beschrieben haben, stellen wir hier die ersten Ideen vor, um arithmetische Operationen des ENUMs auf mehrerere Prozessoren zu verteilen und damit an Laufzeit
zu gewinnen. Es ist wichig die Funktionsweise des ENUMs verstanden zu haben, um
die Vorgehensweise der Parallelisierung nachzuvollziehen.
Da ENUM mit Tiefensuche und Backtracking den Suchbaum nach einem Minimum
durchstöbert, stellt es für die Parallelisierung des ENUM Algorithmus eine Schwie-
Özgür Dagdelen
48
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
5. Paralleler BKZ Algorithmus
rigkeit dar. Dieses Problem kann wie folgt adressiert werden. Nehmen wir an, dass
uns 4 Prozessoren zur Vefügung stehen. Dann starten wir 4 ENUM Aufrufe mit
folgender Starteinstellung:
Prozessor 1 startet mit der Startkonstellation x = (1, 0, . . . , 0) ∈ Zk−j+1
auf Stufe 1.
Prozessor 2 startet mit der Konstellation x = (0, . . . , 0, 1) ∈ Zk−j+1 auf Stufe
t=k
Prozessor 3 startet mit der Konstellation x = (0, . . . , 0, 2) ∈ Zk−j+1 auf Stufe
t=k
Prozessor 4 startet mit der Konstellation x = (0, . . . , 0, 3) ∈ Zk−j+1 auf Stufe
t=k
Sobald ein Prozessor seine Berechnungen vollendet hat und theoretisch xk inkrementieren muss, um fortzusetzen, wird stattdessen das zuletzt verwendete xk inkrementiert und die Berechnungen fortgesetzt, sofern kein Prozessor das Ende vermerkt
hat. Dies geschieht genau dann, wenn seine Startkonstellation keine Verbesserung
der Minimalstelle bringen kann.
Dieser Ansatz ist nicht sehr empfehlenswert. Hier besteht eine Art Tradeoff zwischen Breitensuche und Tiefensuche. Breitensuche insofern, dass es von der Wurzel
aus, jedem ausgehendem Knoten ein Prozessor zugewiesen wird, welcher eine Tiefensuche in diesem Unterbaum durchführt. Dieser Ansatz bringt einige Nachteile mit
sich. Zum einen ist die Prozessorauslastung nicht optimal. Die Durchsuchung eines
Teilbaums kann wesentlich länger dauern, als viele andere Teilbäume. Zum anderen
findet nicht unbedingt jeder Prozessor eine Verwendung in dieser Vorgehensweise.
Dadurch kann keine erfolgsversprechende Beschleunigung erwartet werden. Ausserdem werden durch dieses Abarbeitungsschema erheblich mehr arithemetische Operationen im Vergleich zur sequentiellen Vorgehensweise ausgeführt. Die Erklärung
liegt darin, dass Knoten in der parallelen Version erreicht werden, in denen das aktuelle Minimum nicht mit dem des sequentiellen übereinstimmt. Beispielsweise startet
Prozessor 2 mit einer Startkonstellation von x = (0, . . . , 0, 1)T , aber mit dem Wissenstand des Startminimums. Dadurch werden die Teilbäume durchsucht, weil mit
einer Verbesserung gerechnet werden kann. Im Sequentiellen wäre man bereits mit
allen Möglichkeiten der Konstellationen mit xk = 0 durch und hätte wahrscheinlich
bereits eine neue deutlich kleinere Minimalstelle gefunden.
Özgür Dagdelen
49
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
5. Paralleler BKZ Algorithmus
Aus den genannten Gründen müssen wir daran arbeiten, nicht von der Wurzel aus die
Operationen an die Prozessoren zu verteilen, sondern an die Tiefensuche anzupassen
und einige bestehende Eigenschaften der Funktionsweise des ENUMs auszunutzen.
Wir können bei der ENUM Prozedur die folgende Beobachtung machen: Nehmen
wir an, wir befinden uns in der ENUM Prozedur auf der Stufe i mit 1 < i ≤ n.
Dann sind die Elemente xi , . . . , xn des Konstellationsvektors x ∈ Zn festgelegt. Nun
existieren 2 Ausgangsmöglichkeiten:
Wir stellen fest, dass es nicht von Nöten ist Unterbäume zu durchsuchen, da
bereits in diesem Knoten ein zu hoher Wert für li vorliegt. Wir springen daher
auf Stufe i + 1 und setzen mit xi+1 um eins erhöht fort.
Unser aktuelles li liegt unter dem Wert des aktuellen Minimums, d.h. es besteht
die Möglichkeit, dass in den Blättern der Unterbäume ein neues Minimum gefunden werden kann. Wir springen daher zur Stufe i−1 und behalten xi , . . . , xn
wie bisher.
Hieraus kann man schließen, wenn wir die Konstellation (xi , . . . , xn ) festgesetzt haben und wir eine mögliche Verbesserung sehen, dass wir zwingend in irgendeinem
Zeitpunkt des Algorithmus die Konstellation (xi + 1, . . . , xn ) erreichen müssen. Dies
wäre ein neuer Ansatz für die Einführung der Parallelität, indem eine Weitergabe
der restlichen Operationen an einen nächsten Prozessor übergeben wird. Ein Prozessor wird deswegen folgende Erneuerung durchführen. Seien wir auf der Stufe i
und sei die aktuelle Konstellation (xi , . . . , xn ). Die neue Vorgehensweise wird nun
wie folgt umgesetzt:
Es gibt eine Möglichkeit für das Auffinden eines neuen Minimums. Dann lass
einen neuen Prozessor die ENUM Prozedur auf Stufe i mit dem Konstellationsvektor (xi + 1, . . . , xn ) starten. Führe die Schritte danach wie üblich fort.
Sobald die Stufe i wieder erreicht wird, terminiere. Dies gelingt, indem die
obere Schranke für die Ausführungen aktualisiert wird.
Besteht keine Aussicht auf eine neue Minimalstelle, so springe auf Stufe i + 1,
sofern diese Stufe nicht die obere Schranke überschreitet. Der neue Konstellationsvektor ist nun (xi+1 + 1, . . . , xn ).
Wenn wir diese Überlegungen umsetzen, kommen wir zu dem neuen parallelen
ENUM Algorithmus 15.
Wir verwenden ENUM Threads, sobald wir Aussicht auf ein neues Minimum haben.
Diese Threads funktionieren im Grunde genommen ähnlich wie die Hauptprozedur
Özgür Dagdelen
50
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
5. Paralleler BKZ Algorithmus
Algorithmus 15 : Paralleler ENUM - Algorithmus (1.Ansatz)
Eingabe : Gram-Schmidt Koeffizienten (µi,j )1≤i,j≤n , Höhenquadrate
2
∗
2
bj , . . . , kb∗k k , Schranken j und k
Ausgabe : Konstellationskoeffizienten xj , . . . , xk ∈ Z, c̄ ∈ R
2
∗
1 c̄ := bj  
0
 .. 
x := x̃ := y := l :=  . 
0
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
bound := k
computeVar := false
t := j
solange t <= bound tue
wenn computeVar = true dann
P
yt = ki=t+1 x̃i µi,t
q
c̄−lt+1
x̃t = −yt −
−1
lt
Ende
x̃t = x̃t + 1
lt = lt+1 + (x̃t + yt )2 kb∗t k2
computeVar := false
wenn lt < c̄ dann
wenn t > j dann
computeVar := true
t := t − 1
wenn bound = k dann
Starte ENUM Thread auf Stufe t + 1 und übergebe x̃, l, y
bound := t
Ende
sonst
c̄ := lt
x := x̃
Ende
Ende
wenn computeVar = false dann
wenn (x̃t + yt ) ≥ −0.5 dann
t := t + 1
Ende
Ende
Ende
Özgür Dagdelen
51
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
5. Paralleler BKZ Algorithmus
Abbildung 5.2.: Ausführungsschritte des parallelen ENUMs im Vergleich zur sequentiellen Version
ENUM, die im Algorithmus 15 beschrieben ist. Es müssen die Programmattribute
nur mit dem übergebenen Werten initialisiert werden. Ausserdem darf anfangs nicht
das Minimum gesetzt werden. Zusammengefasst müssen die Zeilen 1 − 5 aus dem
Algorithmus 15 mit den folgenden Zeilen aus Algorithmus 16 ausgetauscht werden.
Algorithmus 16 : ENUM Thread (Initialisierungen)
Eingabe : Schranken j und k, Vektoren x̃, l, y, aktuelle Stufe i
/* c̄, x sowie die Gram-Schmidt Koeffizienten und Höhenquadrate
sind globale Variablen
*/
1
2
3
4
5
6
Initialisiere die Werte x̃, y und l mit den Eingaben
bound := k
computeVar := true
t := i
solange t <= bound tue
..
.
Ende
Unser Algorithmus startet bewusst nicht bei jeder Aussicht auf ein neues Minimum
einen neuen Thread, da dadurch ein zu hoher Overhead produziert werden würde
und zu viele kleine abzuarbeitende Blöcke vorbereitet werden würden. Die Laufzeit
leidet dadurch enorm. Sinnvollerweise muss man nach einem Optimum suchen, wann
neue Threads erstellt werden sollen. Neue Ideen zur Optimierung werden noch in
diesem Kapitelabschnitt folgen.
Özgür Dagdelen
52
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
5. Paralleler BKZ Algorithmus
Die Abblildung 5.2 zeigt die Vorgehensweise am Beispiel 5.1. Wir können beobachten, dass wir durch die Parallelisierung im Vergleich zu der Anzahl der benötigten sequentiellen Schritte etwa halb so viele Schritte durchführen. Wir rufen fünf Threads
auf. Dennoch benötigen wir für die maximale Beschleunigung nicht 5 Prozessoren,
da der erste Prozessor seine Berechnungen beendet hat, bevor der dritte Thread
gestartet wird. Also kann der erste Prozessor die Berechnungen des dritten Threads
übernehmen. Für eine maximale Beschleunigung reichen für dieses Beispiel 4 Prozessoren aus. Sei hier noch vermerkt, dass nicht zwingend in der parallelen Vorgehensweise die selben Knoten durchsucht werden, wie dies im sequentiellen der Fall
ist. Wie zuvor erwähnt, stimmen die Minima in den parallelen Schritten nicht mit
denen der sequentiellen überein. Es könnten also auch wie im Ansatz zuvor mehr
Schritte insgesamt ausgeführt werden. Allerdings sind es weitaus weniger als beim
Ansatz aus der Wurzel die Teilbäume zu verteilen. Wir arbeiten recht nah an der
Tiefensuche und damit nah an der sequentiellen Abarbeitungsfolge. Das minimiert
die zusätzlichen Schritte.
Es müssen in der parallelen Version aber nicht zwangsläufig mehr arithmetische Operationen und vor allem Knoten besucht werden. Da einige Knoten früher als in der
sequentiellen Vorgehensweise untersucht werden, können durchaus früher kleinere
Minima gefunden werden, wodurch der Suchbaum eventuell nicht so tief durchsucht
werden muss, als dies der Fall im sequentiellen ist.
Optimierungen. Dieser erste Ansatz für einen parallelen Aufzählalgorithmus ENUM
ist ein Weg zur Beschleunigung der seriellen Version. Orientiert an der sequentiellen
Version, werden die Knoten abgearbeitet und dennoch parallel arithmetische Operationen durchgeführt. Es wird immer dann ein neuer Thread gestartet, sobald ein
neues Miminim in den Blättern des Unterbaumes zu finden sein könnte. Aber dennoch führt der selbe Prozessor die Suche nach dem Minima in den Unterbäumen
fort. Nur wird eine neue obere Schranke für die Ausführung des ENUM festgelegt.
Nehmen wir an, wir würden die neue parallele ENUM Prozedur mit 50 Gittervektoren aufrufen, um nach einem kürzesten Vektor in dem von den 50 Gittervektoren
aufgespanntem Gitter zu suchen. Nehmen wir weiter an, wir seien in der Stufe 49
und die Möglichkeit ein neues Minimum zu finden, sei gegeben. Dann starten wir ein
neuen Thread auf Stufe 49 und führen alle Operationen mit diesem Prozessor fort bis
wir wieder an der Stufe 49 angelangt sind. Das würde bedeuten, dass wir innerhalb
des parallelen ENUMs eine Instanz von einem seriellen ENUM mit Blockgröße 49
durchführen. Das wäre sehr ineffizient und es würde Sinn ergeben, auch diese Operationen wieder in neue Threads aufzuteilen, um möglicherweise mehr Prozessoren
Özgür Dagdelen
53
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
5. Paralleler BKZ Algorithmus
zu beschäftigen. Die Abbildung 5.3 zeigt ein Beispiel, in der die parallele Version
gegenüber der sequentiellen einen bedeutungslosen Geschwindigkeitsgewinn besitzt.
Der sequentielle Algorithmus 14 findet den kürzesten Vektor in 19 Schritten, wobei
der parallele Algorithmus 15 genau 17 Schritte benötigt. Das käme zu einer Beschleunigung von 1.12. Es ist leicht zu sehen, dass mit wachsender Größe der Schritte und
gleicher Aufbau des Suchbaums die Beschleunigung gegen 1.0 konvergiert.
Abbildung 5.3.: Worst Case Beispiel des ersten Ansatzes von ENUMpar
Aus diesem Grund werden wir eine neue Schranke sdeep einführen, welche den Sinn
hat, dass ein Thread, welcher bereits einen weiteren Thread gestartet hat, unter
bestimmten Voraussetzungen weitere Threads starten darf. Nehmen wir nun wieder
an, ENUM befände sich auf der Stufe i und wir müssen die Unterbäume weiteruntersuchen, dann wird nun wie folgt vorgegangen:
Falls wir bereits Operationen an einen anderen Prozessor übergeben haben,
indem wir einen Thread starten ließen, so überprüfen wir, ob die Differenz
von der oberen Schranke und der jetzigen Stufe größer als sdeep ist, d.h.
bound − i > sdeep , dann starte wieder einen neuen Thread auf Stufe i und
übergebe zusätzlich die obere Schranke. Danach passe die neue obere Schranke
an, indem sie auf i gesetzt wird und führe die Operationen weiter aus.
Falls noch kein Thread gestartet wurde, so starte wie bisher einen weiteren
Thread und passe die obere Schranke an.
Özgür Dagdelen
54
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
5. Paralleler BKZ Algorithmus
Nun können große Blöcke rechtzeitig entdeckt werden und die Operationen auf weitere Prozessoren verteilt werden. Zum einen können wir somit mehr Prozessoren
rechnen lassen, d.h. die Auslastungsrate wird erhöht, welches wiederum mehr Beschleunigung bedeuten dürfte. Zum anderen sind sequentielle Anteile geringer und
weniger Prozessoren müssen warten, bis wieder neue offene Berechnungen bereit
stehen.
Zusätzlich zu sdeep werden zwei weitere neue Schranken sup und sdown eingeführt,
die zur Optimierung des Algorithmus beitragen. Um zu verhindern, dass sehr große
Blöcke durch einzelne Threads abgearbeitet werden, kann eine obere Schranke sup
gesetzt werden, die aussagt, dass nur dann Threads gestartet werden sollen, wenn
die aktuelle Stufe im Baum unter diesen Wert sup liegt.
Analog haben eventuell zu kleine Threadblöcke auch wenig Sinn, weil der entstehende
Overhead durch das Parallelisiern zu groß ist, dass dadurch die Gesamtlaufzeit sich
eher erhöht. Dafür führen wir die untere Schranke sdown ein. Nur auf Stufen i > sdown
dürfen Threads gestartet werden.
Die neuen Optimierungsideen sind in den Algorithmen 17 und 18 umgesetzt und
geben schlussendlich die Finalversion unseres ENUMpar, welchen wir im parallelen
BKZ Algorithmus verwenden.
Ziel ist es, eine optimale Parameterbelegung für sdeep , sup und sdown zu finden,
um die größtmögliche Beschleunigung oder auch Effizienz zu erhalten. In unserer
Implementierung haben wir einige Parameterbelegungen evaluiert. Die Ergebnisse
werden im nächsten Kapitel vorgestellt.
Algorithmus 17 : ENUMpar Thread (Initialisierungen)
Eingabe : Schranken j und k, Vektoren x̃, l, y, aktuelle Stufe i sowie
Schranke bound
/* c̄, x sowie die Gram-Schmidt Koeffizienten und Höhenquadrate
sind globale Variablen
*/
1
2
3
4
5
6
7
Initialisiere die Werte x̃, y und l mit den Eingaben
Initialisiere bound mit der Eingabe
start:= i
computeVar := true
t := i
solange t <= bound tue
..
.
Ende
Özgür Dagdelen
55
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
5. Paralleler BKZ Algorithmus
Algorithmus 18 : ENUMpar - Algorithmus
Eingabe : Gram-Schmidt Koeffizienten (µi,j )1≤i,j≤n , Höhenquadrate
2
∗
2
bj , . . . , kb∗k k , Schranken j und k
Ausgabe : Konstellationskoeffizienten xj , . . . , xk ∈ Z, c̄ ∈ R
2
∗
c̄
:=
bj 1
 
0
 .. 
x := x̃ := y := l :=  . 
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
0
bound := k
start := j
computeVar := false
t := j
solange t <= bound tue
wenn computeVar = true dann
P
yt = ki=t+1 x̃i µi,t
q
c̄−lt+1
x̃t = −yt −
−1
lt
Ende
x̃t = x̃t + 1
lt = lt+1 + (x̃t + yt )2 b∗t 2 computeVar := false
wenn lt < c̄ dann
wenn t > j dann
computeVar := true
t := t − 1
wenn t < sup ∧ t > sdown dann
wenn bound = k ∨(bound−t > sdeep ∧ start< t) dann
Starte ENUMpar Thread auf Stufe t + 1 und übergebe
x̃, l, y sowie bound
bound := t
Ende
Ende
sonst
c̄ = lt
x = x̃
Ende
Ende
wenn computeVar = false dann
wenn (x̃t + yt ) ≥ −0.5 dann
t=t+1
Ende
Ende
Ende
Özgür Dagdelen
56
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
6. Implementierung und Diskussion
6. Implementierung und Diskussion
In diesem Kapitel stellen wir die Implementierung des parallelen BKZ Algorithmus
zur Gitterreduktion nach Algorithmus 13 vor. Ausserdem testen wir die Unterprozeduren LLLpar sowie ENUMpar auf Beschleunigung und Effizienz im Vergleich zur
sequentiellen Version. Zum Schluss beschreiben wir die praktischen Untersuchungen
unseres parallelen BKZ Algorithmus und diskutieren die Ergebnisse.
6.1. Übersicht
Die Tests wurden auf einem AMD Prozessor mit 16 Kernen (Prozessoreinheiten)
und einer Maschinenwortbreite von 64 Bit durchgeführt. Als Betriebsystem nutzt
der Universitätsrechner Debian GNU/Linux in der Version 2.6.26-1.
Die Algorithmen wurden in Java implementiert. Von besonderem Interesse war die
Frage, ob die Leistung und Geschwindigkeit von in Java geschriebenen Gitterreduktionen mit denen der in C geschriebenen Implementierungen, speziell die Implementierung aus der NTL [Sho], mithalten kann. Anfangs der Diplomarbeit war
die Hoffnung vorhanden, die Ausführungszeiten der NTL zur Gitterreduktion zu
übertreffen, welche momentan zu den schnellsten verfügbaren Gitterbasisreduktionsalgorithmen zählen. Dabei wird in der NTL der SE Algorithmus mit einigen
zusätzlichen Veränderungen zur Optimierung implementiert. Zur Evaluation wurde
die Java Version 1.6.0.12 verwendet.
Für die Approximationen innerhalb der Gitterreduktion nutzen wir den Datentyp
double. Damit ist uns eine Genauigkeit von 53 Bits gegeben. Für höhere Genauigkeit
bräuchten wir Gleitkommazahlen mit beliebig einstellbarer Genauigkeit, welche die
Ausführungszeiten für Operationen deutlich verlangsamen. Wir testeten neben den
Approximationen mit double auch den Datentyp BigDecimal sowie Apfloat [Tom].
BigDecimal befindet sich im Paket java.math.BigDecimal. JScience [Daua] bietet
zudem noch die Möglichkeiten Matrizen und Vekoren zu speichern und sogar Operationen auf diesen auszuführen. Leider sind, sobald eine Matrix initialisiert ist, die
Özgür Dagdelen
57
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
6. Implementierung und Diskussion
Elemente in dieser Matrix nicht mehr überschreibar und somit für die Verwendung
unserer Algorithmen nicht mehr geeignet. Tests haben gezeigt, dass mit wachsender
Bitlänge der Zahlen die Operationen mit Apfloat deutlich schneller gegenüber denen mit BigDecimal ausführbar sind. Jedoch zeigten beide Datentypen im Vergleich
zur Implementierungen von C eine zu hohe Laufzeit und konnten bedauerlicherweise nicht effizient in Gitterreduktionen verwendet werden. Aus diesem Grund nutzen
wir in unseren Implementierungen den Datentyp double, obwohl erwartet werden
kann, dass durch die Verwendung der langsameren Gleitkommazahlen deutlich bessere Ergebnisse in Bezug auf Beschleunigung und Effizienz durch das Parallelisieren
erreicht werden.
Die Gitterbasis speichern wir in einem zwei dimensionalem Array vom Datentyp
BigInteger. Wir entschieden uns statt dem Paket java.math.BigInteger die leicht
schnellere Implementierung aus dem Paket vom Java Algebra System (JAS) Project
[rnHK] zu wählen. Dieser Datentyp speichert Zahlen mit beliebiger Bitgröße. Kandidaten zur Verwendung als Datentyp waren die Datentypen Apint aus [Tom] sowie
LargeInteger aus JScience [Daua]. Allerdings haben Tests gezeigt, dass BigInteger
den restlichen Datentypen vorzuziehen ist.
6.2. Die Prozedur LLLpar
In diesem Abschnitt präsentieren wir die Implementierung der parallelen Gitterreduktion LLLpar nach den Algorithmen vorgestellt in [BW08]. Es handelt sich hier
um eine Parallelisierung des SE Algorithmus, welcher im zweiten Abschnitt im Kapitel 4.2 beschrieben wurde. Als Baseline haben wir auch eine sequentielle Version
des SE Algorithmus implementiert. Uns ist keine Implementierung des sequentiellen
SE in Java bekannt.
Exakt werden nur Operationen an den Basisvektoren durchgeführt, so dass wir die
Gitterbasis als Datentyp BigInteger speichern. Die Approximationen der GramSchmidt Koeffizienten sowie der Matrix R, in der die Skalarprodukte gespeichert
sind, werden mit dem Datentyp double festgehalten.
Die verschiedenen Threads für die Skalarproduktberechnung, Orthogonalisierung sowie für die Reduktion der Gram-Schmidt Koeffizienten und den Gittervektoren werden in einer ConcurrentContext Umgebung aus der Klassenbibliothek Javolution
[Daub] gestartet. Die Umgebung soll die gleichzeitige Ausführung von Operationen auf Multi-Kern-Prozessoren optimieren und behandelt die Synchronisation der
Threads. Nachdem alle Threads ausgeführt sind, wird die Umgebung verlassen und
Özgür Dagdelen
58
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
6. Implementierung und Diskussion
es kann wie im Algorithmus fortgefahren werden. Interne Tests zeigten, dass für
die Threads die Implementierungen von Runnable etwas schneller laufen als eine
Vererbung der Klasse Thread.
Eine Übersicht der Attribute bzw. der globalen Variablen unserer Klasse SEpar
werden in der Tabelle 6.1 gegeben. Zudem sind die implementierten Methoden in
Tabelle 6.2 beschrieben.
Exemplarisch zeigen wir anhand der Größenreduktion der Gittervektoren die Implementierung der parallelen Ausführung. Zu Beginn des Programms, bevor wir in
einer while Schleife Schritt für Schritt die Gitterreduktionen ausführen, berechnen
wir die Grenzen der Berechnungen für die einzelnen Threads der Größenreduktion.
Diese Grenzen bleiben über die komplette Laufzeit konstant, da sich die Anzahl der
Elemente pro Vektor nicht ändern. Die Berechnungen der Grenzen werden durch
den folgenden Code realisiert:
Listing 6.1: Berechnung der Grenzen für die Größenreduktion
1
2
3
4
5
6
7
8
9
10
11
12
int intervall = nCols/nrProz;
if ( intervall < minRed)
intervall = minRed;
int start = 0;
if ( intervall * nrProz == nCols){
splitSR = new int[nCols/intervall+1];
} else
splitSR = new int[nCols/intervall+2];
for ( int j = 0; j < splitSR.length; j++) {
splitSR[ j]=start ;
start += intervall;
}
Sobald in der while Schleife während der Aktualisierung der Gram-Schmidt Koeffizienten festgestellt wird, dass eine Größenreduktion stattfinden muss, so wird
die Methode sizeReductionPart2(i) aufgerufen. Den Code zur Klasse zeigt das
Listing 6.2.
Özgür Dagdelen
59
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
6. Implementierung und Diskussion
private
BigInteger[][] Basis
private double[][]
apprBasis
private double[][] M
In dem zwei dimensionalem Array wird die aktuelle Basis in
exakter Arithmetik gespeichert.
Hier wird die approximierte Basis gespeichert.
Dieses Array speichert die Gram-Schmidt-Koeffizienten.
private double[][] R
Dieses Array speichert die Skalarproduktberechnung und weitere Operationen auf ihnen. Sie dient im Grunde genommen
für die Berechnung der Gram-Schmidt Koeffizienten und speichert in den Diagonalen die Höhenquadrate.
private double[] S
Dies ist ein Hilfsarray, welches in der Orthogonalisierung initialisiert wird und bei der Prüfung auf einen möglichen Tausch
abgerufen wird.
int nCols
int nRows
double delta
Es gibt die Spaltenanzahl der Basismatrix wieder.
Es gibt die Zeilenanzahl der Basismatrix wieder.
Hier wird der Reduktionsparameter δ gespeichert.
int bitsize
Es gibt die verwendete Bit-Genauigkeit an. In unserem Fall
beträgt sie 53 für double.
boolean Fr
Dies ist eine Hilfsvariable, welche besagt, ob eine
Größenreduktion in der momentanen Stufe notwendig
ist.
boolean Fc
Dies ist eine Hilfsvariable, welche besagt, ob ein zu großer
Reduktionskoeffizient entstanden ist und daher aus Stabilitätsgründen die Fortsetzung in der vorherigen Stufe stattfinden soll.
double[] r
Dies ist eine Hilfsvariable, welche in der Orthogonalisierung
verwendet wird.
double[] f
Dies ist eine Hilfsvariable, welche in der Reduktion der GramSchmidt Koeffizienten verwendet wird.
double[] roundf
Dies speichert bereits die gerundeten Werte des Arrays f. Sie
dient zur Laufzeitoptimierung.
int[] splitSR
Dieses Array beinhaltet die Grenzen der Threads für die
Größenreduktion der Basisvektoren.
int scaproBound
Dies gibt die Größe der Pakete für die Skalarproduktberechnung an.
int scaproSeq
Dies ist die Schranke bis wann das Programm die Berechnung
der Skalarprodukte sequentiell berechnen soll.
int oBound
Diese Größe gibt den sequentiellen Anteil der parallelen Vorgehensweise für die Gram-Schmidt Koeffizientenberechnung an.
int oSeq
Dies ist die Schranke für die Stufe bis wann das Programm die
Berechnung der Gram-Schmidt Koeffizienten sequentiell berechnen soll.
int redBound
Die Größe gibt den sequentiellen Anteil der parallelen Vorgehensweise für die Reduktion der Gram-Schmidt Koeffizienten
an.
int redSeq
Dies ist die Schranke für die Stufe bis wann das Programm die
Reduktion der Gittervektoren sequentiell berechnen soll.
int minRed
Diese Größe gibt die Anzahl der Mindestschritte für
einen einzelnen Thread für die parallele Ausführung der
Größenreduktion wieder.
Tabelle 6.1.: Attribute der Klasse SEpar
Özgür Dagdelen
60
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
6. Implementierung und Diskussion
void scalarproductPart(int i)
Die Methode führt die Skalarproduktberechnungen hbj , bi i mit j = 1, . . . , i − 1
durch.
void orthPart(int i)
Die Methode führt die Berechnungen der
Gram-Schmidt Koeffizienten
µi,j sowie der
Höhenquadrate b∗i 2 durch.
void sizeReductionPart1(int i)
Die Methode führt die Reduktionen der
Gram-Schmidt Koeffizienten µi,j durch.
void sizeReductionPart2(int i)
Die Methode führt die Reduktionen des
Gittervektors bi durch.
void recompute(int i)
Diese Methode führt bei notwendigen Neuberechnungen die Skalarprodukt- sowie
Gram-Schmidt Koeffizientenberechnungen
durch.
void swap(BigInteger[][] basis,
int i)
Die Methode vertauscht die Vektoren bi
und bi−1 in der exakten Basis.
void swap(int i)
Die Methode vertauscht die Vektoren b0i
und b0i−1 in der approximierten Basis.
int[] computeSplitValuesR(int i)
Die Grenzen für die Berechnungen der
Größenreduktion der Gram-Schmidt Koeffizienten übernimmt diese Methode.
int[] computeSplitValuesO(int i,
int j)
void computeScaProSeq(int i)
Die Grenzen für die Berechnungen der
Gram-Schmidt Koeffizienten übernimmt
diese Methode.
Diese Methode führt die sequentielle Berechnung der Skalarprodukte durch.
double scapro(BigInteger[][]
basis, int i, int j)
Diese Methode berechnet exakt das Skalarbodukt hbi , bj i und gibt sie als double
zurück.
double scalarproduct(double[][] a,
int i, int j)
Diese Methode
berechnet das Skalarbo
dukt b0i , b0j mit den approximierten Basisvektoren.
double norm(double[][] a, int i)
double[][]
approxBasis(BigInteger[][] basis)
void approxVector(BigInteger[][]
basis, int i)
Die Methode berechnet die Norm des approximierten Gittervektors b0i , d.h. kb0i k
Diese Methode gibt die approximierte Basis bei Eingabe der exakten Basis zurück.
Diese Methode aktualisiert den Vektor b0i ,
indem der exakte Gittervektor erneut approximiert wird.
Tabelle 6.2.: Methoden der Klasse SEpar
Özgür Dagdelen
61
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
6. Implementierung und Diskussion
Listing 6.2: Methode für die Größenreduktion der Gittervektoren
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
private void sizeReductionPart2(int i ) throws Exception {
if ( i<redSeq){
reduceseq(i) ;
} else {
ConcurrentContext.enter();
ConcurrentContext.setConcurrency(curr);
try{
for ( int k = 0; k < splitSR.length−1; k++) {
ConcurrentContext.execute(SizeUpdate.valueof(splitSR[k],splitSR[k+1],i));
}
} finally {
ConcurrentContext.exit();
}
}
}
Die einzelnen SizeUpdate Threads führen die Reduktion der Gitterbasisvektoren
aus, indem jeder Thread nur die ihm zugewiesenen Elemente des Vektors reduziert. Diese werden durch die zu Beginn der Klasse SEpar berechneten Teilgrenzen
übergeben. Der Code für die SizeUpdate Threads sehen wie folgt aus:
Listing 6.3: Thread zur Größenreduktion der Gittervektoren
1
2
3
4
5
6
7
8
9
10
11
public static class SizeUpdate implements Runnable{
int i ;
int s ;
int e;
static SizeUpdate valueof(int i , int j , int i2) {
SizeUpdate su = new SizeUpdate();
su.s=i;
su.e=j;
su. i=i2;
return su;
}
12
13
14
15
16
17
18
19
20
21
22
23
public void run() {
if (e>nCols){
e=nCols;
}
for ( int j = i−1; j >= 0; j−−) {
if (Math.abs(f[j ]) >0.5){
BigInteger biMue = new BigInteger((int)roundf[j]);
for ( int l = s; l < e; l++) {
Basis[ i ][ l ] = Basis[i ][ l ]. subtract(Basis[ j ][ l ]. multiply(biMue));
}
}
Özgür Dagdelen
62
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
6. Implementierung und Diskussion
}
for ( int l = s; l < e; l++) {
apprBasis[i ][ l ] = Basis[i ][ l ]. getVal() .doubleValue();
}
24
25
26
27
}
28
29
}
Für die Tests der Klasse SEpar wurden die Basen verwendet, welche besonders für
ihre beweisbare Schwierigkeit in der Challenge der TU Darmstadt [BLR08] verfügbar
gestellt wurden. Wir verwenden Gitter mit den Gitterdimensionen zwischen 200 und
700.
Zur Feststellung der optimalen Wahl unserer Parameter für den parallelen SEpar
machten wir folgende negative Beobachtungen:
Für die Optimierung der Berechnungen der Gram-Schmidt Koeffizienten be-
sitzen wir die Parameter so sowie smino . Es musste festgestellt werden, dass die
Berechnung am schnellsten durch die sequentielle Vorgehensweise ausgeführt
wird. Die einzelnen Schritte in einer Stufe können mit dem Datentyp double
in einer Geschwindigkeit umgesetzt werden, dass die Parallelisierung nur Overhead produziert.
Die Parameter zur Reduktion der Gram-Schmidt Koeffizienten brachten ähnlich
wie bei ihrer Berechnung keine Beschleunigung.
Daher wurden diese Schritte weiterhin sequentiell in der Klasse SEpar ausgeführt. In
der Skalarproduktberechnung sowie in der Reduktion der Gitterbasisvektoren war
allerdings eine Beschleunigung vorzufinden.
Abbildung 6.1 links zeigt, dass die Skalarproduktberechnung einen deutlichen Geschwindigkeitsgewinn verzeichnen kann. Mit dem Parameter ssp = n/20 , wobei n
die Dimension des Gitters angibt, wird bei der Verwendung von 16 Prozessoren eine
Beschleunigung von bis zu 8.0 erreichen.
Auch in der Reduktionsphase erfahren wir weitere Beschleunigungen. Die rechte
Grafik der Abbildung 6.1 zeigt die Laufzeiten für die Reduktion. Diese beinhalten
sowohl die sequentielle Reduktion der Gram-Schmidt Koeffizienten als auch die parallele Reduktion der Gittervektoren.
Die Beschleunigung und dementsprechend die Effizienz der parallelen Gitterreduktion nach dem SE Algorithmus ist nur mäßig. Die Abbildung 6.2 zeigt die Laufzeiten
des SEpar im Zusammenhang mit der Anzahl der Prozessoren sowie die erreichte
Özgür Dagdelen
63
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
6. Implementierung und Diskussion
Abbildung 6.1.: Laufzeiten
der
Reduktionsphase
Skalarproduktberechnung
sowie
der
Beschleunigung. Unter anderem kommt die moderate Beschleunigung dadurch zu
Stande, dass noch ein wesentlicher Teil sequentiell bearbeitet wird. Das fällt auf
die Berechnung der Gram-Schmidt Koeffizienten sowie der anschließenden Reduktion dieser Koeffizienten. Die Implementierung aus der NTL Bibliothek ist trotz der
Parallelisierung schneller.
Abbildung 6.2.: Laufzeiten des SEpar sowie die erreichten Beschleunigungen
6.3. Die Prozedur ENUMpar
In diesem Abschnitt präsentieren wir die Ergebnisse der Implementierung vom Algorithmus 18 aus Kapitel 5.2. Dies ist nach unserem Kenntnisstand die erste Implementierung eines parallelen Aufzählverfahren nach dem Prinzip [SE91].
Im Hauptthread führen wir eine Liste, indem wir die erstellten Threads im Programm speichern, falls bereits alle verfügbaren Prozessoren in Beschäftigung sind.
Özgür Dagdelen
64
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
6. Implementierung und Diskussion
Sobald ein Prozessor seinen zu bearbeiteten Thread beendet hat, nimmt dieser ein
neuen Thread aus dem Pool und führt diesen aus. Sobald alle Threads beendet wurden und sich auch keine weiteren mehr im Pool befinden, kann das Hauptprogramm
terminieren und als Ergebnis die Konstellation des kürzesten Vektors sowie dessen
Länge zurückgeben.
Für die Korrektheit der Funktionsweise ist eine Synchronisierung notwendig. Die
Minima und die aktuelle Konstellation des Minimums muss synchron gehalten werden. Zudem muss beachtet werden, dass Threads nicht verloren gehen und damit
Teilbäume nicht durchsucht werden.
Eine Übersicht der Attribute und der Methoden der Klasse ENUMpar wird in Tabelle
6.3 sowie Tabelle 6.4 gegeben.
double[][] m
int lowerbound
int upperbound
int deepbound
Hier werden die Gram-Schmidt Koeffizienten gehalten.
Dieser Wert entspricht der oberen Schranke sup .
Dieser Wert entspricht der unteren Schranke sdown .
Dieser Wert entspricht der Schranke sdeep .
double min
Dieser Wert gibt das Höhenquadrat des aktuellen Minimums
an.
int[] sol
Hier wird die Konstellation des aktuellen Minimums gehalten.
double[] r
Dieses Array speichert die Höhenquadrate der Vektoren, die
in den Aufrufsgrenzen zwischen j und k liegen.
int jj
Dieser Wert speichert die Position der Gittervektoren, in welcher die Prozedur ENUMpar beginnt.
int kk
Dieser Wert speichert die Position der Gittervektoren, in welcher die Prozedur ENUMpar endet.
FastList<parEnum>
threadlist
Diese Liste speichert die erzeugten ENUM Threads, falls alle
Prozessoren bereits beschäftigt sind. Sie funktioniert als eine
FIFO Liste.
int nrThreads
Dieser Wert gibt die Anzahl der momentan ausgeführten
Threads wieder.
Tabelle 6.3.: Attribute der Klasse ENUMpar
Für die Tests der Klasse ENUMpar wurden fünf zufällige Basen verwendet, welche die
Dimension 100 besitzen. Dabei wurden diese Gitter mit dem SE Algorithmus zuvor
reduziert, um für die darauffolgenden ENUMpar Tests die Gram-Schmidt Koeffizienten und Höhenquadrate zur Verfügung zu stellen. Zum Vergleichen verwenden wir
die Durchschnittslaufzeiten der fünf Basen.
Für eine optimale Parameterwahl wurden etliche Tests durchgeführt mit dem folgendem Ergebnis:
Özgür Dagdelen
65
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
6. Implementierung und Diskussion
void start
Mit dieser Methode wird das Aufzählverfahren gestartet
double getMin()
Diese Methode gibt das Höhenquadrat des aktuellen Minimums zurück.
void setMin(double
newmin)
Diese Methode setzt das Höhenquadrat des aktuellen Minimums.
void incNrThreads()
Diese Methode inkrementiert den Wert des Attributs
nrThreads.
void decNrThreads()
Diese Methode dekrementiert den Wert des Attributs
nrThreads.
int[] getSol()
Diese Methode gibt die Konstellation des aktuellen Minimums
zurück.
void setSol(int[] x)
Diese Methode setzt die Konstellation des aktuellen Minimums.
void
startThread(parEnum
valueof)
Diese Methode nimmt einen parENUM Thread entgegen. Falls
bereits alle Prozessoren arbeiten, wird sie in der Liste gespeichert, ansonsten wird sie direkt ausgeführt.
void startFromList()
Diese Methode nimmt einen Thread aus der Liste threadlist
nach dem FIFO Prinzip.
Tabelle 6.4.: Methoden der Klasse ENUMpar
sdown beschleunigt die Implementierung nicht. Dies kommt dadurch, dass durch
diese Vorgehensweise die Anzahl erzeugender kleiner Teilbäume gering bleibt.
Sobald höhere innere Knoten im Suchbaum einmal erreicht wurden, werden
fast ausschließlich Blöcke in dieser Größe erzeugt.
Es stellte sich heraus, dass es sich durchaus lohnt, eine obere Grenze sup für die
Erstellung neuer Threads zu verwenden. Tests zeigten eine optimale Laufzeit
unter Verwendung der Grenze sup =
5
6
· β, wobei β die verwendete Block-
größe angibt. Diese Einführung der oberen Grenze führte beispielsweise für
die Blockgröße 50 unter Verwendung von 8 Prozessoren zu einer zusätzlichen
Beschleunigung von 2.7. Das ist eine deutliche Optimierung ohne den Einsatz
von zusätzlichen Prozessoren.
Die Grenze sdeep führte zur keiner sonderlich großen Beschleunigung, aber
dennoch konnten einige Laufzeitverkürzungen festgestellt werden. Mit einer
Blockgröße von 50 terminierte die Implementierung durchschnittlich 14 Sekunden früher wie ohne die Verwendung von sdeep . Dies entspricht jedoch nur
einer Beschleunigung von etwa 1,3%. Wir empfanden sdeep =
optimale Parameterwahl.
5
6
· sup als die
Die Implementierung der parallelen Klasse ENUMpar erreichte gegenüber der sequentiellen Version eine sehr gute Beschleunigung und Effizienz. Die Abbildung 6.3
Özgür Dagdelen
66
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
6. Implementierung und Diskussion
zeigt für die Blockgrößen zwischen 40 und 50 die Laufzeiten der parallelen Implementierung getestet mit verschiedener Anzahl an Prozessoren. Die Abbildung zeigt,
dass die parallele Implementierung gegenüber der sequentiellen Implementierung
sogar überraschend eine Effizienz von über 1.0 unter Vewendung von bis zu 8 Prozessoren erreichte. Das kommt dadurch zu Stande, dass einige Teilbäume in der
parallelen Vorgehensweise auf Grund früher gefundener Minima nicht durchsucht
werden müssen.
ENUMpar zeigt eine hohe Effizienz, selbst mit steigender Anzahl an Prozessoren.
ENUMpar besitzt für die Verwendung von bis zu 8 Prozessoren etwa die selbe Effizienz. Einen leichten Effizienzrückgang muss mit 16 Prozessoren erwartet werden.
Dennoch liegt ihre Effizienz bei einem Wert über 0.8. Es ist zu beobachten, dass die
Effizienz mit wachsender Blockweite ebenfalls steigt.
Abbildung 6.3.: Laufzeiten der Aufzählverfahren ENUM sowie ENUMpar sowie erreichte Effizienz
6.4. Hauptprozedur parBKZ
In diesem Abschnitt wird die Implementierung des ersten parallelen BKZ Algorithmus nach dem Algorithmus 13 aus Kapitel 5 beschrieben. Wir vergleichen die Parallelisierung mit der Implementierung der sequentiellen Vorgehensweise und zeigen
die Erfolge auf.
Der parallele BKZpar benutzt die Unterprozeduren LLLpar sowie ENUMpar aus
den vorherigen Unterkapiteln. Im BKZpar selbst existieren keine weiteren parallelen
Ausführungen, da die Laufzeit sich aus den vorgestellten Prozeduren LLLpar und
ENUMpar zusammensetzen.
Özgür Dagdelen
67
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
6. Implementierung und Diskussion
Die Attribute und Methoden der Klasse BKZpar werden in den Tabellen 6.5 sowie
6.6 beschrieben.
BigInteger[][] basis
double[][] M
int nrRows
Dieses Array sichert die exakte Gitterbasis.
Dieses Array sichert die Gram-Schmidt Koeffizienten.
Dieser Wert steht für die Anzahl an Gittervektoren.
int nrCols
Dieser Wert steht für die Anzahl der Elemente eines Gittervektors.
double delta
Dieser Wert steht für den Reduktionsparameter δ
int blocksize
Dieser Wert steht für die verwendete Blockgröße des ENUMpar.
Tabelle 6.5.: Attribute der Klasse BKZpar
BigInteger[][] createArray(int j,
int i, BigInteger[] vec)
Diese Methode gibt ein Array, in der die
Vektoren (b1 , . . . , bj−1 , bneu
, bj , . . . , bh )
j
gespeichert sind, zurück.
double norm(BigInteger[] vec)
Diese Methode gibt die Norm des eingegangenen Vektors zurück.
void updateMR(double[][] m,
double[][] r,int start, int end)
Mit dieser Methode werden die GramSchmidt Koeffizienten und Höhenquadrate
aktualisiert.
void updateBasis(BigInteger[][]
bigIntegers,int start, int end)
Mit dieser Methode wird die Gitterbasis
aktualisiert.
BigInteger[] createNewVector(int
j, int[] sol)
Diese Methode gibt den Gittervektor
zurück, welcher mit Hilfe der Konstellation vom ENUMpar erstellt wird.
Tabelle 6.6.: Methoden der Klasse BKZpar
Wir testeten unsere Implementierung des BKZpar sowie des BKZ auf dem ChallengeGitter der TU Darmstadt mit der Dimension 200. Abbildung 6.4 zeigt die Laufzeiten des BKZ sowie BKZpar mit den Blockgrößen 20, 25 und 30. Wir stellen fest,
dass in diesen Blockgrößen die parallele Implementierung ENUMpar deutlich länger
benötigt, als der sequentielle ENUM. Die Berechnung eines ENUM Aufrufs in dieser
Blockgröße ist in wenigen Millisekunden realisierbar. Hier benötigt die parallele Implementierung zwar nur wenige Millisekunden länger. Dennoch existiert eine hohe
Anzahl an ENUM Aufrufen, wodurch diese sich in der Gesamtlaufzeit bemerkbar
machen.
Abbildung 6.5 zeigt die Gesamtlaufzeit des BKZpar sowohl mit Verwendung von
ENUMpar, als auch mit der sequentiellen Version ENUM. Es zeigt sich, dass die Gesamtlaufzeit durch die Verwendung von ENUM minimal ist, aber durch Hinzunahme
an weiteren Prozessoren für die Berechnungen keine Beschleunigung bringen.
Özgür Dagdelen
68
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
6. Implementierung und Diskussion
Challengegitter mit Dimension 200 (delta = 0.99)
Challengegitter mit Dimension 200 (delta = 0.99)
60,000
2,500
30,000
20
8−Prozessoren
16−Prozessoren
seriell
4−Prozessoren
8−Prozessoren
16−Prozessoren
0
seriell
10,000
0
25
16−Prozessoren
20,000
500
8−Prozessoren
1,000
Laufzeit BKZpar
Laufzeit BKZ
ENUMpar
ENUM
40,000
4−Prozessoren
1,500
seriell
Laufzeit BKZpar
Laufzeit BKZ
ENUMpar
ENUM
4−Prozessoren
Laufzeit in sek.
Laufzeit in sek.
50,000
2,000
30
BKZ Blockgroesse
BKZ Blockgroesse
Abbildung 6.4.: Laufzeiten des BKZ sowie BKZpar für kleine Blockweiten
Man muss feststellen, dass in Blockgrößen bis zu 30 die Implementierung des ENUMpar nur Laufzeiteinbußen bedeuten. Zuvor zeigten wir die hohe Beschleunigung des
ENUMpar in Blockgrößen über 40. Durch die Erhöhung der Blockweite ab dem
Wert 40 schlägt die Laufzeit des ENUMs deutlich in der Gesamtlaufzeit des BKZ
nieder. Wir testeten einen Durchlauf des BKZ bis die ENUM Prozedur wieder am
ersten Vektor des Gitters beginnt, mit den Blockweiten 45 und 50.Das ist also kein
kompletter BKZ Aufruf. Tatsächlich bringt die parallele Implementierung eine Beschleunigung von 1.7 bzw. 2.5 unter Verwendung von 8 Prozessoren. Die Abbildung
6.6 zeigt die erreichten Laufzeiten der Implementierungen.
Challengegitter mit Dimension 200 (delta = 0.99)
60,000
Laufzeit in sek.
50,000
Laufzeit BKZpar
Laufzeit BKZ
ENUMpar
ENUM
40,000
30,000
20,000
16−P.+ENUM
8−Proz+ENUM
4−Proz+ENUM
16−P.+ENUMpar
8−Proz+ENUMpar
seriell
0
4−Proz+ENUMpar
10,000
30
BKZ Blockgroesse
Abbildung 6.5.: Laufzeiten des BKZpar sowohl mit ENUM als auch mit ENUMpar
Challengegitter mit Dimension 200 (delta = 0.99)
1,000
seriell
0
45
BKZ Blockgroesse
8−Proz
500
Laufzeit BKZpar
Laufzeit BKZ
ENUMpar
ENUM
50,000
40,000
30,000
20,000
10,000
0
8−Proz
1,500
60,000
4−Proz
2,000
70,000
seriell
Laufzeit BKZpar
Laufzeit BKZ
ENUMpar
ENUM
Laufzeit des ersten Durchlaufs in sek.
2,500
4−Proz
Laufzeit des ersten Durchlaufs in sek.
Challengegitter mit Dimension 200 (delta = 0.99)
3,000
50
BKZ Blockgroesse
Abbildung 6.6.: Laufzeiten des BKZ sowie BKZpar für große Blockweiten
Özgür Dagdelen
69
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
7. Zusammenfassung und Ausblick
7. Zusammenfassung und Ausblick
Hier werden die Erfolge und Grenzen unseres neues Ansatzes zur Parallelisierung
des BKZ Algorithmus zusammengefasst. Das Ziel dieser Ausarbeitung ist, durch die
Beschleunigung des BKZ eine höhere Blockgröße verwenden zu können und damit
eine bessere Ergebnisbasis zu erhalten. Aus Laufzeitgründen wird bisher meist als
obere Blockgröße β = 25 zur Gitterreduktion genutzt. Zudem haben wir in der
Implementierung die Programmiersprache Java gewählt, um diese objektorientiere
Sprache auf ihre Leistung in mathematischen Operationen mit den der üblichen
Sprache C zu vergleichen.
Wir implementierten die Prozeduren SEpar sowie ENUMpar, um unsere neuen Ideen
auf ihren praktischen Vorteil und Effizienz zu untersuchen. Die Prozedur SEpar kann
in den Operationen der Skalarproduktberechnungen sowie der Gitterbasisreduktion
parallelisiert werden. Die übrigen Schritte bringen keinen Erfolg bei der Parallelisierung nach dieser Vorgehensweise. Dennoch sind beachtliche Laufzeitgewinne zu
verzeichnen. Wir mussten dennoch feststellen, dass die Laufzeit der Implementierung
des SE aus der NTL geringer als die unserer Implementierung ist.
Eine deutlich höhere Beschleunigung erreicht die Prozedur ENUMpar. Das Aufzählverfahren ENUMpar zum Auffinden kürzester Vektoren scheint annähernd mit einer
Effizienz von 1.0 und höher eine Lösung auszugeben. In kleinen Blockgrößen ist die
sequentielle Implementierung des ENUM minimal schneller. Dies ist jedoch wichtig,
da in einem BKZ Algorithmus mit kleinen Blockgrößen sehr viele ENUM Aufrufe stattfinden. In der Summe macht es sich in der Laufzeit durchaus bemerkbar.
ENUMpar eignet sich sehr in Fällen, wo das Interesse für das Aufrufen einer einzigen Instanz ausserhalb des BKZ Algorithmus liegt. Hier kann die ganze Effizienz
des ENUMpar zum Tragen kommen.
Der erste parallele BKZ Algorithmus scheint vielversprechend zu sein. Die besondere
Effizienz des ENUMpar macht sich allerdings erst ab Blockgrößen 45 im BKZpar in
der Laufzeit bemerkbar. In den heute genutzten Blockweiten zwischen 20 und 30 ist
das serielle Aufzählverfahren ENUM schneller. Dennoch haben wir mit der ersten
Özgür Dagdelen
70
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
7. Zusammenfassung und Ausblick
parallelen Variante des BKZ Algorithmus den ersten Schritt für eine Beschleunigung
des BKZ erreicht.
Weitere Optimierungen des BKZpar sind möglich. Durch weitere Tests können die
Parameter für den SEpar sowie für ENUMpar für eine optimale Beschleunigung
angepasst werden. Ausserdem könnte eine intelligente Prioritätsliste bei der Speicherung der Threads für das ENUMpar von Nutzen sein. Durch Einführung einer
Priorität innerhalb der Threads könnten schneller neuere Minima gefunden werden,
wodurch die Durchsuchung einiger Teilbäume eingespart werden könnte.
Aufgrund der exponentiellen Komplexität wird die Ausführung des parallelen BKZpar
trotz der linearen Beschleunigung nicht in akzeptabler Laufzeit realisierbar wie vorerst angenommen. Sicherlich sind größere Blockgrößen anwendbar. Interessanter
wäre es die Parallelisierung geeigneter an das BKZ anzupassen, statt die einzelnen Prozeduren zu parallelisieren. Dies verpflichtet womöglich dazu, sich von der
sequentiellen Vorgehensweise zu lösen.
Es besteht die Überlegung nicht die einzelnen ENUM Aufrufe zu parallelisieren,
sondern simultan mehrere ENUM Instanzen zu starten und die gefundenen Vektoren
an die passende Position im Gitter hinzuzufügen. Fraglich ist hier, was man sich
dabei versprechen kann. Denn außer dem ersten ENUM Aufruf sind die Vektoren
in den übrigen ENUM Aufrufen nicht aktuell gehalten verglichen mit der seriellen
Vorgehensweise. Es ist interessant, dies weiter zu untersuchen.
Eine weiterer Ansatz liegt in der Einführung einer dynamischen Anpassung der
Blockgröße im BKZ. Um ENUMpar effizient zu nutzen, kann in den vorderen kürzeren
Vektoren eine größere Blockgröße verwendet werden als in den hinteren längeren Vektoren. Durch das Verringern der Blockgröße mit fortlaufender Position, in welcher
man sich im BKZ befindet, kann zuerst der parallele ENUMpar aufgerufen werden.
Sobald die Blockgröße klein genug ist, wird die serielle Implementierung ENUM verwendet. Dies verhindert Aufrufe des ENUMpar in kleinen Blockgrößen und kann
deutlich die erzielten Ergebnisse verbessern. Der Nachteil hierbei liegt darin, dass
beweisbar nur eine βmin - reduzierte Basis als Ergebnis zurückgegeben wird, wobei
βmin die kleinste verwendete Blockgröße ist.
Unsere Implementierung unterstüzt die Verwendung beliebig vieler Prozessoren.
Wissenswert wäre die Entwicklung der Beschleunigung und Effizienz des BKZpar
sowie ENUMpar, wenn deutlich mehr als 16 Prozessoren genutzt werden. Interessant wäre, ob diese hohe Effizienz vor allem des ENUMpar noch aufrecht erhalten
bleibt und welche Blockgrößen dann realisierbar wären.
Özgür Dagdelen
71
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
Literaturverzeichnis
Literaturverzeichnis
AD97 Miklós Ajtai and Cynthia Dwork. A public-key cryptosystem with worstcase/average-case equivalence. In Proceedings of the 29th Annual ACM
Symposium on Theory of Computing, STOC’97 (El Paso, Texas, May 46, 1997), pages 284–293, New York, 1997. ACM Press. 1
Bac98 Werner Backes. Berechnung kürzester Gittervektoren. Master’s thesis,
Universität des Saarlandes, 1998. 5.2, 5.2
BL06 Johannes Buchmann and Christoph Ludwig. Practical lattice basis sampling reduction. In Florian Hess, Sebastian Pauli, and Michael E. Pohst,
editors, ANTS, volume 4076 of Lecture Notes in Computer Science, pages
222–237. Springer, 2006. 3.4
BLR08 Johannes Buchmann, Richard Lindner, and Markus Rückert. Explicit hard
instances of the shortest vector problem. In Post-Quantum Cryptography
(PQCrypto) 2008, pages 79–94. Springer-Verlag, 2008. 6.2
BW08 Werner Backes and Susanne Wetzel. A parallel LLL using POSIX threads.
Technical Report 2008-12, DIMACS, Fri November 14 07:32:13 2008. Fri
Nov 14 07:35:33 EST 2008. 4.2, 4.2, 4.2, 6.2
Daua Jean-Marie Dautelle. Java tools and libraries for the advancement of
sciences. http://jscience.org/. 6.1
Daub Jean-Marie Dautelle. Javolution - The Java Solution for Real-Time and
Embedded Systems. http://javolution.org/. 6.2
Fil02 Bartol Filipovic. Implementierung der Gitterbasenreduktion in Segmenten. Master’s thesis, Universität Frankfurt, 2002. 3.1, 3.1, 3.4
FP85 U. Fincke and M. Pohst. Improved methods for calculating vectors of
short length in a lattice, including a complexity analysis. Math. Comp.,
44:463–471, 1985. 5.2
Özgür Dagdelen
72
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
Literaturverzeichnis
GGH96 Oded Goldreich, Shafi Goldwasser, and Shai Halevi. Collision-free hashing
from lattice problems. Electronic Colloquium on Computational Complexity (ECCC), 3(42), 1996. 1
GN08a N. Gama and P. Q. Nguyen. Finding short lattice vectors within Mordell’s
inequality. In STOC ’08 – Proc. 40th ACM Symposium on the Theory of
Computing. ACM, 2008. 3.3
GN08b Nicolas Gama and Phong Q. Nguyen. Predicting lattice reduction. In
Advances in Cryptology – Proc. Eurocrypt ’08, Lecture Notes in Computer
Science. Springer, 2008. 3.3
GV96 Gene H. Golub and Charles F. Van Loan. Matrix Computation. John
Hopkins Studies in the Mathematical Sciences. Johns Hopkins University
Press, Baltimore, Maryland, third edition, 1996. 2.3
Hec95 C. Heckler. Automatische Parallelisierung und parallele Gitterbasisreduktion. Dissertation, Universität des Saarlandes, Saarbrücken, March 1995.
Institut für Mikroelektronik. 2.3, 4, 4.1, 4.1, 4.1, 4.1, 4.2
HPS98 J. Hoffstein, J. Pipher, and J. Silverman. NTRU: A ring based public-key
cryptosystem. In Third International Algorithmic Number Theory Symposium (ANTS-III), volume 1423 of Lecture Notes in Computer Science,
pages 268–288. Springer-Verlag, Berlin Germany, 1998. 1
Hör94 H.H. Hörner. Verbesserte Gitterbasenreduktion; getestet am ChorRivest
Kryptosystem und an allgemeinen Rucksackproblemen. Master’s thesis,
Universität Frankfurt, August 1994. 3.3, 3.3, 5, 5.2
HT93 Christian Heckler and Lothar Thiele. Parallel complexity of lattice basis
reduction and a floating-point parallel algorithm. In Arndt Bode, Mike
Reeve, and Gottfried Wolf, editors, Proceedings of the 5th International
Conference on Parallel Architectures and Languages Europe, PARLE’93
(Munich, Germany, June 1993), volume 694 of LNCS, pages 744–747.
Springer-Verlag, Berlin-Heidelberg-New York-London-Paris-Tokyo-Hong
Kong-Barcelona-Budapest, 1993. 4.1
JS98 Joux and Stern.
Lattice reduction: A toolbox for the cryptanalyst.
JCRYPTOL: Journal of Cryptology, 11, 1998. 1
KS01a H. Koy and C. P. Schnorr. Segment LLL-reduction of lattice bases. In
Joseph H. Silverman, editor, CaLC, volume 2146 of Lecture Notes in Computer Science, pages 67–80. Springer, 2001. 3.4
Özgür Dagdelen
73
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
Literaturverzeichnis
KS01b H. Koy and C. P. Schnorr. Segment LLL-reduction with floating point
orthogonalization. In Joseph H. Silverman, editor, CaLC, volume 2146 of
Lecture Notes in Computer Science, pages 81–96. Springer, 2001. 2.3
KS02 H. Koy and C. P. Schnorr. Segment and strong segment LLL-reduction of
lattice bases., May 2002. 3.4
LLL82 A. K. Lenstra, H. W. Lenstra Jr., and L. Lovász. Factoring polynomials
with rational coefficients. Mathematische Annalen, 261:515–534, 1982. 1,
2.5, 3.1
Lud05 Christop Ludwig. Practical Lattice Basis Sampling Reduction. Dissertation, Technische Universität Darmstadt, 2005. 3.4
May05 Alexander May. Public Key Kryptanalyse, Skript einer Vorlesung an der
Technischen Universität Darmstadt, 2005. 2.2
Ngu99 Phong Nguyen. Cryptanalysis of the Goldreich-Goldwasser-Halevi cryptosystem from Crypto’97. In Michael Wiener, editor, Advances in Cryptology
– CRYPTO ’ 99, volume 1666 of Lecture Notes in Computer Science, pages 288–304. International Association for Cryptologic Research, SpringerVerlag, Berlin Germany, 1999. 1
NS00 Phong Q. Nguyen and Jacques Stern. Lattice reduction in cryptology: An
update. In Wieb Bosma, editor, ANTS, volume 1838 of Lecture Notes in
Computer Science, pages 85–112. Springer, 2000. 1
NS01 Phong Q. Nguyen and Jacques Stern. The two faces of lattices in cryptology. In Joseph H. Silverman, editor, CaLC, volume 2146 of Lecture Notes
in Computer Science, pages 146–180. Springer, 2001. 1
NS05 P. Nguyen and D. Stehle. Floating-point LLL revisited. Lecture Notes in
Computer Science, 3494:215–233, 2005. 2.3
PS08 Xavier Pujol and Damien Stehlé. Rigorous and efficient short lattice vectors enumeration. In Josef Pieprzyk, editor, ASIACRYPT, volume 5350
of Lecture Notes in Computer Science, pages 390–405. Springer, 2008. 3.3,
5.2, 5.2, 5.1, 5.2
rnHK Dr. rer. nat. Heinz Kredel. Java algebra system (jas) project. http:
//krum.rz.uni-mannheim.de/jas/. 6.1
RSA78 R. L. Rivest, A. Shamir, and L. Adleman. A method for obtaining digital signatures and public key cryptosystems. Communications of the
Özgür Dagdelen
74
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
Literaturverzeichnis
ACM, 21(2):120, February 1978. The basics of trap-door functions and
the famous RSA public key cryptosystem are presented in this paper. 1
Sch87 Claus Peter Schnorr. A hierarchy of polynomial time lattice basis reduction
algorithms. Theoretical Computer Science, 53(2–3):201–224, 1987. 3.3
Sch01 Claus Peter Schnorr. Gittertheorie und algorithmische Geometrie, Reduktion von Gitterbasen und Polynomidealen, Vorlesungskript , 2001. 2.1
Sch03 Claus Peter Schnorr. Lattice reduction by random sampling and birthday
methods. In Helmut Alt and Michel Habib, editors, STACS, volume 2607
of Lecture Notes in Computer Science, pages 145–156. Springer, 2003. 3.4
Sch06a Claus Peter Schnorr. Blockwise lattice basis reduction revisited. Workshop
Codes and Lattices in Cryptography, September 2006. 3.4
Sch06b Claus Peter Schnorr. Fast LLL-type lattice reduction. INFCTRL: Information and Computation (formerly Information and Control), 204, 2006.
3.1, 3.4
Sch07 Claus Peter Schnorr. Progress on lll and lattice reduction. In Proceedings
LLL+25, 2007. 2.3, 3.1
SE91 C. P. Schnorr and M. Euchner. Lattice basis reduction: Improved practical algorithms and solving subset sum problems. In L. Budach, editor,
Proceedings of the 8th International Conference on Fundamentals of Computation Theory (FCT ’91) (Gosen, Germany, September 1991), volume
529 of LNCS, pages 68–85. Springer-Verlag, Berlin-Göttingen-HeidelbergNew York, 1991. 2.5, 3.1, 3.3, 6.3
Sho
Victor Shoup. Number theory library (NTL) for C++, version 5.4.2. http:
//www.shoup.net/ntl/. 6.1
Tom
Mikko Tommila. Arbitrary precision arithmetic library for Java. http:
//www.apfloat.org/apfloat_java/. 6.1
Vil92 Gilles Villard. Parallel lattice basis reduction. In Paul S. Wang, editor,
Proceedings of ISSAC ’92. International Symposium on Symbolic and Algebraic Computation, pages 269–277, pub-ACM:adr, 1992. ACM Press.
4.1
Wet98 Susanne Wetzel.
An efficient parallel block-reduction algorithm.
In
J. P. Buhler, editor, Proceedings of the 3rd International Symposi-
Özgür Dagdelen
75
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
Literaturverzeichnis
um on Algorithmic Number Theory, ANTS’98 (Portland, Oregon, June 21-25, 1998), volume 1423 of LNCS, pages 323–337. SpringerVerlag, Berlin-Heidelberg-New York-Barcelona-Budapest-Hong KongLondon-Milan-Paris-Singapore-Tokyo, 1998. 4.1
Wie94 Kay Wiese. Parallelisierung von LLL-Algorithmen zur Gitterbasisreduktion. Master’s thesis, Technische Universität Darmstadt, 1994. 2.3, 3.1,
3.1, 4.1, 4.2
Özgür Dagdelen
76
Parallelisierung von Gitterbasisreduktionen
Paralleler BKZ - Algorithmus
A. Anhang
A. Anhang
Während der Recherche zu der Ausarbeitung wurden viele Algorithmen zur Gitterbasisreduktion betrachtet. Neben den sequentiellen Algorithmen wurde auch genauer
auf vorhandene parallele Algorithmen eingegangen. Dabei wurde eine Übersicht der
vorhandenen Algorithmen erstellt, welche wir hier im Anhang für interessierte Leser
beifügen möchten.
Özgür Dagdelen
i
O(d²m log1/δ M) [d+log2M0]
O(dn log1/δ M)
[2d+log2(M0M1²)] / [5d+log2(M0²M1³)]
O(dn log2n log1/δ M) / O(nd log1/δ M)
[7d+O(n)+2log2M0] / [2d+2log2M0] /
[O(log2M)]
O(d²n+d log2n log1/δ M)
[d logM0]
LLLH
SLLL0
SLLL (skaliert)
k-Segment LLL
SLLL+
SSLLL
O(d log M)
5
O(d³n log M) [d log2M]
[Zahlenlänge]
Arithmetische Operationen
Modified LLL
LLLFP (+tiefe Einfügungen)
LLL
Algorithmus
λ1²
λ1²
λ1²
(det L)
λ1²
(n-1)
(n-1)/4
n-1
‖ b1 ‖² ≤ (α/δ)
‖ b1 ‖² ≤
‖ b1 ‖² ≤
‖ b1 ‖² ≤ (α/δ)
‖ b1 ‖² ≤ α
Qualität
1/n
2
n log B Tauschs
GS-Orth. Reparatur möglich (O(n²) statt O(n³))
Einführung GKA → Rundungsfehlermaßnahmen notwendig
•
Skalarprodukt zu klein
•
Reduktionskoeffizient zu groß |⌈µk,l ⌋| > 2τ/2
•
δ > ½ muss gewählt werden
Keine Garantie auf Term., falls Genauigkeit der fpa zu klein
Stabil bis Dimension 125 und Zahlengröße 300 Bits
Tiefe Einfügungen: füge direkt in Pos. i<k statt nur tauschen
•
für polynomielle Zeit wird Schranke benötigt
•
Kompromiss: mehr Laufzeit → bessere Ergebnisse
Aktualisiere GS und Größenreduktion bis kein Tausch möglich
Mehr arithmetische Operationen als LLL
LLL with HO (Householder Orth.) using TriColl
TriColl berechnet rl und hl
t
10
n
Falls 2 ≥ 2 m ρ → appr. LLL Basis:
(j-i)/2
•
|µj,i| < ½ + ϵ αϵ rjj/rii + ϵ
Stabil bis Dimension 350
So viel LLL wie möglich lokal in Segmenten durchführen
Nutzt localLLL(Rl,k)
-3
•
#localLLL ≤ 2nk log1/δ M
und TriSegl,k
•
Trianguliert und größenreduziert Bl,k, Bl+1,k
•
TriCol
τ
10
n
Es benötigt 2 ≥ 2 m ρ M1² Genauigkeit
Verhindere die benötigte Zahlengenauigkeit
Beschränktes Ansteigen der Höhe beim Übergang Bl, Bl+1 erlaubt
(Qualitätsverlust)
LLLSeql,1:
•
teile localLLL(Rl,1) so dass ‖Tl,1‖ ≤ 9 ⋅ 2n+1
(1)
-n/2
•
verkleinern von D mit Faktor 2
1/8
SLLL mit δ‘ = δ besser als LLL mit δ (SLLL Dauer wird 3 mal länger als mit δ)
Skalierte Version:
•
Orth. mit Vektoren etwa gleicher Länge (Streckung nötig)
•
HRS
•
Stabil für Dimension > 1000
Eine SLLL Variante, die LLL Operationen auf immer größer werdende
Subsegmente anwendet und die dadurch entstandenen lokalen
Transformationen werden rekursiv weitergegeben.
Schneller als SLLL aber benötigt mehr Genauigkeitsbits
Einführung von schwachen und starken Segmenten
Bemerkungen
[13]
[1], [12]
[1], [6], [12], [13],
[14], [15]
[1], [12]
[1], [12]
[11]
[1], [2], [3], [4], [5],
[6], [7], [8]
[1], [3], [5], [9], [10]
Literatur
Durchschnitt:
Primal Dual RSR
]
Siehe Semi-Block 2k Red.
[
O(d²n s log1/δ 2)
Semi-Block 2k Reduktion
Primal Dual Reduktion
/ Primal-duale Segment Reduktion
ENUM
Basis
BKZ
Schnorr/Euchner Algo.
ISLLL
s-1 (n-1)/2
‖ b1 ‖² ≤ (α/δ )
(det L)
2/n
→ HKZ Reduktion
lineare Stutzung
linear verschobene Stutzung
lineare Stutzung mit beschränkten Koeffizienten
Ansatz „gleichmäßige Last“
Gaußsche Volumenheuristik
Adaptionsverfahren
HKZ Reduktionen auf und
Qualität besser als Semi-Block Red. außer wenn
Primal-duale Segment Reduktion
Statt HKZ nun ENUM
•
Parallelisierbar durch Einführung von Phasen (m/2 Proz.)
Ersetze HKZ durch RSR
3 Hauptschritte
1.
Primal RSR auf
2.
Dual RSR auf
3.
Global RSR
2k Block
•
•
•
•
•
•
Erweitern eines primitiven Vektors zu einer Basis (schneller als LLL)
Finde
, so dass
→ neue Basis
Verhinderung doppelten Aufrufs des LLL nach/bevor Nullvektor Eliminierung
Minimiere
Finde durch Tiefensuche
, so dass
Ab β > 20 sehr langsam, β > 30 nicht mehr durchführbar
→ Einführung Stutzung
Abschwächen der Bedingung
k²
σ k²
D(l) ≤ (α/δ) D(l+1) → D(l) ≤ (α/δ ) D(l+1) mit σ = Segmentlevel
LLL beschleunigen mit fpa
Stabil und schnell falls Genauigkeit hoch genug
Verbesserung der Performance durch verschiedene Heuristiken
•
Late Size-Reduction, Modified Size-Reduction, Iterative Heuristics,
Modular Δ, Deep Insertion
Seriell etwa 3 mal schneller als Alltauschalgortihmus
Parallelisierbar mit n Prozessoren
•
Orth [n+6k], Größenred [3n+10k] noch O(n) statt O(n²)
•
Mit POSIX Threads (1,2 und 4 Prozessoren/Kerne)
Erst Aufruf der LLL-reduktion zur Bereitstellung der Höhenquadrate und GSKoeffizienten
Aufruf der ENUM-Funktion (das Zeitaufwändigste in hohen Dim.)
Zyklisches nach Rechts rotieren (1 Pos) mit Fensterbreite ß, so dass ĉj ≥ δ cj
Hörner gibt verschiedene BKZ Varianten mit Verbesserungen
•
Aufruf L³FP bei Stufe j-1 statt j (zur Garantie der Terminierung)
•
Basis Aufruf vorher
•
Neues
vorher nutzen
[1], [12], [19]
[1], [6], [12], [19]
[1], [12], [19]
[3], [9], [10], [18],
[26], [28], [29], [30],
[31]
[9], [10]
[3], [6], [9], [10],
[18], [26], [29]
[2], [7], [16], [17],
[24]
[13]
LLL²
Sampling Reduction / RSR
Parallel Block Reduktion
GivensRot
Alltausch Algo.
]
Bitkomplexität
Siehe Alltausch Algo.
Seriell:
n Proz:
n² Proz:
[
LLL mit
und
Primal-dual:
2k- red:
SR:
•
•
•
, welches mit 50% einen Vektor
in Zeit von
)
Angaben alle unter GSA,RA
SR:
•
Kein GSA benötigt → BESTBOUND wird genutzt
•
Problem: nur die ersten Vektoren sind gut approx.
o
→ Pool SR, Short Projection Reduction
Die Genauigkeit der Gram-Schmidt Berechnungen werden durch
systematische Verwendung der Gram Matrix verbessert
Teilweise Verwendung der Cholesky Faktorisierung im iterativen Baibai
(k=48 → apfa:
liefert mit apfa
SA: O(n²) Zeit → generiere b mit b kürzer als b1
SHORT: benutze SA um b zu finden, so dass
Wiederhole O(n) mal SHORT
LLL:
•
Im WorstCase keine Terminierung
RSR ist eine Erweiterung von tiefe Einfügungen
Idee: soviele Tauschs wie möglich in einer Phase ausführen (gerade, ungerade)
GS-Orth. durch Givensrotationen
Größe der Zahlen während Größenred:
•
LLL:
•
Alltausch:
Modi:
•
Orth: seriell, durchfallend, zyklisch
•
GR: verteilt, Ring, zyklisch
•
Architektur: Rechnernetz, MIMD, SIMD
guter Tausch wenn
(abh. von Fehler aus Givensrotation)
Für exakte Arithmetik nicht geeignet, da zu große Zahlen auftreten können
Reihenfolge der Berechnungen von c,s wichtig
Fehler durch Givensrotation:
Parallelisierbar auf n,n² Prozessoren
m disjunkte Blöcke der Größe l
die zuvor lokal LLL reduziert
werden, dann global.
Tausche Vektoren an den Rändern, wenn LLL Bedingung nicht gilt
Parallelisierbar auf n,n² Prozessoren
Praktische Ergebnisse: beste Aufsicht auf Erfolg beim Parallelisieren für β = 2
Ziel: möglichst guten Approximationsfaktor erreichen
Approximationsfaktor einiger Algorithmen:
[27]
[22], [23], [25]
[11]
[5], [7]
[4], [5], [7], [8], [11],
[20], [21]
•
•
•
•
•
δ
geordnet und längenreduziert
HKZ reduziert
o
o
HKZ reduziert
sowie GNF
Primal-Dual Reduktion für k
o
o
o
,
Semi Block 2k Reduktion
mit
sowie GNF
o
o
(ß-reduziert) BKZ, falls
o
o
HKZ (Hermite und Korkine Zolotareff) für
o
o
LLL, falls
(längenreduziert)
eine Gitterbasis,
Gram-Schmidt Koeffizienten. Gelte
Sei
, falls
, falls
, falls
, dann gilt
•
•
•
•
o
SLLL+
o
SLLL für
falls
o
o
o
o
δ
, falls
für ,
mit
, falls
und alle l, mit
, falls
für ungerade
geordnet und längenreduziert
,
k-Segment LLL
o
o
SLLL0 für k,
reduziert im Sinne von
die zugehörige Gram-Schmidt Orthogonalisierung und seien
Verschiedene Algorithmen besitzen ihre eigene Auslegung des Reduktionsbegriffs. Hier sind einige nochmal zusammengefasst aufgelistet:
L³FPV, ENUMV, SchnittENUM
Nearest Plane Algorithmus für die Gram –Schmidt Berechnungen
Anwendung der Lazy Size-Reduction
Vektorbasierte Variante
[10]
,
die
[1] Claus Peter Schnorr:
[2] Werner Backes, Susanne Wetzel:
[3] C.P.Schnorr, M.Euchner:
[4] C. Heckler, L. Thiele:
[5] Kay Wiese:
[6] Bartol Filipović:
[7] C. Heckler:
[8] Gilles Villard:
[9] Horst Helmut Hörner:
[10] Markus Michalek:
[11] Susanne Wetzel:
[12] Claus Peter Schnorr:
[13] H. Koy, C. P. Schnorr:
[14] H. Koy, C. P. Schnorr:
[15] H. Koy, C. P. Schnorr:
[16] W. Backes, S. Wetzel:
[17] W. Backes, S. Wetzel:
[18] Michael Kaib:
[19] Claus Peter Schnorr:
[20] C. Heckler, L. Thiele:
[21] C. Heckler, L. Thiele:
[22] C.P. Schnorr:
[23] J. Buchmann, C. Ludwig:
[24] W.Backes, S. Wetzel:
[25] C. Ludwig:
[26] M. Kaib, H. Ritter
[27] Phong Q. Nguyen, Damien Stehlé:
[28] Xavier Pujol, Damien Stehlé:
[29] Hörner, Schnorr:
[30] Backes:
[31] Ritter:
Progress on LLL and Lattice Reduction
Lattice Basis Reduction with Dynamic Approximation
Lattice Basis Reduction: Improved Practical Algorithms and Solving Subset Sum Problems
A Parallel Lattice Basis Reduction for Mesh-connected Processor Arrays and Parallel Complexity
Parallelisierung von LLL Algorithmen zur Gitterbasisreduktion
Implementierung der Gitterbasenreduktion in Segmenten
Automatische Parallelisierung und parallele Gitterbasisreduktion
Parallel lattice basis reduction
Verbesserte Gitterbasenreduktion; getestet am Chor-Rivest Kryptosystem und an allgemeinen Rucksackproblemen
Gitteralgorithmen auf dem Vektorrechner
An Efficient Parallel Block-Reduction Algorithm
Fast LLL-Type Lattice Reduction
Segment and Strong Segment LLL-Reduction of Lattice Bases.
Segment LLL-Reduction of Lattice Bases
Segment LLL-Reduction with Floating Point Orthogonalization
New Results on Lattice Basis Reduction in Practice
Heuristics on Lattice Basis Reduction in Practice
Gitterbasenreduktion für beliebige Normen
Blockwise Lattice Basis Reduction Revisited
Complexity Analysis of a Parallel Lattice Basis Reduction Algorithm
Parallel Complexity of Lattice Basis Reduction and a Floating-Point Parallel Algorithm
Lattice Reduction by Random Sampling and Birthday Methods
Practical Lattice Basis Sampling Reduction
A Parallel LLL using POSIX Threads
Practical Lattice Basis Sampling Reduction
Block Reduction for Arbitrary Norms
Floating-Point LLL Revisited
Rigorous and Efficient Short Lattice Vectors Enumertions
Attacking the Chor-Rivest Cryptosystem by Improved Lattice Reduction
Berechnung kürzester Gittervektoren
Aufzählungsverfahren kürzester Gittern beliebiger Norm
Die verwendeten Paper für die Übersicht der Algorithmen: