Hermann Gahm
ABAP™ Performance Tuning
Bonn 폷 Boston
Auf einen Blick 1
Einführung .......................................................................... 17
2
SAP-Systemarchitektur für ABAP-Entwickler .................... 21
3
Werkzeuge zur Performanceanalyse ................................... 29
4
Parallelisierung ................................................................... 133
5
Datenverarbeitung per SQL ................................................ 155
6
Pufferung von Daten ........................................................... 241
7
Verarbeitung interner Tabellen ........................................... 275
8
Kommunikation mit anderen Systemen ............................. 309
9
Spezielle Themen ................................................................ 317
10
Ausblick .............................................................................. 325
A
Ausführungspläne der verschiedenen Datenbanken .......... 343
B
Der Autor ............................................................................ 363
Inhalt Geleitwort ................................................................................................. Vorwort und Danksagung ..........................................................................
1
Einführung ............................................................................ 17 1.1 1.2 1.3
2
Tuning-Methoden ................................................................... Aufbau des Buches .................................................................. Hinweise zur Verwendung des Buches .....................................
17 19 20
SAP-Systemarchitektur für ABAP-Entwickler ...................... 21 2.1
2.2
3
13 15
Die SAP-Systemarchitektur ...................................................... 2.1.1 Die Dreischichtenarchitektur ....................................... 2.1.2 Verteilung der drei Schichten ...................................... Performanceaspekte der Architektur ........................................ 2.2.1 Frontend ..................................................................... 2.2.2 Applikationsschicht ..................................................... 2.2.3 Datenbank .................................................................. 2.2.4 Zusammenfassung .......................................................
21 22 23 25 26 26 27 27
Werkzeuge zur Performanceanalyse .................................... 29 3.1 3.2 3.3
Übersicht über die Werkzeuge ................................................. Einsatzzeitpunkte der Werkzeuge ............................................ Die Analyse und die Werkzeuge im Detail ............................... 3.3.1 SAP Code Inspector (SCI) ............................................ 3.3.2 Selektivitätsanalyse (DB05) ......................................... 3.3.3 Prozessanalyse (SM50/SM66) – Status eines Programms ................................................................. 3.3.4 Debugger – Speicheranalyse ........................................ 3.3.5 Memory Inspector (S_MEMORY_INSPECTOR) ............ 3.3.6 ST10 – Table Call Statistics .......................................... 3.3.7 Performance-Trace – Allgemeines (ST05) ..................... 3.3.8 Performance-Trace – SQL-Trace (ST05) ....................... 3.3.9 Performance-Trace – RFC-Trace (ST05) ........................ 3.3.10 Performance-Trace – Enqueue-Trace (ST05) ................ 3.3.11 Performance-Trace – Tabellenpuffer-Trace (ST05) ........ 3.3.12 ABAP-Trace (SE30) ...................................................... 3.3.13 Single Transaction Analysis (ST12) ...............................
30 32 34 35 41 45 48 50 52 55 58 72 74 76 79 93
7
Inhalt
3.4
3.5
4
Paketierung ............................................................................. Parallelisierung ........................................................................ 4.2.1 Motivation .................................................................. 4.2.2 Herausforderungen und Lösungsansätze für parallelisierte Programme ............................................ 4.2.3 Techniken zur Parallelisierung ..................................... 4.2.4 Zusammenfassung .......................................................
133 135 136 137 147 152
Datenverarbeitung per SQL ................................................. 155 5.1 5.2
5.3 5.4
5.5
8
105 114 125 129 129 129 129 130 130 130
Parallelisierung ..................................................................... 133 4.1 4.2
5
3.3.14 E2E-Trace ................................................................... 3.3.15 Einzelsatzstatistik (STAD) ............................................ 3.3.16 Dump-Analyse (ST22) ................................................. Tipps zur Performanceanalyse .................................................. 3.4.1 Konsistenzchecks ........................................................ 3.4.2 Zeitbasierte Analyse .................................................... 3.4.3 Vermeidung ................................................................ 3.4.4 Optimierung ............................................................... 3.4.5 Laufzeitverhalten bei Massendaten ............................. Zusammenfassung ...................................................................
Die Architektur einer Datenbank ............................................. Ausführung von SQL ................................................................ 5.2.1 Ausführung im SAP NetWeaver AS ABAP .................... 5.2.2 Ausführung in der Datenbank ..................................... Effizientes SQL: Grundsätzliches .............................................. Zugriffsstrategien ..................................................................... 5.4.1 Logische Strukturen .................................................... 5.4.2 Indizes als Suchhilfe .................................................... 5.4.3 Operatoren ................................................................. 5.4.4 Entscheidung für einen Zugriffspfad ............................ 5.4.5 Analyse und Optimierung in ABAP .............................. 5.4.6 Zusammenfassung ....................................................... Ergebnismenge ........................................................................ 5.5.1 Reduktion der Spalten ................................................. 5.5.2 Reduktion der Zeilen ................................................... 5.5.3 Eine bestimmte Anzahl von Zeilen lesen ...................... 5.5.4 Aggregate bilden ......................................................... 5.5.5 Existenzchecks ............................................................
155 160 160 162 164 164 165 167 177 179 181 196 197 200 203 205 207 209
Inhalt
5.6
5.7
5.8
5.9
5.10
6
5.5.6 Updates ...................................................................... 5.5.7 Zusammenfassung ....................................................... Indexdesign ............................................................................. 5.6.1 Lesende oder schreibende Verarbeitung? .................... 5.6.2 Wie wird auf die Daten zugegriffen? ........................... 5.6.3 Zusammenfassung ....................................................... Ausführungshäufigkeit ............................................................. 5.7.1 Array Interfaces ........................................................... 5.7.2 SELECTS in Schleifen und geschachtelte SELECTS ........ 5.7.3 View ........................................................................... 5.7.4 Join ............................................................................. 5.7.5 FOR ALL ENTRIES ....................................................... 5.7.6 Änderungen in Schleifen und COMMIT ....................... Verwendetes API ..................................................................... 5.8.1 Open SQL statisch ...................................................... 5.8.2 Open SQL dynamisch .................................................. 5.8.3 Native SQL statisch ..................................................... 5.8.4 Native SQL dynamisch ................................................ 5.8.5 Zusammenfassung ....................................................... Spezialfälle und Ausnahmen .................................................... 5.9.1 Sortieren ..................................................................... 5.9.2 Pool- und Cluster-Tabellen .......................................... 5.9.3 Hints und Anpassung von Statistiken ........................... Zusammenfassung ...................................................................
210 211 211 214 217 219 219 220 222 224 226 227 230 232 232 233 233 233 233 234 234 235 237 240
Pufferung von Daten ............................................................ 241 6.1
6.2
6.3
6.4
SAP-Speicherarchitektur aus Sicht des Entwicklers ................... 6.1.1 Benutzerbezogener Speicher ....................................... 6.1.2 Benutzerübergreifender Speicher ................................ Benutzerbezogene Pufferungsarten .......................................... 6.2.1 Pufferung im internen Modus ..................................... 6.2.2 Pufferung über interne Modi hinweg .......................... 6.2.3 Pufferung über externe Modi hinweg .......................... 6.2.4 Zusammenfassung ....................................................... Benutzerübergreifende Pufferungsarten ................................... 6.3.1 Pufferung im Shared Buffer ......................................... 6.3.2 Pufferung im Shared Memory ...................................... 6.3.3 Pufferung über Shared Objects .................................... 6.3.4 Zusammenfassung ....................................................... SAP-Tabellenpufferung ............................................................ 6.4.1 Architektur und Übersicht ...........................................
241 243 244 245 245 249 250 250 251 251 252 253 255 256 257
9
Inhalt
6.5
7
8.2 8.3
276 277 281 287 287 291 296 297 298 299 300 302 303 305 308
RFC-Kommunikation zwischen ABAP-Systemen ....................... 8.1.1 Synchroner RFC ........................................................... 8.1.2 Asynchroner RFC ......................................................... Performanceaspekte bei der RFC-Kommunikation ................... Zusammenfassung ...................................................................
310 310 311 312 316
Spezielle Themen .................................................................. 317 9.1
9.2 9.3 9.4 9.5 9.6
10
Überblick über interne Tabellen ............................................... Organisation im Hauptspeicher ................................................ Die Tabellentypen ................................................................... Performanceaspekte ................................................................ 7.4.1 Füllen ......................................................................... 7.4.2 Lesen .......................................................................... 7.4.3 Ändern ....................................................................... 7.4.4 Löschen ...................................................................... 7.4.5 Verdichten .................................................................. 7.4.6 Sortieren ..................................................................... 7.4.7 Kopierkostenreduzierter bzw. -freier Zugriff ................ 7.4.8 Sekundärindizes .......................................................... 7.4.9 Kopieren ..................................................................... 7.4.10 Geschachtelte Schleifen und nicht-lineares Laufzeitverhalten ......................................................... 7.4.11 Zusammenfassung .......................................................
Kommunikation mit anderen Systemen .............................. 309 8.1
9
263 264 272 273
Verarbeitung interner Tabellen ............................................ 275 7.1 7.2 7.3 7.4
8
6.4.2 Welche Tabellen können gepuffert werden? ................ 6.4.3 Performanceaspekte der Tabellenpufferung ................. 6.4.4 Analysemöglichkeiten ................................................. Zusammenfassung ...................................................................
Lokale Verbuchung .................................................................. 9.1.1 Asynchrone Verbuchung ............................................. 9.1.2 Lokale Verbuchung ..................................................... Parameterübergaben ............................................................... Typkonvertierungen ................................................................. Indextabellen ........................................................................... Frontendressourcen schonen ................................................... Enqueue- und Message-Service schonen ..................................
317 317 318 320 321 321 322 323
Inhalt
10 Ausblick ................................................................................ 325 10.1
10.2
Wichtige Änderungen an den Werkzeugen zur Performanceanalyse ................................................................. 10.1.1 Performance-Trace (ST05) ........................................... 10.1.2 ABAP-Trace (SAT) ....................................................... Wichtige Änderungen bei internen Tabellen (Sekundärschlüssel) .................................................................. 10.2.1 Definition ................................................................... 10.2.2 Verwaltungskosten und Lazy Index Update ................. 10.2.3 Lesezugriffe ................................................................. 10.2.4 Active Key Protection ................................................. 10.2.5 Delayed Index Update bei inkrementellen Schlüsseländerungen ................................................... 10.2.6 Zusammenfassung .......................................................
325 325 330 336 337 338 338 339 340 341
Anhang ....................................................................................... 343 A B
Ausführungspläne der verschiedenen Datenbanken ............................ 343 Der Autor .......................................................................................... 363
Index ......................................................................................................... 365
11
Eine häufige Ursache lang laufender ABAP-Programme sind ineffiziente Zugriffe auf interne Tabellen. Dies trifft besonders bei der Verarbeitung großer Datenmengen zu. Dieses Kapitel beschreibt die für ABAP-Entwickler wichtigsten Aspekte bei der Verarbeitung interner Tabellen.
7
Verarbeitung interner Tabellen
Interne Tabellen gehören zu den komplexesten Datenobjekten, die es im ABAP-Umfeld gibt. Mit internen Tabellen ist es möglich, dynamische Datenmengen im Hauptspeicher abzulegen. Interne Tabellen sind vergleichbar mit Arrays und entlasten aufgrund ihrer Dynamik den Programmierer vom Aufwand der programmgesteuerten Speicherverwaltung. Die Daten in internen Tabellen werden zeilenweise verwaltet, wobei jede Zeile die gleiche Struktur hat. Meistens werden interne Tabellen zur Pufferung oder Aufbereitung von Inhalten aus Datenbanktabellen verwendet. Die Art des Zugriffs auf interne Tabellen spielt, wie auch bei den Datenbanktabellen, eine große Rolle für die Performance. Die Praxis zeigt, dass über das Tuning der internen Tabellen ähnlich große Effekte wie beim Tuning der Datenbankzugriffe möglich sind. Die negativen Effekte ineffizienter Zugriffe auf interne Tabellen für das Gesamtsystem lassen sich durch das Hinzufügen weiterer CPUs oder Application Server aber leichter ausgleichen als ineffiziente Datenbankzugriffe. Ineffiziente Datenbankzugriffe belasten die Datenbank als zentrale Ressource, während ineffiziente Zugriffe auf interne Tabellen die besser skalierbare Applikationsschicht (siehe Kapitel 2) belasten. Die folgenden Abschnitte geben zunächst einen Überblick über interne Tabellen im Allgemeinen. Danach sehen wir uns an, wie interne Tabellen im Hauptspeicher organisiert werden. Anschließend betrachten wir die verschiedenen Arten interner Tabellen. Es folgt dann der wesentliche Teil des Kapitels, die Performanceaspekte bei der Verarbeitung interner Tabellen. Hier werden typische problematische Beispiele und Lösungsmöglichkeiten vorgestellt.
275
7
Verarbeitung interner Tabellen
7.1
Überblick über interne Tabellen
Interne Tabellen werden durch vier Eigenschaften vollständig spezifiziert: 1. Tabellentyp Die Zugriffsart auf den Tabellentyp bestimmt, wie ABAP auf einzelne Tabellenzeilen zugreift. Dieses Thema wird ausführlich in Abschnitt 7.3 besprochen. 2. Zeilentyp Der Zeilentyp einer internen Tabelle kann ein beliebiger ABAP-Datentyp sein. 3. Eindeutigkeit des Schlüssels Der Schlüssel kann als eindeutig (unique) oder nicht eindeutig (non-unique) festgelegt werden. Bei eindeutigen Schlüsseln gibt es keine mehrfachen Einträge (bezüglich des Schlüssels) in internen Tabellen. Die Eindeutigkeit richtet sich nach dem Tabellentyp. Standardtabellen erlauben nur Non-uniqueSchlüssel und Hash-Tabellen nur Unique-Schlüssel. 4. Schlüsselkomponenten (unter Berücksichtigung der Reihenfolge) Die Schlüsselkomponenten und ihre Reihenfolge legen die Kriterien fest, anhand derer die Identifikation von Tabellenzeilen erfolgt. In Abbildung 7.1 wird dies nochmals syntaktisch dargestellt. Feld1
Feld2
Feld3
A
1
10
A
2
5
B
1
7
B
2
25
TYPES: TYPE of [WITH [UNIQUE | NON-UNIQUE] ] [INITIAL SIZE ]. DATA: TYPE of WITH [UNIQUE | NON-UNIQUE] [INITIAL SIZE ].
: [STANDARD] TABLE | SORTED TABLE | HASHED TABLE for types also: INDEX TABLE | ANY TABLE
Abbildung 7.1 Interne Tabellen – Deklaration
276
KEY f1 ... fn | KEY TABLE LINE | DEFAULT KEY
Organisation im Hauptspeicher
Für die Performance ist hauptsächlich die Kombination aus Zugriffsart und Tabellentyp relevant. Die verschiedenen Zugriffsarten und Tabellentypen werden in Abschnitt 7.3 behandelt. Bevor wir uns die Tabellentypen im Detail ansehen, betrachten wir zunächst, wie die internen Tabellen im Hauptspeicher organisiert sind.
7.2
Organisation im Hauptspeicher
Im Hauptspeicher werden die internen Tabellen, wie auch Datenbanktabellen, in Blöcken bzw. Seiten organisiert. Im Zusammenhang mit den internen Tabellen sprechen wir im Folgenden von Seiten. Wenn eine interne Tabelle in einem ABAP-Programm deklariert wird, wird im Hauptspeicher zunächst nur eine Referenz (Table Reference) angelegt. Erst wenn Einträge in die Tabelle geschrieben werden, werden ein Tabellenkopf (Table Header) und ein Tabellenkörper (Table Body) angelegt. Abbildung 7.2 zeigt eine schematische Darstellung der Organisation im Hauptspeicher. DATA: itab TYPE TABLE OF struc. APPEND wa TO itab. APPEND wa TO itab. …
Tabellenreferenz Tabellenkopf Seitenverwaltung
1. Seite (nr. ... ENDLOOP. ENDLOOP.
Nehmen wir an, die interne Tabelle it_customers hat 1.000 Einträge. Für jeden Kunden existieren im Mittel zwei Aufträge, die interne Tabelle it_orders hat also 2.000 Einträge. Wenn es sich jeweils um Standardtabellen handelt, müssen beide internen Tabellen vollständig abgearbeitet werden: Die äußere Tabelle it_customers, weil keine Einschränkung vorhanden ist und semantisch alle Datensätze verarbeitet werden sollen; die innere Tabelle it_orders wird zwar eingeschränkt, die zugehörigen Einträge für jeden Kunden können aber nicht effizient gesucht werden, es muss also auch für die innere Tabelle die ganze Tabelle it_orders durchsucht werden. Dies geschieht für jeden Eintrag der äußeren Tabelle in unserem Beispiel also 1.000 Mal. Nehmen wir an, der äußere Loop benötigt ungefähr 200 μs und der innere insgesamt 140.000 μs. Wenn die Datenmengen nun verdoppelt werden, verdoppeln sich auch die Laufzeiten für jeden Loop, da die beiden Loops linear mit der Anzahl der Einträge skalieren. Es ergäben sich also bei 2.000 Einträgen in der äußeren Tabelle (it_customers) ~400 μs und bei der inneren Tabelle (it_ orders) für 4.000 Einträge ~560.000 μs für alle 2.000 Durchläufe. Zwar muss die innere Tabelle für jeden Eintrag der äußeren durchlaufen werden, dabei müssen aber nicht für jeden äußeren Eintrag alle inneren, sondern nur die zwei Einträge, die zu einem Kunden gehören, verarbeitet werden. Die Laufzeit ist bei doppelter Datenmenge also viermal so lang. Das Laufzeitverhalten ist nicht linear, sondern quadratisch. (Der innere Loop dauert doppelt so lange wie zuvor – skaliert mit n – und wird zweimal so häufig wie zuvor ausgeführt.) In diesem Fall ist der Grund also ein ineffizienter Zugriff auf die innere Tabelle. Um dies zu vermeiden, muss der Zugriff auf die innere Tabelle optimiert werden. Für ein lineares Laufzeitverhalten müsste der Zugriff auf die innere Tabelle konstant sein, damit sich bei einer Verdoppelung der Zugriffshäufigkeit die Laufzeit verdoppelt. Da im vorherigen Beispiel kein eindeutiger Schlüssel möglich ist, kann über eine Sorted-Tabelle ein logarithmisches Laufzeitverhalten für den inneren Zugriff erreicht werden. Die Sorted-Tabelle erlaubt eine Binärsuche auf der inneren Tabelle und sorgt so für ein effizientes Auffinden der beiden passenden Einträge in der inneren Tabelle für jeden Eintrag der äußeren Tabelle. Für das gesamte Codefragment ergibt sich dann O(n x log n).
306
Performanceaspekte
An dieser Stelle ein kurzer Vergleich zum Nested Loop Join bei Datenbanken (siehe Abschnitt 5.4.5): Wie auch bei den Nested Loop Joins auf Datenbanken sind für die Optimierung geschachtelter Schleifen die Anzahl und die Effizienz des Zugriffs auf die innere Tabelle von Bedeutung. Nicht-lineares Laufzeitverhalten liegt nicht immer an ineffizienten Zugriffen auf interne Tabellen, sondern kann z. B. auch durch einen quadratischen Anstieg der Aufrufhäufigkeit eines effizienten Zugriffs auf eine interne Tabelle hervorgerufen werden. Die Auswirkungen nicht-linearer Programmierung können generell mit kleineren Datenpaketen reduziert werden. Allerdings sollten die Pakete dabei nicht zu klein gewählt werden, um nicht zu großen Overhead an anderen Stellen zu erzeugen (siehe auch Abschnitt 4.1.3). Da bei der Entwicklung von Programmen auf dem Entwicklungssystem meistens nur ein kleiner Testdatenbestand zur Verfügung steht, kommt es vor, dass nicht-lineares Laufzeitverhalten nur schwer zu entdecken ist, da geschachtelte Schleifen mit kleinen Datenmengen oft nur einen kleineren Teil der gesamten Programmlaufzeit ausmachen. Bei kleinen Testdatenbeständen sieht es dann oft so aus, als würde sich das Programm linear zur Anzahl der verarbeiteten Mengen verhalten. Um bereits während der Entwicklung mit kleinen Datenmengen nicht-lineares Laufzeitverhalten zu entdecken, muss das Laufzeitverhalten auf ABAP-Statement-Ebene verglichen werden. Dabei werden die Zeiten für die Zugriffe auf interne Tabellen mit zwei Varianten – z. B. einmal mit zehn und einmal mit 100 zu verarbeitenden Datensätzen – mit den Transaktionen SE30 oder ST12 vermessen und miteinander verglichen. So kann schon mit kleinen Datenmengen nicht-lineares Laufzeitverhalten entdeckt werden. Im Release 7.0 EhP1 gibt es kein Werkzeug, mit dem Sie diesen Vergleich automatisiert durchführen können. Sie finden jedoch im SDN unter folgenden Links ein Werkzeug und eine Beschreibung, wie sich so ein Vergleich automatisieren lässt: 왘
Nonlinearity: The problem and background https://www.sdn.sap.com/irj/sdn/weblogs?blog=/pub/wlg/5804
왘
A Tool to Compare Runtime Measurements: Z_SE30_COMPARE: https://www.sdn.sap.com/irj/sdn/weblogs?blog=/pub/wlg/8277
왘
Report Z_SE30_COMPARE: https://www.sdn.sap.com/irj/sdn/wiki?path=/display/Snippets/Report%2bZ_ SE30_COMPARE
307
7.4
7
Verarbeitung interner Tabellen
왘
Nonlinearity Check Using the Z_SE30_COMPARE: https://www.sdn.sap.com/irj/sdn/weblogs?blog=/pub/wlg/8367
Im Release 7.00 EhP2 kann der Vergleich von Trace-Dateien mit SAP-Standardmitteln durchgeführt werden (siehe Kapitel 10).
7.4.11
Zusammenfassung
Bei der Arbeit mit internen Tabellen ist die Wahl des richtigen Tabellentyps und der Zugriffsart entscheidend. Standardtabellen sollten nur für kleine Tabellen oder Tabellen, die mit Indexzugriffen verarbeitet werden können, verwendet werden. Bei größeren Standardtabellen sollten Sie auf jeden Fall auf eine effiziente Verarbeitung mit der Binärsuche achten, wenn nur Teile der Tabelle verarbeitet werden sollen. Diese kann sowohl für Einzelsatz- als auch für Massenzugriffe verwendet werden. Standardtabellen sollten dafür nach Möglichkeit gleich sortiert aufgebaut werden oder aber nur so häufig sortiert werden, wie dies unbedingt erforderlich ist. Bei Zugriffen auf verschiedene Schlüsselfelder mit der Binärsuche, die ein Umsortieren notwendig machen würden, muss in jedem Fall geklärt werden, ob der Aufwand für das Sortieren gerechtfertigt ist (von den verbesserten Lesezugriffen amortisiert wird). Sorted-Tabellen können eindeutig oder nicht-eindeutig für die meisten Anwendungsfälle benutzt werden. Sie bieten sich besonders für die teilsequenzielle Verarbeitung an, bei der z. B. ein Anfangsstück des Tabellenschlüssels benutzt wird. Hash-Tabellen sollten nur da verwendet werden, wo der eindeutige Schlüsselzugriff die einzige Art des Zugriffs ist, insbesondere dann, wenn sehr große Tabellen verarbeitet werden müssen. Generell sollten interne Tabellen, wenn es möglich ist, mit Block-Operationen gefüllt werden, um den Overhead von Einzelsatzzugriffen zu vermeiden. Wo es sinnvoll ist, sollten Kopierkosten für die Bereitstellung der Ergebnisse mit TRANSPORTING fieldlist/NO FIELDS reduziert oder mit ASSIGNING bzw. REFERENCE INTO ganz vermieden werden. Dies ist besonders für geschachtelte Tabellen wichtig. Interne Tabellen sollten nach Möglichkeit generell nicht zu groß werden, um den Speicherplatz des SAP-Systems zu schonen.
308
Index /SDF/E2E_TRACE 105, 108
A ABAP Array Interface 220 ABAP Central Services (ASCS) 24 ABAP Database Connectivity (ADBC) 161, 233 ABAP Dump 126 ABAP Load 23 ABAP Memory 243, 249 ABAP Paging Area 249 ABAP Virtual Machine 79 ABAP Workbench 254 ABAP-Debugger 31 ABAP-Stack 23, 24 ABAP-Trace 30, 79, 330 ABAP-Tuning 17 abgebrochene Pakete 145 Active Key Protection 339 Advanced List Viewer (ALV) 322, 326 Aggregat 207 Aggregated Table Summary 70 Aggregatfunktion 270 Allokation 278 Antwortzeit 17 Anwendungsstatistik 125 Anwendungs-Tuning 18 APPEND SORTED BY 279 Applikationsschicht 21, 23, 26 Architektur, Performanceaspekte 25 Array Interface 133, 221, 323 asynchrone Verbuchung 317 asynchroner RFC 148, 311 Aufrufhierarchie 90 Aufrufstelle des SQL-Statements 222 ausführliche Trace-Liste 61 Ausführungshäufigkeit 219 Ausführungsplan 68, 162, 343
B Background RFC (bgRFC) 312 Batchjob 147 Batchjob-API 148
Batchservergruppe 148 baumartiger Index 283 benutzerbezogener Speicher 243 Benutzersitzung 244 benutzerübergreifender Speicher 244 Binary Search 294 Blatt 283 Blockgröße 158 Bottom-up-Analyse 100 Buffer Pool 157 BYPASSING BUFFER 270
C Calendar-Puffer 251 CALL FUNCTION ... DESTINATION... 244 Call Stack 222, 327 Call Tree 102 CLIENT SPECIFIED 183, 219, 271 Client-Server-Architektur 21 Clustered Index Scan 182 Clustered Index Seek 181, 182 Code Inspector 32 Performanceprüfungen 36 COLLECT 298 COMMIT WORK 61, 70, 104, 140, 163, 231, 317 Copy on Write 304 Cost-based Optimizer 179 COUNT 270 Covering Index 172, 200, 219 CUA-Puffer 251 Cursor-Cache 156
D Data Manipulation Language (DML) 140, 214 Data Sharing 243 Datenbank 27 Aggregate 207 API für Datenbankabfragen 232 Ausführungspläne 181 Blöcke 157
365
Index
Datenbank (Forts.) Datenbank Hints 238 Datenbank-Interface 160 Datenbankprozess 156 Datenbank-Thread 156 Daten-Cache 157 DBI-Hints 237 Ergebnismenge 197 Existenzchecks 209 Explain Plan 181, 343 FOR ALL ENTRIES 227 Full Table Scan 174 geschachtelte SELECTs 223 Hash Join 194 Hauptspeicher 156 Heap-Tabellen 165 Identical SELECTs 223 Index Fast Full Scan 174 Index Full Scan 173 Index Range Scan 170 Index Unique Scan 169 Indexdesign 211 indexorganisierte Tabelle 165 Indizes als Suchhilfe 167 Join 191, 226 Join-Methoden 191 Kompilieren 162 logische Strukturen 165 NATIVE SQL 233 Nested Loop Join 192 OPEN SQL 232 Operatoren 177 Optimizer 179 Paketgrößen 199 Parsen 162 passender Zugriffspfad 211 physikalischer I/O 158 Pool- und Cluster-Tabellen 235 Selektivität und Verteilung 185 Softwarearchitektur 155 Sort Merge Join 193 Sortieren 234 SQL-Cache 157 Statistiken 180 Systemstatistiken 180 unpassender Zugriffspfad 196 Views 224 zentrale Ressource 155 Zugriffsstrategien 164
366
Datenbank-Interface 160 Datenbankprozess 156 Datenbankschicht 21, 23 Datenbanksperre 140 Datenblock 157 Daten-Cache 157 DB File Scattered Read 176 DB File Sequential Read 176 DB02 195, 196 DB05 31, 32, 33, 34, 41, 190, 272 Ergebnisbildschirm 42 DB2 for iSeries 156 DBI Array Interface 220 DBI-Hint 237 Deadlock 141 Deallokation 279 Debugger 48 Speicherabzug 50 Speicheranalyse-Werkzeug 49 Default Key 281 Delayed Index Update 340 DELETE 297 DELETE FROM SHARED BUFFER 251 DELETE FROM SHARED MEMORY 252 Dequeue-Baustein 139 DISTINCT 270 Double Stack 23, 24 Dreischichtenarchitektur 21, 22 Durchsatz 17, 136 dynamische Verteilung 145
E E2E-Trace 105 Analyse 109 Durchführung eines Traces 107 Voraussetzungen 105 Einzelsatzoperation 289 Einzelsatzpufferung 259 Einzelsatzstatistik 30 Einzelsatzzugriff 134 End-to-End-Trace 29, 31, 105 Enqueue-Service 26, 323 Enqueue-Trace 74 Ergebnismenge 197 erweiterte Schreibsperre 323 Event 79 Existenzcheck 209 Explain Plan 181, 190
Index
EXPORT TO MEMORY 249 EXPORT TO SHARED BUFFER 251 EXPORT TO SHARED MEMORY 252 Extended Memory 242 Extended Trace List 61 externer Modus 245
F Fehlerbehandlung, Paketverarbeitung 134 Filesystem-Cache 158 Filterwerkzeug 334 FLUSH_ENQUEUE 323 FOR ALL ENTRIES 191, 227, 228, 238, 271 FOR UPDATE 270 Fragmentierung 262 Frontend 26 Frontendressource 322 Full Table Scan 174, 177, 182, 344, 348, 351, 354, 356, 359
G Gebiet 254 gebündelter Zugriff 134 generische Pufferung 259 geschachtelte Schleifen 36, 305 geschachtelte SELECT-Anweisung 191, 223 geschachtelte Tabellen 37 GET PARAMETER ID 250 GROUP BY 270
H Hash Join 191, 194 Hash-Tabelle 194, 282, 285, 286 Hash-Verwaltung 285 Hauptmodus 245 Heap-Speicher 243 Heap-Tabelle 165 Hints 237 horizontale Verteilung 25 HTTP 309 HTTP-Plug-in 107 HTTP-Trace 330
I IBM DB2 iSeries 347 IBM DB2 UDB 350 IBM DB2 zSeries 344 Identical Selects 68 IMPORT FROM SHARED BUFFER 251 IMPORT FROM SHARED MEMORY 252 Index Fast Full Scan 174 Index Full Scan 173, 346, 349, 352, 355, 358, 361 Index Only 169 Index Range Scan 170, 177, 182, 345, 348, 351, 354, 357, 360 Index Skip Scan 177 Index Unique Scan 169, 177, 181, 346, 349, 352, 355, 357, 360 Indexdesign 211 indexorganisierte Tabellen 165 Indexstatistik 180 Indexstruktur 167 Indextabelle 282, 321 Indizes als Suchhilfe 167 INITIAL SIZE 278 Inner Join 226 Inspektion 35 Inter Process Communication (IPC) 156 interne Tabellen 275, 276 APPEND 288 baumartiger Index 283 Beschränkungen 286 Binary Search 294 COLLECT 298 DELETE 297 füllen 287 geschachtelte Schleifen 305 gleichartige 303 Hash-Tabellen 282 Hash-Verwaltung 285 Index 282 Indextabellen 282 INITIAL SIZE 278 INSERT 288 kopieren 303 Kopierkosten 300 Lesen 291 linearer Index 283 LOOP 291 MODIFY 296
367
Index
interne Tabellen (Forts.) Organisation im Hauptspeicher 277 Performanceaspekte 287 READ TABLE 293 Sekundärindizes 302 Sekundärschlüssel 336 SORT 299 Sorted-Tabellen 281 Standardtabellen 281 Tabellen-Sharing 303 Tabellentypen 281 interner Modus 245 IS NULL 271
J Java-Stack 23, 24 Jobzustandsabfrage 148 Join 191, 226, 347, 350, 353, 355, 358, 361 Join-Methode 191, 194 Journal 163
K Kiwi Approach 18 Kommunikation direkte Kommunikation 309 indirekte Kommunikation 309 Protokolle 309 kompilieren 157, 162 Konsistenzcheck 129 Kopierkosten 264
L Lastverteilung 146 Latenzzeit 322 Laufzeitverhalten 130 Lazy Copy 304 Lazy Index Update 338 Least Frequently Used 163, 261 Least Recently Used 162, 252, 261 Left Outer Join 226 lesende Verarbeitung 214 lesende Zugriffe 162 linearer Index 283 Lock-Eskalation 141 Logical Row ID 168
368
logische Strukturen 165 lokale Verbuchung 317, 318 LOOP 291
M Mapping Area 242 Massendaten 130 Memory Inspector 32, 49, 50, 305 Speicherabzüge erstellen 50 Memory Snapshot 49 Mengenoperation 287 Merge Scan Join 191 Message-Service 26, 323 Messdatenübersicht 335 Microsoft SQL Server 359 MODIFY 296 Modularisierungseinheit 99 Multiblock I/O 175
N Nametab-Puffer 243, 251 Native SQL 233 dynamisch 233 Nested Loop Join 191, 192 Netzwerkpaketgröße 199
O Objektmenge 35 Open SQL 232 dynamisch 233 Operator 177 Optimierung 130 Optimizer 179 Oracle 356 ORDER BY 234, 270 OTR-Puffer 251
P Package Size 220 Paketgröße 133, 142, 199 Paketierung 133 Paketverarbeitung 133 Array Interface 133 Fehlerbehandlung 134 Paketgröße 133
Index
parallele Verarbeitung 136 Parallelisierung 133, 135 abgebrochene Pakete 145 asynchroner RFC 148 Batchjob 147 Batchservergruppe 148 Deadlock 141 Dynamische Verteilung 145 gleichmäßige Ausnutzung der Hardware 146 Herausforderungen 137 Kapazitätsgrenzen der Hardware 147 Lastverteilung 146 Paketgröße 142 Parallelisierungskriterium 136 Sperre 138 statische Verteilung 144 Status der Verarbeitung 145 Synchronisationszeitpunkt 137 Techniken zur Parallelisierung 147 Verteilung der Pakete 144 Wiederaufsetzbarkeit 145 Parameter Memory 250 Parameterübergaben 320 parsen 157, 162 passender Zugriffspfad 211 Passport 105 Performance 17 ABAP-Tuning 17 Antwortzeit 17 Anwendungs-Tuning 18 Durchsatz 17 Hardware 18 Skalierbarkeit 17 System-Tuning 18 Performanceanalyse 29, 325 Performancemanagement 18 Performance-Trace 30, 55, 72, 325 aktivieren 55 anzeigen 56 deaktivieren 56 sichern 57 PERFORMING … ON END OF TASK 149 physikalischer I/O 158 Pool- und Cluster-Tabellen 235 Post-Runtime-Analyse 114 Präsentationsschicht 21, 22 PRIV-Mode 243 Profilwerkzeug 334
Programmpuffer 243, 251 Prozessanalyse 45 globale Prozessübersicht 47 lokale Prozessübersicht 47 Prozessdetails 47 Status 45 Prozesskette 143 Prozessmonitor 115 Prüfvariante 35, 39 Puffer 243 Pufferschlüssel 269 Puffer-Trace 272 Pufferung 241 im ABAP Memory 249 im internen Modus 245 im SAP Memory/Parameter Memory 250 im Shared Buffer 251 im Shared Memory 252 im Tabellenpuffer 256 in internen Tabellen 247 in Shared Objects 253 in Variablen 246 Wiederverwendbarkeit 248 Pufferungsstatus 55
Q queued RFC (qRFC) 152, 311 Quota 242
R Random I/O 175 Raw Device 158 Read Ahead 174 READ TABLE 293 Request Tree 112 RETURNING-Parameter 320 RFC 309, 310 Datentransfer 314 Roundtrips 314 RFC-Kommunikation 310 RFC-Overhead 313 RFC-Servergruppe 149 Konfiguration 152 Ressourcenparameter 152 RFC-Trace 72 Roundtrip 322
369
Index
RSPRFC02 149 Rule-based Optimizer 179 Run Time Type Identification 282 RZ12 149
S S_MEMORY_INSPECTOR 31, 50 SAP Business Explorer 22 SAP Code Inspector 33, 34, 35, 270 Ad-hoc-Inspektion 37 Ergebnisbildschirm 39 Grenzen 37 SQL-Trace 329 Tests 35 SAP EarlyWatch Check 195 SAP GoingLive Check 195 SAP GUI 22 SAP MaxDB 353 SAP Memory 243, 250 SAP NetWeaver Application Server 23 SAP NetWeaver Business Client 22 SAP NetWeaver Portal 23 SAP-Enqueue 139 SAPHTTPPlugIn.exe 107 SAP-Systemarchitektur 21 SAP-Tabellenpuffer 245 SAT 330 Filterwerkzeug 334 Messdatenübersicht 335 Profilwerkzeug 334 Zeitwerkzeug 334 schreibende Verarbeitung 214 schreibende Zugriffe 163 SCI 31, 32, 33, 34, 35 SCII 36, 37 Screen-Puffer 251 SE11 224, 237 SE12 237 SE16 190, 195, 272 SE17 272 SE24 36 SE30 30, 47, 79, 185, 201, 204, 209, 210, 223, 226, 230, 288, 294, 299, 302, 307, 321, 328 Aggregation, ohne 84 Aggregation, pro Aufrufstelle 84 Aggregation, vollständig 84 Anweisungen 83
370
SE30 (Forts.) Aufrufhierarchie 90 Brutto- und Nettozeit 88 Dauer und Art 84 im aktuellen Modus 85 im parallelen Modus 85 Messvariante definieren 82 Programmteile 83 Trace auswerten 86 Trace erstellen 85 Trace-Dateien verwalten 92 SE37 36 SE38 36 SE80 254 Seite 277 Sekundärindex 168, 302 eindeutiger 168 Sekundärschlüssel 336 SELECT – Code-Inspector-Prüfungen 36 SELECT in Schleifen 222 Selektivität 185 Selektivitätsanalyse 33, 34, 41 Sequential I/O 175 sequenzielle Verarbeitung 136 SET PARAMETER ID 250 Shared Buffer 243, 251 Shared Memory 243, 252 Shared Objects 243, 244, 253 SHMA 254 SHMM 254 Single Block I/O 175 Single Statistical Record 111 Single Transaction Analysis 92 Skalierbarkeit 17 SM37 41 SM50 31, 45, 47, 115, 181, 182, 249 SM61 148 SM66 31, 45, 47 SMD 105 SMTP 310 Solution Manager Diagnostics 105 SORT 299 Sort Merge Join 191, 193 Sorted-Tabelle 281, 286 Sortieren 234 Spalten reduzieren 198, 200 Spaltenstatistik 180 Speicherabzug 50
Index
Speicherarchitektur 241 benutzerbezogener Speicher 243 benutzerübergreifender Speicher 244 Speicherbereiche 241 Speicherbereich 241 Sperre 138 SQL 155 Ausführung 160 effizientes 164 SQL Statement Summary 62 SQL-Cache 156, 157 SQL-Trace 30, 58, 72, 183, 185, 195, 201 Aggregated Table Summary 70 Aufrufstelle im ABAP-Programm 68 Datenbank-Interface 58 DDIC-Informationen 68 Details des ausgewählten Statements 66 EXPLAIN 68 Identical SELECTs 68 Statement Summary 62 Table Summary 70 Trace-Liste 60 SSR 111 ST02 243, 252, 253, 268 ST04 46, 176 ST05 30, 46, 55, 181, 183, 185, 195, 197, 201, 211, 223, 237, 267, 272, 325 Enqueue-Trace 74 HTTP-Trace 330 Performance-Trace 72 RFC-Trace 72 SQL-Trace 58 Stack-Trace 327 Tabelllenpuffer-Trace 76 ST10 31, 52, 263, 267, 272 Status der gepufferten Tabellen 53 ST12 30, 47, 92, 93, 223, 307, 328 Bottom-up-Analyse 100 gruppiert nach Modularisierungseinheiten 98 SQL-Trace 104 Top-down-Analyse 102 Trace auswerten 97 Trace erstellen 94 Traces einsammeln 96 Übersicht 93 ST22 31, 125 Stack-Trace 327
STAD 30, 31, 32, 34, 41, 114 Auswertung 117 Selektion 116 Standalone-Enqueue-Server 24 Standardtabelle 281, 286 statische Verteilung 144 Statistiksatz 114 Swap 268 synchrone Verbuchung 318 synchroner RFC 310 Synchronisationszeitpunkt 137 Systemstatistik 180 System-Tuning 18
T Tabellenpuffer 241, 243 Analysemöglichkeiten 272 Architektur 257 Einzelsatzpufferung 260 generische Pufferung 260 Größe der Tabellen 262 Kriterien zur Pufferung 263 lesender Zugriff 258 Performanceaspekte 264 schreibender Zugriff 258 SQL-Statements, die am Puffer vorbeigehen 269 Synchronisation 259 Typen 259 Verdrängung und Invalidierung 268 vollständige Pufferung 260 Zugriffe, die am Puffer vorbeigehen 267 Tabellenpuffer-Trace 76 Tabellenpufferung 256 Tabellen-Sharing 303 Tabellenstatistik 180 Tabellentyp 281 Tabellenübersicht 71 Tabellenzugriffsstatistik 54 Table Body 277 Table Header 277 Table Reference 277 Table Summary 70 TABLES-Parameter 320 Time Split Hierarchy 103 Top Down Time Split Hierarchy 102 Top-down-Analyse 102 Trace-Level 106, 107
371
Index
Trace-Liste 60 Traces 34 Transaction Log 163 transaktionaler RFC (tRFC) 311 Typkonvertierung 321
U Unicode 262 unpassender Zugriffspfad 196 Unterabfrage 270 UP TO n ROWS 206 Update 210 UPDATE dbtab FROM... 215 UPDATE SET... 215 User Session 244
V varchar 262 Verbuchung asynchrone 317 lokale 317, 318 synchrone 318 Verbuchungstabelle 317 Verdichten 298 verdichtete Tabellenübersicht 70 Vermeidung 129 Verteilung 185 vertikale Verteilung 25 View 224 vollständige Pufferung 259
372
W Web Dynpro Java 23 Werkzeuge 29 ABAP-Trace 79, 330 Debugger 48 Dump-Analyse 125 E2E-Trace 105 Einsatzzeitpunkte 32 Einzelsatzstatistik 114 Enqueue-Trace 74 Memory Inspector 50 Performance-Trace 55, 325 Prozessanalyse 45 RFC-Trace 72 SAP Code Inspector – SCI 35 Selektivitätsanalyse 41 Single Transaction Analysis 93 SQL-Trace 58 Tabellenpuffer-Trace 76 Table Call Statistics 52 Traces 34 Übersicht 30 WHERE 36 Wiederaufsetzbarkeit 145 Workprozess-Monitor 32
Z Zeilen reduzieren 198, 203 zeitbasierte Analyse 129 Zeitwerkzeug 334 zentrale Ressourcen 26 Zugriffspfad 179 Zugriffsstatistiken 52
