In diesem Blogbeitrag vergleichen wir die Leistung von drei verschiedenen Algorithmen, die in einem aktuellen pers?nlichen Projekt verwendet wurden: dem ILP (Integer Linear Programming)-Algorithmus, dem Lokaler Algorithmus unter Verwendung des A*-Algorithmus und eine optimierte L?sung unter Verwendung des Branch and Bound-Algorithmus. Alle Algorithmen wurden mit demselben Datensatz getestet, wobei die ILP- und Branch-and-Bound-Implementierungen die gleiche Arbeitslast teilten, w?hrend die A*-Implementierung aufgrund von Leistungseinschr?nkungen eingeschr?nkt war.

Haftungsausschluss: Obwohl ich nicht auf die spezifischen Codedetails des Projekts eingehen werde, werde ich einige Erkenntnisse daraus teilen. Die Codebasis ist nicht zur ?ffentlichen Offenlegung bestimmt und dient als Haftungsausschluss zur Wahrung ihrer Vertraulichkeit.

Benchmark-Ergebnisse

Hier sind die Benchmark-Ergebnisse für alle drei Algorithmen:

goos: linux
goarch: amd64
pkg: github.com/sosalejandro/<my-project>/<my-package>/pkg
cpu: 13th Gen Intel(R) Core(TM) i7-13700HX

BenchmarkGenerateReportILP-24                            724       1694029 ns/op       30332 B/op        181 allocs/op
BenchmarkGenerateReportILPParallel-24                   6512        187871 ns/op       34545 B/op        184 allocs/op
BenchmarkGenerateReportLocal-24                            2     851314106 ns/op    559466456 B/op   7379756 allocs/op
BenchmarkBranchGenerateReportLocal-24                 101449         12106 ns/op       29932 B/op        165 allocs/op
BenchmarkGenerateReportLocalParallel-24                    3     349605952 ns/op    559422440 B/op   7379837 allocs/op
BenchmarkBranchGenerateReportLocalParallel-24         120543         10755 ns/op       29933 B/op        165 allocs/op
PASS
coverage: 81.4% of statements
ok      github.com/sosalejandro/<my-project>/<my-package>/pkg   11.121s

Workload-Konfiguration

Alle Algorithmen wurden mit demselben Datensatz getestet, aber der Arbeitsaufwand (d. h. die H?ufigkeit, mit der jedes Element verarbeitet wird) unterschied sich zwischen den Implementierungen.

ILP- und Branch-and-Bound-Implementierungsarbeitsaufwand:

plan := []Plan{
    {ID: "1", Times: 100},
    {ID: "2", Times: 150},
    {ID: "3", Times: 200},
    {ID: "8", Times: 50},
    {ID: "9", Times: 75},
    {ID: "10", Times: 80},
    {ID: "11", Times: 90},
    {ID: "12", Times: 85},
    {ID: "13", Times: 60},
    {ID: "14", Times: 110},
}

A* Implementierungsaufwand:

plan := []Plan{
    {ID: "1", Times: 1},
    {ID: "2", Times: 1},
    {ID: "3", Times: 5},
    {ID: "8", Times: 5},
    {ID: "9", Times: 5},
    {ID: "10", Times: 5},
    {ID: "11", Times: 9},
    {ID: "12", Times: 5},
    {ID: "13", Times: 5},
    {ID: "14", Times: 5},
}

Workload-Analyse

Um die Auswirkungen dieser Arbeitslasten auf die Benchmark-Ergebnisse zu verstehen, berechnen wir die Gesamtzahl der Iterationen (d. h. die Summe der Zeitwerte) für jede Implementierung.

Gesamtzahl der Iterationen:

• ILP und Branch-and-Bound-Implementierungen:

  100 + 150 + 200 + 50 + 75 + 80 + 90 + 85 + 60 + 110 = 1000

• A*-Implementierung:

  1 + 1 + 5 + 5 + 5 + 5 + 9 + 5 + 5 + 5 = 46

Arbeitsbelastungsverh?ltnis:

ILP Iterations / A* Iterations = 1000 / 46 ≈ 21.74

Das bedeutet, dass die ILP- und Branch-and-Bound-Implementierungen ungef?hr 21,74-mal mehr Iterationen verarbeiten im Vergleich zur A*-Implementierung.

Leistungsvergleich

Lassen Sie uns die Benchmark-Ergebnisse in Bezug auf die Arbeitsbelastungsunterschiede aufschlüsseln.

Beobachtungen

1. Ausführungszeit pro Vorgang:
   • BenchmarkGenerateReportILP-24 vs. BenchmarkBranchGenerateReportLocal-24:
     • Branch and Bound ist 99,29 % schneller als ILP und reduziert die Ausführungszeit von 1.694.029 ns/op auf 12.106 ns/op .

