View Full Version : Durch SQL-Trigger eine 60-fache Laufzeit des betroffenen Progamms.
Da ist es immer schwer eine Vorhersage zu machen.
Fakt ist, dass die Anzahl der Writes sich mindestens halbieren muss, da sie ja verteilt werden.
Nun hängt es von weiteren Faktoren ab, wie sich die IO's verteilen.
- Satzlänge und damit die Anzahl gepufferten Writes
- Speicherort auf dem Plattenarray (ggf. sind beide Dateien physisch auf derselben Disk)
Aber immherhin ist das nicht Faktor 60 sondern nur 7.
Und wie sieht die Aufgabenstellung aus?
Muss die Kopie bei Masseninsert durchden Trigger erfolgen oder reicht ein folgender "insert into ... select from ..."?
Letzteres kann durchaus effektiver sein, da nur blockweise gelesen werden muss während beim Insert mehrere Aktionen stattfinden:
- Satznummer aus der Kette der gelöschten ermitteln
- Falls keine gelöschten, ggf. Datei erweitern
- Satz schreiben
Da ist es immer schwer eine Vorhersage zu machen.
Fakt ist, dass die Anzahl der Writes sich mindestens halbieren muss, da sie ja verteilt werden.
Nun hängt es von weiteren Faktoren ab, wie sich die IO's verteilen.
- Satzlänge und damit die Anzahl gepufferten Writes
- Speicherort auf dem Plattenarray (ggf. sind beide Dateien physisch auf derselben Disk)
Aber immherhin ist das nicht Faktor 60 sondern nur 7.
Und wie sieht die Aufgabenstellung aus?
Muss die Kopie bei Masseninsert durchden Trigger erfolgen oder reicht ein folgender "insert into ... select from ..."?
Letzteres kann durchaus effektiver sein, da nur blockweise gelesen werden muss während beim Insert mehrere Aktionen stattfinden:
- Satznummer aus der Kette der gelöschten ermitteln
- Falls keine gelöschten, ggf. Datei erweitern
- Satz schreiben
Bulk Operationen haben unter günstigen Bedingungen einen erheblich höheren Durchsatz wie satzweise Operationen. Zur Blockung beim lesen kommen noch Blockung beim schreiben, geändertes Sperrhandling, Optimierung beim Zugriff. Der Trigger erzwingt satzweise Verarbeitung, die mit ca 500 Operationen/sec durchaus plausibel erscheint.
Ähnliche Leistung wie bei Bulk Operationen erzielt man bei satzweiser Verarbeitung allenfalls bei massiver Parallelisierung.
D*B
In diesem Fall reicht ein nachträglicher insert into... select from...
Jedoch macht mir der Datendurchsatz bei den geplanten History-Tabellen Bauchschmerzen.
Bei den einzelnen Aufträgen (Auftragserfassung/-änderung) ist das noch kein Problem, da im Max nur 2-3 Sätze hinzugefügt oder aktualisiert werden.
Jedoch kann es auf die Fakturierung auswirkungen haben.
Die oben genannten Werte habe ich übrigens auch schon mit den CASE WHEN... Funktionsaufrufen erreicht. Die Funktionen wurden ja durch die CASE-Bedingung nicht aufgerufen.
CASE WHEN... hat also keine großen Auswirkungen.
Das 60-fache war im gesamten Programmablauf aufgekommen. Hier spielt der Update-Trigger die größere Rolle, da dieser pro Satz mehrfach ausgelöst wurde (das Programm ist optimierungswürdig :( )
Das 7-fache bei einem reinen Insert ohne Manipulationen ist schon nicht akzeptabel.
Nun, dann kommt ggf. der Update ON EACH STATEMENT doch noch zum Tragen.
Dann kannst du in diesem Fall den "insert ... select .... from inserted" als Bulkinsert codieren.
Allerdings weiß ich nicht, ob durch die temporäre Inserted-Table und den dadurch zusätzlichen Write die Performance da wirklich besser ist.
Bei deinem später noch geplanten Update wird dann auch noch die Indexoptimierung gravierend.
andreaspr@aon.at
28-10-19, 19:01
Vielleicht auch noch ein paar Gedanken:
* was hat die Tabelle beim Attribut REUSEDLT hinterlegt? (DSPFD)
Bei *NO wird immer am Tabellen-Ende hinzugefügt.
Bei *YES sucht er den nächsten freien Platz
* Hast du schon den DB-Monitor gestartet?
Wieviele "Hard-Open" zur Tabelle gemacht?
Falls er (aus was für einen Grund auch immer) öfters ein Hard-Open machen muss, stimmt was grundsätzlich nicht.
* Schon probiert mit Commitment Control zu arbeiten?
Also das ATOMIC weg lassen und im aufrufer Programm Commit Steuerung aktivieren.
Dann läuft der Trigger im gleichen Isolation Level wie der Aufrufer.
Hat den Vorteil dass man sich I/O ersparen kann wenn man am ende erst ein COMMIT absetzt und dadurch mit größeren Blöcken auf die Disk schreibt.
* Probier mal MODE DB2ROW statt DB2SQL
lg Andreas
Journalisierung erhöht die IO's und ändert am Blocken nichts.
Laut Doku wird DB2ROW ignoriert und sowieso DB2SQL verwendet.
andreaspr@aon.at
29-10-19, 17:24
Dem mit Commit wiederspreche ich!
Mit Commit können die IO's nachweislich verringert werden.
Denn das System schreibt dann nach dem Commit mit Blöcken auf die Disk.
Ohne Commit (*NONE) wird für jedes INSERT einzeln geschrieben.
Ich würde sogar sagen, dass du mit Commitsteuerung die meiste Performance hier herausholen könntest.
Dem mit Commit wiederspreche ich!
Mit Commit können die IO's nachweislich verringert werden.
Denn das System schreibt dann nach dem Commit mit Blöcken auf die Disk.
Ohne Commit (*NONE) wird für jedes INSERT einzeln geschrieben.
Ich würde sogar sagen, dass du mit Commitsteuerung die meiste Performance hier herausholen könntest.
... commit bei Bulk Operationen ist fatal, da werden Millionen von Sperrren eingesammelt und beim eventuellen Rollback geht die Kiste in die Knie. Journalisierung kann durchaus positive Wirkungen haben, da dann die sequentiellen Schreiboperationen auf die Receiver vorgezogen werden, die kaum Strom kosten - wenn denn die Hardware Bilanz das zulässt.
Im vorliegenden Fall, wenn ich denn die rudimentäre Problembeschreibung richtig verstehe, ist der Trigger das vorrangige Problem, da selbiger die Bulk Operation zur satzweisen Verarbeitung zwingt.
Aus meinen Erfahrungen sehe ich zwei mögliche Strategien:
- Sequenz von Bulk Operationen (hierbei sollte man prüfen, ob man für inserts alle Indexe auf delayed stellt und im nachhinein parallel wieder hochzieht - kann helfen aber auch massiv schaden)
- Batch Änderungen massiv parallel reinfahren - dann aber mit Commit wg. Collisions.
Generell gilt hier: es gibt keine Patentrezepte, sondern nur Arbeitshypothesen, die sorgfältig evaluiert werden müssen.
D*B
andreaspr@aon.at
29-10-19, 19:47
Im vorliegenden Fall, wenn ich denn die rudimentäre Problembeschreibung richtig verstehe, ist der Trigger das vorrangige Problem, da selbiger die Bulk Operation zur satzweisen Verarbeitung zwingt.
Deshalb war mein Vorschlag die Commitsteuerung übergreifend zu aktivieren und das ATOMIC weg lassen.
Wenn ich mit Commit um ein vielfaches schneller bin, ist die Bilanz auch im Falle eines ROLLBACK immer noch weit im grünen Bereich.
Generell gilt hier: es gibt keine Patentrezepte, sondern nur Arbeitshypothesen, die sorgfältig evaluiert werden müssen.
So ist es!
Gerade wenn es um Performance geht, ist Commit ein wichtiger Bestandteil der leider viel zu oft unterschätzt wird.
Deshalb war mein Vorschlag die Commitsteuerung übergreifend zu aktivieren und das ATOMIC weg lassen.
Wenn ich mit Commit um ein vielfaches schneller bin, ist die Bilanz auch im Falle eines ROLLBACK immer noch weit im grünen Bereich.
So ist es!
Gerade wenn es um Performance geht, ist Commit ein wichtiger Bestandteil der leider viel zu oft unterschätzt wird.
Der Insert-Trigger, um den es hier geht, ist ohne ATOMIC definiert. (siehe Beitrag auf Seite 2)
Das die IBM i bei Commit direkt auf die Platte schreibt, glaub ich nicht. Soweit ich weiss entscheidet das System selbst, in welchen Blöcken, die Daten auf die Platte schreibt, es sei denn ich leite ein kontroliertes Ende ein. Wenn ich ohne Commit-Steuerung arbeite werden alle Änderungen (auch nur im Speicher) geschrieben. Dann als letztes wird die Änderung auf die Platte geschoben.
So, wieder abgeschweift, was ich sagen will ist, wenn die Systemeinstellungen stimmen entscheidet das System über den Plattenzugriff, egal ob mit oder ohne Commit. Da ich auf unserm Testsystem diese Trigger teste, läuft auf diesem System fast nichts anderes. Sie Satzlänge beträgt 130 Byte. 64GB Arbeitsspeicher sind im System. Datentechnisch reden wir bei 6,2 Mio Sätzen von unter 1GB. Somit sollte die IBM i alles im Speicher abfackeln und dann auf die Platte auslagern. Wir reden hier schließlich nicht über PC's, die beim Abruppten beenden alles verlieren, selbst wenn ich das System zwinge sich sofort zu beenden, wird der Speicherzustand noch auf die Platte geschrieben. Somit geht auch in diesem Fall so gut wie nie etwas verloren.
Als RPG-Entwickler weiß ich, dass ein Programm, das unter Commitment-Control läuft die Daten, egal wie viele es sind, erst festgeschriebt, wenn ich den Commit abfeuer. Beende ich das Programm vorher und starte es dann wieder, meckert das System, dass noch nicht festgeschriebene Sätze anstehen. Man muss erst ein Rollback abfeuern um die undefinierten Änderungen zu verwerfen.
SQL arbeitet zwar beim Commit in Blöcken, aber deshalb steuert man nicht, dass das Ergebnis auf die Platte geschrieben wird. Für das System ist Arbeitsspeicher und Platte ein Speicher.
Warum sollte IBM an diesem System, von dem Prinziep abweichen, das macht das System doch von jeher aus.