• BenchmarkGenerateReportILP-24 vs BenchmarkGenerateReportLocal-24:

  • ILP ist 99,80 % schneller als Local und reduziert die Ausführungszeit von 851.314.106 ns/op auf 1.694.029 ns/op.

• BenchmarkGenerateReportILPParallel-24 vs BenchmarkBranchGenerateReportLocalParallel-24:

  • Branch and Bound Parallel ist 94,28 % schneller als ILP Parallel und reduziert die Ausführungszeit von 187.871 ns/op auf 10.755 ns /op.

• BenchmarkGenerateReportILPParallel-24 vs. BenchmarkGenerateReportLocalParallel-24:

  • ILP Parallel ist 99,95 % schneller als Local Parallel und reduziert die Ausführungszeit von 349.605.952 ns/op auf 187.871 ns/op .

1. Speicherzuweisungen:

   • ILP-Implementierungen:Leichter Anstieg der Speichernutzung und -zuweisungen bei paralleler Ausführung.
   • Branch-and-Bound-Implementierungen: Geringere Speichernutzung und -zuweisungen im Vergleich zu den A*-Implementierungen.
   • A*-Implementierungen: Extrem hohe Speicherzuweisungen, was zu einer ineffizienten Ressourcennutzung führt.

2. Durchsatz:

   • ILP Parallel und Branch and Bound Parallel k?nnen aufgrund der h?heren Arbeitsbelastung ungef?hr 21,74-mal mehr Iterationen verarbeiten.
   • A*-Implementierungen haben Probleme mit dem Durchsatz, nicht aufgrund der deutlich geringeren Anzahl von Iterationen, sondern aufgrund der ineffizienten Speichernutzung und Implementierung.

Auswirkungen unterschiedlicher Arbeitsbelastung auf die Leistung

Angesichts der Tatsache, dass die ILP- und Branch-Algorithmen 21,74-mal mehr Durchsatz pro Testiteration verarbeiten, wirkt sich dieser Unterschied in der Arbeitslast auf die Leistung und Effizienz jedes Algorithmus aus:

• ILP- ??und Branch-Algorithmen: Da diese einen gr??eren Durchsatz bew?ltigen, sind sie für h?here Arbeitslasten optimiert. Obwohl sie mehr Vorg?nge abwickeln, sorgen sie für kürzere Ausführungszeiten. Dies legt nahe, dass sie nicht nur recheneffizient sind, sondern auch für Hochdurchsatzszenarien gut geeignet sind.

• Lokaler Algorithmus: Mit einem geringeren Durchsatz und einer h?heren Ausführungszeit ist dieser Algorithmus bei der Bew?ltigung erh?hter Arbeitslasten weniger effizient. Bei einer Skalierung auf den gleichen Durchsatz wie ILP oder Branch würde sich die Ausführungszeit erheblich verl?ngern, was darauf hindeutet, dass es nicht ideal für F?lle mit hohem Durchsatz ist.

In Szenarien mit erh?hter Arbeitslast würden ILP und Branch Local übertreffen aufgrund ihrer F?higkeit, einen h?heren Durchsatz effizient zu verwalten. Wenn umgekehrt die Arbeitslast reduziert würde, k?nnte die Leistung des lokalen Algorithmus n?her an der von ILP und Branch liegen, würde aber aufgrund grundlegender Unterschiede in der Algorithmuseffizienz wahrscheinlich immer noch hinterherhinken.

Algorithmusübersicht

Um ein klareres Verst?ndnis dafür zu vermitteln, wie die einzelnen Algorithmen an die Probleml?sung herangehen, finden Sie hier einen allgemeinen überblick über ihre Mechanismen und Methoden.

Ganzzahlige lineare Programmierung (ILP)

Zweck:

ILP ist eine Optimierungstechnik, mit der das beste Ergebnis (z. B. maximaler Gewinn oder niedrigste Kosten) in einem mathematischen Modell ermittelt wird, dessen Anforderungen durch lineare Beziehungen dargestellt werden. Es ist besonders effektiv für Probleme, die durch lineare Einschr?nkungen und eine lineare Zielfunktion ausgedrückt werden k?nnen.

Allgemeiner Arbeitsablauf:

1. Variablen definieren:
   
   Identifizieren Sie die Entscheidungsvariablen, die die zu treffenden Entscheidungen darstellen.

2. Zielfunktion:
   
   Formulieren Sie eine lineare Gleichung, die maximiert oder minimiert werden muss.

3. Einschr?nkungen:
   
   Legen Sie lineare Ungleichungen oder Gleichheiten fest, die die L?sung erfüllen muss.

4. L?sen:
   
   Verwenden Sie einen ILP-L?ser, um die optimalen Werte der Entscheidungsvariablen zu finden, die die Zielfunktion maximieren oder minimieren und gleichzeitig alle Einschr?nkungen erfüllen.

Pseudocode:

goos: linux
goarch: amd64
pkg: github.com/sosalejandro/<my-project>/<my-package>/pkg
cpu: 13th Gen Intel(R) Core(TM) i7-13700HX

BenchmarkGenerateReportILP-24                            724       1694029 ns/op       30332 B/op        181 allocs/op
BenchmarkGenerateReportILPParallel-24                   6512        187871 ns/op       34545 B/op        184 allocs/op
BenchmarkGenerateReportLocal-24                            2     851314106 ns/op    559466456 B/op   7379756 allocs/op
BenchmarkBranchGenerateReportLocal-24                 101449         12106 ns/op       29932 B/op        165 allocs/op
BenchmarkGenerateReportLocalParallel-24                    3     349605952 ns/op    559422440 B/op   7379837 allocs/op
BenchmarkBranchGenerateReportLocalParallel-24         120543         10755 ns/op       29933 B/op        165 allocs/op
PASS
coverage: 81.4% of statements
ok      github.com/sosalejandro/<my-project>/<my-package>/pkg   11.121s

A*-Algorithmus (lokale Implementierung)

Zweck:

A* ist ein Pfadfindungs- und Graph-Traversal-Algorithmus, der für seine Leistung und Genauigkeit bekannt ist. Es findet effizient den kürzesten Weg zwischen Knoten, indem es Funktionen der Suche nach einheitlichen Kosten und der reinen heuristischen Suche kombiniert.

Allgemeiner Arbeitsablauf:

1. Initialisierung:
   
   Beginnen Sie mit einem Anfangsknoten und fügen Sie ihn der Priorit?tswarteschlange hinzu.

2. Schleife:

   • Entfernen Sie den Knoten mit der niedrigsten Kostensch?tzung aus der Priorit?tswarteschlange.
   • Wenn es sich um den Zielknoten handelt, beenden Sie ihn.
   • Andernfalls erweitern Sie den Knoten, indem Sie seine Nachbarn erkunden.
   • Berechnen Sie für jeden Nachbarn die neuen Kosten und aktualisieren Sie die Priorit?tswarteschlange entsprechend.

3. Kündigung:
   
   Der Algorithmus schlie?t ab, wenn der Zielknoten erreicht ist oder die Priorit?tswarteschlange leer ist (was anzeigt, dass kein Pfad vorhanden ist).

Pseudocode:

goos: linux
goarch: amd64
pkg: github.com/sosalejandro/<my-project>/<my-package>/pkg
cpu: 13th Gen Intel(R) Core(TM) i7-13700HX

BenchmarkGenerateReportILP-24                            724       1694029 ns/op       30332 B/op        181 allocs/op
BenchmarkGenerateReportILPParallel-24                   6512        187871 ns/op       34545 B/op        184 allocs/op
BenchmarkGenerateReportLocal-24                            2     851314106 ns/op    559466456 B/op   7379756 allocs/op
BenchmarkBranchGenerateReportLocal-24                 101449         12106 ns/op       29932 B/op        165 allocs/op
BenchmarkGenerateReportLocalParallel-24                    3     349605952 ns/op    559422440 B/op   7379837 allocs/op
BenchmarkBranchGenerateReportLocalParallel-24         120543         10755 ns/op       29933 B/op        165 allocs/op
PASS
coverage: 81.4% of statements
ok      github.com/sosalejandro/<my-project>/<my-package>/pkg   11.121s

Branch-and-Bound-Algorithmus

Zweck:

Branch and Bound ist ein Optimierungsalgorithmus, der den L?sungsraum systematisch erkundet. Es unterteilt das Problem in kleinere Teilprobleme (Verzweigung) und verwendet Grenzen, um Teilprobleme zu eliminieren, die keine besseren L?sungen als die derzeit besten liefern k?nnen (Begrenzung).

Allgemeiner Arbeitsablauf:

1. Initialisierung:
   
   Beginnen Sie mit einer ersten L?sung und legen Sie die bekannteste L?sung fest.

2. Verzweigung:
   
   Teilen Sie das Problem an jedem Knoten in kleinere Teilprobleme auf.

3. Begrenzung:
   
   Berechnen Sie eine optimistische Sch?tzung (Obergrenze) der bestm?glichen L?sung in jedem Zweig.

4. Beschneiden:
   
   Verwerfen Sie Zweige, bei denen die Obergrenze schlechter ist als die bekannteste L?sung.

5. Suche:
   
   Erkunden Sie verbleibende Zweige rekursiv mithilfe der Tiefensuche oder der Bestensuche.

6. Kündigung:
   
   Wenn alle Zweige beschnitten oder erkundet wurden, ist die bekannteste L?sung optimal.

Pseudocode:

goos: linux
goarch: amd64
pkg: github.com/sosalejandro/<my-project>/<my-package>/pkg
cpu: 13th Gen Intel(R) Core(TM) i7-13700HX

BenchmarkGenerateReportILP-24                            724       1694029 ns/op       30332 B/op        181 allocs/op
BenchmarkGenerateReportILPParallel-24                   6512        187871 ns/op       34545 B/op        184 allocs/op
BenchmarkGenerateReportLocal-24                            2     851314106 ns/op    559466456 B/op   7379756 allocs/op
BenchmarkBranchGenerateReportLocal-24                 101449         12106 ns/op       29932 B/op        165 allocs/op
BenchmarkGenerateReportLocalParallel-24                    3     349605952 ns/op    559422440 B/op   7379837 allocs/op
BenchmarkBranchGenerateReportLocalParallel-24         120543         10755 ns/op       29933 B/op        165 allocs/op
PASS
coverage: 81.4% of statements
ok      github.com/sosalejandro/<my-project>/<my-package>/pkg   11.121s

Vergleichende Analyse

Auswirkungen auf die Serverleistung

• Skalierbarkeit:

  • Die Branch and Bound-Implementierung zeigt eine hervorragende Skalierbarkeit und verarbeitet effizient eine gro?e Anzahl gleichzeitiger Anfragen mit reduzierter Latenz.
  • Die ILP Parallel-Implementierung zeigt au?erdem eine hervorragende Skalierbarkeit und verarbeitet effizient eine gro?e Anzahl gleichzeitiger Anfragen mit reduzierter Latenz.
  • Die A*-Implementierung ist aufgrund von Leistungseinschr?nkungen für Umgebungen mit hoher Auslastung ungeeignet.

• Ressourcennutzung:

  • Branch-and-Bound-Implementierungen nutzen Ressourcen effizient, mit geringem Speicherverbrauch und schnellen Ausführungszeiten.
  • ILP Parallel nutzt effektiv Multi-Core-CPUs und bietet so einen hohen Durchsatz bei überschaubarem Speicherverbrauch.
  • A*-Implementierungen verbrauchen überm??ig viel Speicher, was m?glicherweise zur Ersch?pfung der Ressourcen führt.

Auswirkungen der Arbeitslast auf die Leistung

Die Workload-Unterschiede beeinflussen die Leistung der Algorithmen:

• Branch-and-Bound-Implementierung bew?ltigt die gleiche Arbeitslast wie die ILP-Implementierung effizient und sorgt für schnelle Ausführungszeiten und geringe Speichernutzung, sodass sie für die Skalierung geeignet ist.

• ILP-Implementierung bew?ltigt aufgrund optimierter Solver eine gr??ere Arbeitslast effizient.

• A*-Implementierung hat aufgrund hoher Ausführungszeiten und Speichernutzung Probleme mit der Leistung.

Abschluss

Ein zus?tzlicher Vergleich wurde mit einer optimierten L?sung mit dem Branch and Bound-Algorithmus hinzugefügt, der zeigt, wie sich diese im Hinblick auf Leistung und Ressourcennutzung gegenüber dem ILP- und dem A*-Algorithmus deutlich verbessert hat. Die beim Branch-and-Bound-Algorithmus verwendete Arbeitslast ist die gleiche wie beim ILP-Algorithmus.

Die Branch and Bound-basierte BenchmarkBranchGenerateReportLocalParallel-Funktion weist au?ergew?hnliche Leistungsverbesserungen auf und eignet sich daher hervorragend für Serverumgebungen, die eine hohe Parallelit?t und effizientes Ressourcenmanagement erfordern.

Indem wir uns darauf konzentrieren, die St?rken des Branch-and-Bound-Ansatzes zu nutzen und ihn für das spezifische Problem zu optimieren, k?nnen wir sicherstellen, dass das Projekt sowohl leistungsf?hig als auch skalierbar bleibt und in der Lage ist, steigende Anforderungen problemlos zu bew?ltigen.

Letzte Gedanken

Das Gleichgewicht zwischen Leistung, Skalierbarkeit und Entwicklererfahrung ist entscheidend für die Entwicklung robuster Anwendungen. Der Branch and Bound-Ansatz hat sich im aktuellen Setup als der effizienteste erwiesen und bietet erhebliche Leistungssteigerungen bei vertretbarem Entwicklungsaufwand.

Durch die kontinuierliche Profilierung, Optimierung und Nutzung der St?rken jedes algorithmischen Ansatzes k?nnen wir ein leistungsstarkes, skalierbares und entwicklerfreundliches System aufrechterhalten.

Das obige ist der detaillierte Inhalt vonVergleichendes Benchmarking: ILP-, A*- und Branch-and-Bound-Algorithmen in Hochdurchsatzszenarien. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!