Optimizer-Optionen

#### Search Results

Search

# Optimizer-Optionen

Wenn der Natural Optimizer aktiviert wurde, können Sie Prüfungen angeben, indem Sie die in diesem Abschnitt erklärten Optionen einstellen.

Die Optionen können nicht benutzt werden, um Statements anzugeben, die optimiert werden sollen.

Dieser Abschnitt behandelt folgende Themen:

- Liste der Optionen

- ARCH-Option

- ARROPT-Option

- PGEN-Option

- UNICC-Option

- Voraussetzungen für die Code-Generierung mit Unicode-Operanden

- Einfluss anderer Natural-Parameter

## Liste der Optionen

Die folgende Tabelle enthält eine Liste mit den Beschreibungen der Natural Optimizer Compiler-Optionen. Unterstrichene Werte sind Standardwerte (Default Values), d.h. dieser Wert wird angenommen, wenn die Option nicht vorhanden ist.

Eine Natural Optimizer Compiler-Option besteht aus einer Zeichenkette, die von Klammern oder einzelnen Ausrufungszeichen umschlossen ist (Ausnahme: im Natural-Statement `OPTIONS`), wobei die Optionen durch Kommas voneinander abgetrennt sind. Einige Optionen haben Werte, während die bloße Existenz einiger Optionen in der Optionszeichenfolge ausreicht, um die Umgebung zu ändern.

Es gelten folgende Regeln:

- Optionale Klauseln sind von rechteckigen Klammern `[ ]` umgeben.

- Wahlmöglichkeiten sind von geschweiften Klammern `{ }` umgeben.

- Wahlmöglichkeiten sind voneinander durch senkrechte Linien `|`abgetrennt.

- Es kann nur eine dieser Wahlmöglichkeiten angegeben werden.

  `ON` ist gleichbedeutend mit `Y` (Yes),

  `OFF` ist gleichbedeutend mit `N` (No).

- Optionen, die ohne die optionale Klausel `ON` oder `OFF` (falls zutreffend) oder deren Äquivalenzwerte angegeben werden, werden so interpretiert, als ob sie auf `ON` gesetzt sind. Beispiel: `OVFLW` ist identisch zu `OVFLW=ON`.

- Mit Ausnahme der Option `OFF` gelten alle beim Optimieren angegebenen Optionsschalter (als ob `ON` angegeben wäre) und der Standardwert. Beispiel: `INDEX` ist identisch zu `ON,INDEX`.

Option | Erklärung
--- | ---
`ABEND` | Zwingt den Natural Optimizer Compiler, Code zu generieren, der bewirkt, dass Natural sofort abnormal beendet wird, wenn der Natural Optimizer Compiler während des Kompilierens die Option `ABEND` antrifft. Die Option muss selbständig erscheinen, sonst wird sie ignoriert. Andere Parameter werden durch diese Option nicht geändert oder zurückgesetzt. Diese Option kann für Debugging-Zwecke nützlich sein.
`ARCH` | Gibt an, welcher Architecture Level für die Codegenerierung benutzt werden soll, siehe ARCH-Option im folgenden Abschnitt.
`ARROPT` | Gibt an, welche Generierung für Array-Zuweisungen des Typs `A(*):=scalar` verwendet werden soll, siehe ARROPT-Option im folgenden Abschnitt.
`CACHE[={ON| OFF |Y|N}]` | Schaltet die Variablenzwischenspeicherung (Variable Caching) ein oder aus. Siehe auch Variablenzwischenspeicherung (Caching) im Abschnitt Performance-Überlegungen.
`CPU= /370` | Gibt die Ziel-Architektur an.
`DIGTCHCK[={ON| OFF |Y|N}]` | Gibt an, ob die Ziffern von gepackten oder ungepackten Feldern (Formate P und N) geprüft werden sollen, wenn sie in eine andere Variable gleichen Typs und gleicher Genauigkeit verschoben werden. Wenn beispielsweise `DIGTCHCK` auf `ON` gesetzt ist und eine ungepackte Variable (Format N) eine ungültige Ziffer enthält, z.B. `X'FA'`, dann generiert das Verschieben in eine andere ungepackte numerische Variable gleichen Typs den Fehler `S0C7` (oder `NAT0954`). Wenn `DIGTCHCK` auf `OFF` gesetzt ist, wird kein Fehler generiert, aber der generierte Code ist viel schneller.
`ERRDUMP[={ON| OFF |Y|N}]` | Gibt an, ob der Natural Optimizer Compiler abbrechen soll, wenn während der Kompilierungsphase ein Fehler festgestellt wird. Dies ist nützlich, um am Natural Optimizer Compiler selbst eine Fehlerbehebung (Debugging) durchzuführen.
`INDEX[={ON| OFF |Y|N}]` | Gibt an, ob Array-Indizes auf Out-of-Bound-Werte im optimierten Code überprüft werden. Siehe auch die folgende Anmerkung.
`INDX[={ON| OFF |Y|N}]` | Gibt an, ob Array-Indizes auf Out-of-Bound-Werte im optimierten Code überprüft werden. Zusätzlich wird `RANGE` auf `ON` gesetzt. Deshalb ist die Option gleichbedeutend mit `INDEX=ON,RANGE=ON`. Siehe auch die folgende Anmerkung.
`IO[={ON| OFF|Y|N}]` | Nur aus Kompatibilitätsgründen vorhanden. Keine Wirkung.
`LOOPS[={ON| OFF |Y|N}]` | Nur aus Kompatibilitätsgründen vorhanden. Keine Wirkung.
`MIX[={ON| OFF |Y|N}]` | Nur aus Kompatibilitätsgründen vorhanden. Keine Wirkung.
`NODBG``[={ON| OFF|Y|N}]` | Wenn `NODBG=OFF/N` (Standardeinstellung) gesetzt ist, kann der Natural Debugger benutzt werden, um Fehler im optimierten Code zu beheben (dann wird zusätzlicher Code generiert, um zu prüfen, ob der Test-Modus eingeschaltet worden ist (`TEST ON`). Bei `NODBG=ON/Y` wird weniger Code generiert, das Programm läuft schneller und verbraucht weniger CPU-Zeit. Anderseits wird die Funktionalität des Natural Debugger eingeschränkt, weil der Natural Debugger möglicherweise keine Steuerungsmöglichkeit bei optimierten Statements erhält. Siehe auch `NODBG` im Abschnitt Performance-Überlegungen.
`NOSGNTR[={ON| OFF |Y|N}]` | Gilt nur bei gepackten Zahlen. Bei `NOSGNTR=OFF` (Standardeinstellung) werden Vorzeichen von gepackten Zahlen, die das Ergebnis einer arithmetischen Operation oder das Ziel einer Zuweisung sind, gemäß dem Subparameter `PSIGNF` (Interne Darstellung des positiven Vorzeichens bei gepackten Zahlen) des Systemkommandos `COMPOPT` gesetzt. Bei `NOSGNTR=ON` werden die aus der Ausführung der generierten Maschineninstruktion resultierenden Vorzeichen unverändert gelassen. Siehe auch Einfluss anderer Natural-Parameter.
`ON` | Schaltet die Optimierung ein. Wenn keine zusätzliche Option angegeben wird, gilt der für jede Option definierte Standardwert. Wie in der folgenden Anmerkung mitgeteilt, kann dies unerwünschte Ergebnisse zur Folge haben. Dies gilt insbesondere für die Optionen `INDEX, INDX, OVFLW` und `RANGE`.
`OFF` | Schaltet die Optimierung aus.
`OPTLEV={ 2|3}` | Gibt die Optimierungsstufe an - entspricht in etwa der Anzahl der Durchläufe durch das Programm. `OPTLEV=3` ist nützlich, wenn `PGEN` angegeben ist, da einige Verzweigungsziele beim ersten Durchlauf nicht ermittelt werden können und die `PGEN`-Ausgabe während des letzten Durchgangs erfolgt. Daher können einige Werte möglicherweise nicht korrekt angezeigt werden.
`OVFLW[={ON| OFF |Y|N}]` | Gibt an, ob Überlaufprüfungen bei aritmetischen Operationen oder Zuweisungen in den optimierten Code aufgenommen werden. Siehe auch die folgende Anmerkung.
`PGEN[={ON| OFF |Y|N}]` | Gibt an, ob eine Disassemblierung des optimierten Code ausgegeben werden soll. Mit dieser Option werden auch alle anderen Nachverfolgungsoptionen aktiviert, siehe PGEN Option im folgenden Abschnitt.
`RANGE[={ON| OFF |Y|N}]` | Gibt an, ob bei Operationen mit Arrays Bereichsprüfungen durchgeführt werden. Dadurch wird sichergestellt, dass Array-Bereiche eine gleiche Anzahl an Elementen in allen entsprechenden Dimensionen aller Operanden haben. Siehe auch die folgende Anmerkung.
`SIGNCHCK[={ ON|OFF|Y|N}]` | Gibt an, ob das Ergebnis einer Multiplikation mit einem gepackten oder nicht gepackten Multiplikator auf eine negative Null geprüft werden soll. Wenn Null mit einer negativen Zahl multipliziert wird, generiert die Maschineninstruktion MP ein negatives Null-Ergebnis. Wenn `SIGNCHCK` auf `ON` gesetzt ist, wird diese negative Null in eine positive Null umgewandelt. Die Prüfung auf eine negative Null erfolgt bei jeder Multiplikation mit einem gepackten oder nicht gepackten Multiplikator.
`TRENTRY` | Nur für den internen Gebrauch bestimmt. Die Einstellung dieses Parameters nicht ändern.
`UNICC` | Gibt an, ob optimierter Code für `IF`- und `DECIDE`-Statements mit Unicode-Operanden generiert wird, siehe UNICC Option im folgenden Abschnitt.
`ZD``[={ ON|OFF|Y|N}]` | Gibt an, ob Divisoren auf Null geprüft werden sollen. Ist diese Option angegeben, dann wird Code eingefügt, damit sich das Programm gemäß dem Natural-Profilparameter `ZD` verhält, d.h., es wird der Natural-Fehler `NAT1302` ausgegeben oder das Ergebnis ist Null. Ist diese Option nicht angegeben, tritt der Natural-Fehler `NAT0954` auf, wenn der Divisor Null ist. Siehe auch ZD - Division durch Null in der Natural Parameter-Referenz-Dokumentation.

Anmerkung zu INDEX, INDX, OVFLW und RANGE

Wenn die Option `INDEX`, `INDX`, `OVFLW` oder `RANGE` gesetzt ist, werden zusätzliche Instruktionen zu dem generierten Code hinzugefügt, um Datenüberlauf- und Index-außerhalb-Bereich-Situationen zu entdecken, falls solche während der Programmausführung auftreten sollten. Zwar vergrößert die Benutzung dieser Optionen den generierten Code, sie wird aber empfohlen, um sicherzustellen, dass fehlerhafte Programme aufgespürt werden und nicht zu unvorhersehbaren Ergebnissen, Speicherbeschädigungen oder abnormalen Programmabbrüchen führen können.

Folgende Themen werden behandelt:

- Beispiel für INDEX und OVFLW

- Optimale Code-Generierung

### Beispiel für INDEX und OVFLW

    DEFINE DATA LOCAL
    ...
    1 P1 (P1/9)
    ...
    1 P3 (P3/9)
    ...
    1 I (I4)
    1 J (I4)
    1 K (I4)
    1 L (I4)
    END-DEFINE
    ...
    P1(I:J) := P3(K:L)
    ...
    END

#### Erklärung des Beispiels:

Bei `INDX=ON` oder `INDEX=ON` wird Code generiert, um zu überprüfen, dass `I`, `J`, `K` und `L` innerhalb der für `P1` bzw. `P3` definierten Bereiche sind.

Bei `INDX=ON` oder `RANGE=ON` wird Code generiert, um zu überprüfen, dass `I:J` und `K:L` Bereiche von der gleichen Länge bezeichnen.

Bei `OVFLW=ON` wird Code generiert, um zu überprüfen, dass der Wert von `P3` in die entsprechende `P1`-Variable passt.

Zum Beispiel: Der Wert `100` würde hier einen Überlauf verursachen.

Beispiel-Fehlersituation:

Wenn bei gesetztem `OVFLW=OFF` eine der Ausprägungen von `P3` den Wert `100` enthält, ist der Wert, der der entsprechenden `P1`-Ausprägung zugewiesen wird, Null. Ist bei gesetztem `INDX=OFF` die Index-Variable `I` Null oder größer als `9`, werden Speicherbereiche, die nicht zu Array `P1` gehören, beschädigt. Sind diese Optionen (`OVFLW` und `INDX`) auf `ON` gesetzt, tritt ein Natural-Fehler auf, so wie es in der Standard-Natural-Laufzeit der Fall ist.

Für die oben angegebenen NOC-Optionen wird zusätzlicher Code generiert. Dies wird jedoch durch den Vorteil einer Prüfung gut kompensiert, die z. B. vor schwer zu entdeckenden und bereinigenden Fehlern schützt. Unentdeckte Fehler können natürlich zu unvorhersehbaren Ergebnissen führen.

### Optimale Code-Generierung

Um sicherzustellen, dass die geringste Menge an Code generiert wird, und somit optimale Leistung zu erreichen, verwenden Sie:

    OPT='NODBG,NOSGNTR,SIGNCHCK=OFF,ZD=OFF'

Wenden Sie diese Einstellung jedoch nur auf Objekte an, die gründlich mit dem Debugger fehlerbereinigt wurden, siehe auch Anmerkung zu INDEX, INDX, OVFLW und RANGE.

## ARCH-Option

Die `ARCH`-Option dient zur Angabe des IBM Hardware Architecture Level, der zum Generieren von Code für ausführbare Natural-Objekte benutzt werden soll.

Wenn Sie einen `ARCH`-Wert angeben, generiert der Natural Optimizer Compiler neuere und schnellere Maschineninstruktionen, die die Leistung des generierten Codes verbessern können. Der angegebene Wert darf nicht höher sein als der Architecture Level Ihrer aktuellen Maschine. Ein mit einem `ARCH`-Level katalogisiertes ausführbares Natural-Objekt kann nur auf einer Maschine mit gleichem oder einem höheren Architecture Level laufen. Deshalb empfehlen wir, die `ARCH`-Option nicht zu verwenden, wenn die katalogisierten Objekte auf einer beliebigen Maschine, insbesondere auf einer Maschine mit niedrigerem Architecture Level, ausgeführt werden sollen.

Ausführliche Informationen zu IBM Hardware Architecture Level siehe IBM-Literatur (z/Architecture, Principles of Operation).

Die folgenden Architecture Levels werden von der `ARCH`-Option des Natural Optimizer Compiler unterstützt:

IBM Architecture Level | Erforderliche IBM Hardware Facility
--- | ---
`0` | Gibt an, dass kein Architecture Level benutzt wird. Dies ist die Standardeinstellung für alle von Natural unterstützen Großrechnerplattformen.
`1` bis `4` | Diese Werte werden nicht ausgewertet und wie `ARCH=0` behandelt.
`5` bis `6` | z800 oder z900 Extended-Translation Facility 2 z890 oder z990 HFP Multiply-and-Add/Subtract Facility
`7` | z9 bis z109 Extended-Immediate Facility
`8` | z10 General-Instructions-Extension Facility z10 Execute-Extensions Facility
`9` | zEnterprise 196 Load/Store-on Condition Facility Floating-Point-Extension-Facility Distinct-Operands Facility High-Word-Facility
`10` | zEnterprise EC12 (zEC12) Decimal Floating-Point Facility Decimal Floating-Point Zoned-Conversion Facility
`11` | zEnterprise z13 Decimal Floating-Point Packed-Conversion Facility
`12` | zEnterprise z14 Vector Packed-Decimal Facility

Anmerkung
Bei einem `ARCH`-Wert größer als Null generiert der Natural Optimizer Compiler Instruktionen bis hin zu dem in obiger Tabelle beschriebenen Facility Level. Ein `ARCH`-Wert größer als der Architecture Level der zugrunde liegenden Maschine wird bei der Kompilierung abgelehnt. Der Versuch, ein Programm, das mit einem `ARCH`-Level kompiliert wurde, auf einer Maschine mit einem niedrigeren Architecture Level zu starten, führt zu einem Laufzeitfehler NAT1394. Informationen zu der aktuellen Maschine können Sie sich mit dem Systemkommando `TECH` anzeigen lassen.

Folgende Themen werden behandelt:

- Unterstützung für Architecture Level 10

- Unterstützung für Architecture Level 11

- Unterstützung für Architecture Level 12

- Kompatibilität für Architecture Level 10 und 11

- Kompatibilität für Architecture Level 12

### Unterstützung für Architecture Level 10

Bei gesetztem `ARCH=10` generiert der Natural Optimizer Compiler Instruktionen, die von der Decimal-Floating-Point (DFP) Zoned-Conversion Facility für die in den folgenden Abschnitten beschriebenen numerischen Operationen zur Verfügung gestellt werden. Dies kann die Ausführungsgeschwindigkeit für Statements, die diese Operationen verwenden, erheblich verbessern.

> Operationen optimiert durch ARCH=10

>   Die folgenden arithmetischen Operationen auf Variablen der Natural-Datenformate I (ganzzahlig), N (numerisch ungepackt) und P (gepackt numerisch) profitieren von `ARCH=10`.

>   - Wertzuweisungen:

>     `P:=I`

>     `P:=N`

>     `N:=I`

>     `N:=N`

>     `N:=P` nur wenn die Anzahl gepackter Ziffern kleiner gleich 15 ist.

>     `I:=N`

>   - Arithmetische Operationen wie zum Beispiel mit den Statements `ADD`, `SUBTRACT`, `DIVIDE` und `MULTIPLY`, jedoch nur wenn folgende Bedingungen zutreffen:

>     Mindestens einer der verwendeten Operanden ist im Format N oder I.
>     Das Ergebnis der Operation überschreitet nicht 34 Stellen (Ganzzahl- + Dezimalstellen).

>   - Vergleiche wie zum Beispiel mit den Statements `IF` und `DECIDE`, jedoch nur wenn folgende Bedingungen zutreffen:

>     Mindestens einer der verwendeten Operanden ist im Format N.
>     Die beiden Operanden habe verschiedene Formate.

### Unterstützung für Architecture Level 11

Bei gesetztem `ARCH=11` verwendet der Natural Optimizer Compiler Maschineninstruktionen, die mit der DFP Packed-Conversion Facility eingeführt wurden. Zusätzlich zu den mit `ARCH=10` optimierten numerischen Operationen optimiert `ARCH=11` auch Operationen, die nur gepackte Variablen verwenden.

### Unterstützung für Architecture Level 12

Bei gesetztem `ARCH=12` generiert der Natural Optimizer Compiler Maschineninstruktionen, die mit der Vector Packed-Decimal Facility (VPD) eingeführt wurden. Dies kann die Ausführungsgeschwindigkeit bei Zuweisungen, Vergleichen und Berechnungen verbessern, wenn mindestens ein gepackter Operand verwendet wird.

VPD-Maschineninstruktionen werden bei den gleichen Natural-Operationen generiert, die bei Architecture Level 10 und Architecture Level 11 benutzt werden, sie werden jedoch nur bei arithmetischen Operationen verwendet, deren Ergebnisse 31 Stellen (Ganzzahlstellen + Dezimalstellen) nicht übersteigen.

### Kompatibilität für Architecture Level 10 und 11

Wenn `ARCH=10` benutzt wird, generiert der Natural Optimizer Compiler Maschineninstruktionen, die mit der Decimal-Floating-Point (DFP) Zoned-Conversion Facility oder der DFP Packed-Conversion Facility eingeführt wurden. Diese Instruktionen bewirken eine schnellere Ausführung als die Standard-Maschinencode-Instruktionen für arithmetische Operationen, sie akzeptieren jedoch keine Daten, die in Bezug auf den gezonten numerischen Datentyp (N) unzulässig sind.

Dies kann zu Laufzeitfehlern führen, wenn ein N-Feld innerhalb eines `REDEFINE`-Abschnitts einer alphanumerischen oder binären Variablen definiert ist und das N-Feld nicht zulässig initialisiert wird, bevor es in einer arithmetischen Operation benutzt wird.

Ein numerisches zoniertes Feld enthält eine Ziffer in einem Byte. Normalerweise enthält jedes Byte `x’F’` im linken Halbbyte (Zone Bits) und den Ziffernwert (0-9) im rechten Halbbyte (Numeric Bits). Dies gilt für alle Bytes, außer dem letzten, das (A-F) im linken Halbbyte enthält (Sign Bits).

Ein Vorzeichen-Halbbyte (C,A,F,E) stellt einen positiven Wert dar, während (B,D) für einen negativen Wert steht. Ein anderer Wert als (0-9) innerhalb des numerischen Halbbytes (N) und ein anderer Wert als (A-F) innerhalb des Vorzeichen-Halbbytes (S) wird als ungültig angesehen. Die Daten innerhalb der Zonen-Halbbytes (Z) werden von arithmetischen Konvertierungsanweisungen nicht berücksichtigt und können einen beliebigen Wert (0-F) haben.

Beispiel für eine Variable, die als (N6) definiert ist:

ZN | ZN | ZN | ZN | ZN | SN | Vorzeichen ist | Wert ist | Funktioniert bei `ARCH<=9` | Funktioniert bei `ARCH>=10`
--- | --- | --- | --- | --- | --- | --- | --- | --- | ---
F1 | F2 | F3 | F4 | F5 | F6 | F=positive | 123456, ok | ja | ja
F3 | F2 | F6 | F3 | F3 | D2 | D=negative | 323662, ok | ja | ja
40 | 40 | 40 | 40 | 40 | 40 | 4=ungültig | 000000, ok | ja | NAT7024
00 | 00 | 00 | 00 | 00 | 00 | 0=ungültig | 000000, ok | ja | NAT7024
12 | 13 | 14 | 15 | 16 | 17 | 1=ungültig | 234567, ok | ja | NAT7024
51 | 6B | 72 | 7A | 12 | F1 | F=positive | 1B2A21, ungültig | NAT0954 | NAT7024

Wenn `ARCH=9` (oder niedriger) benutzt wird, werden ungültige Vorzeichen-Halbbytes (0-9) durch den generierten Code automatisch in ein positives Vorzeichen (F) korrigiert. Dadurch werden N-Felder mit leerem Inhalt zu gültigen Daten mit dem Wert Null. Das Gleiche gilt für Hexa-Null-Daten.

Wenn `ARCH=10` oder `ARCH=11` benutzt wird, bleiben ungültige Vorzeichen-Halbbytes (0-9) unverändert und führen zu einer Programmprüfung (Data Exception), wenn auf sie von einer DFP-Instruktion zugegriffen wird. Wenn ein solcher Abbruchfehler auftritt, gibt Natural anstelle des Fehlers NAT0954 den Fehler NAT7024 aus, um eindeutig anzuzeigen, dass der Fehler durch eine N-Variable verursacht wird, die keine gültigen numerischen Daten enthält.

Wenn ein numerisches Halbbyte (N) nicht den Wert (0-9) enthält, erfolgt unabhängig vom benutzten Architecture Level eine Programmprüfung (Data Exception).

#### Schlussfolgerung:

Benutzen Sie `ARCH=10` oder `ARCH=11` nicht mit einem anderen Vorzeichenwert als (A-F), um ein Programm zu katalogisieren, das mit unsauberen numerischen Daten arbeitet.

Beispiel:

    OPTIONS MCG=(PGEN,ARCH=9)
    DEFINE DATA LOCAL
    1 #A (A6)
    1 REDEFINE #A
      2 #N (N6)
    END-DEFINE                                     /*  ARCH=9  ARCH=10
    #A := H'F1F2F3F4F5F6'   ADD 1 TO #N  WRITE #N  /*  ok       ok
    #A := H'F3F2F6F3F3D2'   ADD 1 TO #N  WRITE #N  /*  ok       ok
    #A := H'404040404040'   ADD 1 TO #N  WRITE #N  /*  ok       NAT7024
    #A := H'000000000000'   ADD 1 TO #N  WRITE #N  /*  ok       NAT7024
    #A := H'121314151617'   ADD 1 TO #N  WRITE #N  /*  ok       NAT7024
    #A := H'516B727A12F1'   ADD 1 TO #N  WRITE #N  /*  NAT0954  NAT7024
    END

Darüber hinaus, wenn `ARCH=10` (oder höher) benutzt wird, kann Natural einen Fehler NAT1305 (abgeschnittener numerischer Wert) anstelle eines Fehlers NAT1301 (Zwischenergebnis zu groß) aus folgendem Grund ausgeben: Zur Berechnung von Zwischenergebnissen wird das numerische DFP-Format benutzt und ein Überlauf wird erst am Ende der arithmetischen Operation festgestellt, wenn das DFP in das Format des Ereignisses umgewandelt wird.

### Kompatibilität für Architecture Level 12

Wenn `ARCH=12` benutzt wird, generiert der Natural Optimizer Compiler Maschineninstruktionen, die mit der Vector Packed-Decimal Facility (VPD) eingeführt wurden und die in Bezug auf die Unrichtigkeit der Daten mit dem Code kompatibel sind, der mit `ARCH=9` (oder niedriger) generiert wurde.

Numerische Datenfelder (N) mit unrichtigen Vorzeichendarstellungen (0-9) werden in den positiven Vorzeichenwert (F) konvertiert. Dabei werden numerische Felder mit Leerzeichen oder einem `hex00`-Inhalt akzeptiert und als Wert Null behandelt. Eine Daten-Ausnahme (Abend) tritt in dieses Fällen nicht auf.

## ARROPT-Option

Die Option `ARROPT` bestimmt den Generierungsalgorithmus, der bei Array-Zuweisungen des Typs `A(*):=scalar` verwendet werden soll.

Gültige Werte für `ARROPT`:

Wert | Erklärung
--- | ---
`ON` | Empfohlene Einstellung für Arrays mit mindestens 50 Ausprägungen. `ON` ist die Standardeinstellung.
`OFF` | Empfohlene Einstellung für Arrays mit weniger als 50 Ausprägungen.

## PGEN-Option

Die `PGEN`-Option bewirkt, dass der Natural Optimizer Compiler den generierten Code und interne Natural-Strukturen ausgibt. Dies ermöglicht es, Code und Strukturen zu untersuchen, z.B. zur Fehlerbehebung, Performance-Überprüfung und bei Support-Fragen.

Um die von der `PGEN`-Option gelieferten Ergebnisse interpretieren zu können, ist ein Verständnis der Arbeitsweise des /370-Assemblers von IBM erforderlich.

Wir empfehlen Ihnen, diese Option mit Unterstützung durch den Support zu benutzen.

Folgende Themen werden behandelt:

- PGEN setzen

- Sub-Optionen der PGEN-Option

- Ausgabe der PGEN-Option

- Arbeiten mit der PGEN-Ausgabe

### PGEN setzen

Um die `PGEN`-Funktion zu benutzen, müssen Sie die `PGEN`-Option setzen, wenn Sie den Optimizer Compiler aktivieren.

Da der Pufferbereich im Speicher vorgehalten wird, kann es vorkommen, dass der Benutzer-Thread nicht groß genug ist, um die Trace-Informationen aufzunehmen. In diesem Fall sollten Sie versuchen, `PGEN` nur für den Teil des Programms zu setzen, dessen Ablauf verfolgt werden soll, zum Beispiel:

`OPTIONS MCG=(PGEN=ON,TRGPT=ON)` oder `OPTIONS MCG=+PGEN,TRGPT` | Schaltet die Ablaufverfolgung (Tracing) ein, einschließlich der Ablaufverfolgung der GPT-Einträge.
`OPTIONS MCG=(PGEN=OFF)` oder `OPTIONS MCG=-PGEN` | Schaltet die Ablaufverfolgung aus.

Es sind verschiedene Optionen verfügbar, die den Inhalt der Ausgabe beeinflussen. In ihrer Grundform bewirkt die `PGEN`-Option eine formatierte Auflistung von Natural-Quellcode-Zeilen und eine Disassemblierung des entsprechenden Codes, der generiert und im Speicher abgelegt werden soll, um von dort mittels der `NOCSHOW`-Utility extrahiert zu werden, siehe Beschreibung in Ausgabe der PGEN-Option.

Die Optionen `TRSTMT`, `TRGPT`, `TRMPT` und `TRVDT` bewirken, dass Hex-Dumps von internen Datenstrukturen, die mit jeder Zeile verbunden sind, ausgegeben werden.

Die Optionen `TRBASES` und `TRCACHE` bewirken, dass Informationen über Basisregister und Cache-Variablen ausgedruckt werden.

### Sub-Optionen der PGEN-Option

In der folgenden Tabelle werden die Optionen beschrieben, die bei `PGEN=ON` verfügbar sind. Die Erklärung der verwendeten Syntax finden Sie in der Einleitung zum Abschnitt Liste der Optionen weiter oben.

Option | Erklärung
--- | ---
`LPP={5|..| 55 |..|255}` | Zeilen pro Seite für die Trace-Ausgabe. Nur bei `TREXT=ON` benutzt.
`NOsrcE[={ON| OFF |Y|N}]` | Bei `NOsrcE=OFF` wird das Natural-Quellcode-Statement in die Ausgabe aufgenommen.
`TRACELEV={ 0 |..|255}` | Gibt den Trace Level an. Jedes Bit in diesem Ein-Byte-Wert gibt einen Puffertyp für die Verfolgung an; diese Bits können mit den Optionen `TRxxx` ebenfalls eingeschaltet werden.
`TRBASES[={ON| OFF |Y|N}]` | Gibt an, ob Basisregisterzuweisungen verfolgt werden.
`TRCACHE[={ON| OFF|Y|N}]` | Gibt an, ob `CACHE`-Einträge verfolgt werden.
`TREXT[={ON| OFF |Y|N}]` | Bei `TREXT=ON` wird die Ablaufverfolgung an den User Exit `NOCPRINT` geleitet, Beschreibung siehe unten.
`TRGPT[={ON| OFF |Y|N}]` | Gibt an, ob `GPT`-Einträge verfolgt werden.
`TRMPT[=ON| OFF |Y|N}]` | Gibt an, ob `MPT`-Einträge verfolgt werden.
`TRSTMT[={ON| OFF |Y|N}]` | Gibt an, ob `STMT`-Einträge verfolgt werden.
`TRVDT[={ON| OFF |Y|N}]` | Gibt an, ob `VDT`-Einträge verfolgt werden.

Siehe auch die folgenden Beispiele.

### Ausgabe der PGEN-Option

Es gibt zwei Stellen, an die der Natural Optimizer Compiler die Ausgabe von `PGEN` leiten kann.

- Interner Pufferspeicher
- User Exit NOCPRINT

#### Interner Pufferspeicher

Der Inhalt dieses Pufferspeichers wird jedes Mal überschrieben, wenn eines der Kommandos `CHECK`, `CAT`, `STOW` oder `RUN` ausgeführt wird.

Es wird ein Systemdienstprogramm (Utility) `NOCSHOW` bereitgestellt, mit dem der Inhalt dieses Puffers angesehen, durchsucht oder gedruckt werden kann.

Um die Utility NOCSHOW aufzurufen:

- Geben Sie das Direktkommando `NOCSHOW` ein, nachdem eines der Kommandos `CHECK`, `STOW`, `CAT` oder `RUN` ausgeführt worden ist, während der Natural Optimizer Compiler aktiv gewesen ist.

Im Bildschirm sind folgenden PF-Tasten belegt:

PF-Taste | Funktion
--- | ---
PF2 | Position am oberen Rand der Ausgabe.
PF4 | Position eine Zeile zurück
PF5 | Position eine Zeile vor
PF6 | In Report (1) drucken
PF7 | Position eine Seite zurück
PF8 | Position eine Seite vorwärts
PF9 | Via Entire Connection in Report (7) drucken
PF10 | Nach Zeichenkette durchsuchen
PF11 | Suche wiederholen

#### User Exit NOCPRINT

Wenn `TREXT=ON` angegeben ist, übergibt der Natural Optimizer Compiler jede Ausgabezeile an den User Exit `NOCPRINT`, anstatt sie im Trace-Pufferspeicher hinzuzufügen.

Der Aufruf von `NOCPRINT` erfolgt gemäß normalen Betriebssystem-Registerkonventionen. Register 1 zeigt auf ein Vollwort, das die Adresse der 81-Byte-Druckzeile mit ANSI-Vorschubsteuerzeichen in Position 1 enthält. Register 13 zeigt auf einen Bereich von 18*4 Bytes, der als Speicherregister benutzt werden kann. Register 14 enthält die Rückgabeadresse und Register 15 enthält die Eingabeadresse von `NOCPRINT`.

Der User Exit `NOCPRINT` kann in einer beliebigen Sprache geschrieben sein, die die oben genannten Registerkonventionen unterstützt. Der User Exit muß zusammen mit dem Natural Optimizer Compiler-Nukleus mit dem Natural-Nukleus verlinkt sein.

### Arbeiten mit der PGEN-Ausgabe

Dieser Abschnitt enthält Hinweise und Erläuterungen, wie die mit der `PGEN`-Option erstellte Ausgabe zu interpretieren ist.

- Oben in der `PGEN`-Ausgabe stehen einige disassemblierte Zeilen, die scheinbar nicht zu einer Quellcode-Zeile gehören. Es handelt sich um die Instruktionen, aus denen der Prolog besteht, der immer dann ausgeführt wird, wenn die Steuerung vom nicht-optimierten zum optimierten Code übergeben wird. Permanente Basisregister werden geladen und die Steuerung wird an den korrekten Punkt im Prolog übergeben. Siehe Beispiel Abschnitt A weiter unten.

- Manchmal werden viele Zeilen ohne Code gedruckt. Dies bedeutet, dass dort kein Code erforderlich war oder das diese Statements von der NOC-Optimierung ausgeschlossen sind. Siehe Beispiel Abschnitt B weiter unten.

  Besteht daraüber hinaus der für ein Natural-Statement generierte Code nur aus Folgendem:

      BAS   R14,RETH
      DC    X'....'

  so bedeutes dies eine Rückkehr zur Standardlaufzeit, weil dieses Statement nicht von NOC optimiert werden konnte (siehe Zeile `0170`).

- Wenn `NODBG=OFF` (Standardeinstellung) angegeben worden ist, wird zu Beginn eines jeden neuen Natural-Statement eine Instruktionsfolge generiert.

      BALR R9,R11
      DC X'....'

  Diese Instruktionsfolge setzt (im Fehlerfall) die Zeilennummer und prüft, ob der Test-Modus eingeschaltet ist (`TEST` auf `ON`). Ohne diese Instruktionsfolge ist ein Debugging von NOC-kompilierten Statements durch den Natural Debugger nicht möglich. Siehe Beispiel Abschnitt C weiter unten.

- Manchmal ist zwischen disassemblierten Zeilen ein Zeilenumbruch vorhanden. Der Umbruch zeigt eine interne Statement-Trennung an. Dies kommt vor, weil ein einzelnes Natural-Statement oft mehrere interne (Pseudo-Code-)Statements generiert.

- Die bedienten Natural-Variablen werden in den Assembler-Code eingefügt.

- Die Angaben auf der rechten Seite (z.B. `START 8FEC`) sind interner Art. Sie dokumentieren den Pfad, wie der Code von den NOC-Modulen generiert wurde.

- Alle Adressarten innerhalb des Codes werden aufgelöst und in der Form `=(00044)` zur Verfügung gestellt. Dies dokumentiert den Versatz im Code, an dem die Verzweigung ausgeführt wird.

- Die erste und die letzte Code-Instruktion enthält die zum Kompilieren dieses Programms benutzte NOC-Version: `4700 8410` bedeutet NOC-Version V841.

#### Beispiel Abschnitt A:

     000000 4700 8410           NOP   1040(,R8)                         START  8FEC
     000004 5880 D354           L     R8,CONST                                 D9DC
     000008 5870 D370           L     R7,LOCAL                                 D9DC
     00000C 4810 6006           LH    R1,6(,R6)                                90A0
     000010 1F60                SLR   R6,R0                                    90BA
     000012 47F1 A000           B     0(R1,R10)                                90C0

     000016 4DE0 B040           BAS   R14,RETH                           RETN  F0AA
     00001A 0034                DC    X'0034'                                  F0C0

#### Beispiel Abschnitt B:

     0010 0010 OPTIONS MCG=(PGEN,OVFLW,INDX)
      0020 DEFINE DATA LOCAL
      0030 1 I(I4)
      0040 1 P(P7.2)
      0050 1 T(P7.2)
      0060 END-DEFINE
      0070 *
      0080 SETTIME
      0090 *

#### Beispiel Abschnitt C:

     0100 FOR I=1 TO 100000

     00001C 0D9B                BASR  R9,R11                             MOVE 1724A
     00001E 004A                DC    X'004A'                                 17278
     000020 D203 7000 8148      MVC   I(4),#KST0148                            97D2

     000026 47F0 A044           B     68(,R10)         =(00044)          GOTO  EF44

     00002A 0D9B                BASR  R9,R11                              ADD 1724A
     00002C 006A                DC    X'006A'                                 17278
     00002E BF0F 7000           ICM   R0,B'1111',I                             BB20
     000032 5A00 8148           A     R0,#KST0148                              1E4E
     000036 0D90                BASR  R9,0                                     F12A
     000038 4710 B15C           BO    NAT1301                                  1E9E
     00003C BE0F 7000           STCM  R0,B'1111',I                             A9CC

     000040 0D9B                BASR  R9,R11                               IF 1724A
     000042 007C                DC    X'007C'                                 17278
     000044 BF0F 7000           ICM   R0,B'1111',I                             BB20
     000048 5900 819B           C     R0,#KST019B                              3FDA
     00004C 47D0 A054           BNH   84(,R10)         =(00054)                EF44

     000050 47F0 A078           B     120(,R10)        =(00078)          GOTO  EF44

     0110   ADD 1.00 TO P

     000054 0D9B                BASR  R9,R11                              ADD 1724A
     000056 0092                DC    X'0092'                                 17278
     000058 FA41 7004 819F      AP    P(5),#KST019F(2)                         20A0
     00005E 0D90                BASR  R9,0                                     F12A
     000060 4710 B15C           BO    NAT1301                                 1071C
     000064 910D 7008           TM    P+4,X'0D'                               120B0
     000068 4710 A070           BO    112(,R10)        =(00070)               120F6
     00006C 960F 7008           OI    P+4,X'0F'                               1210ª

     0120 END-FOR
     0130 *

     000070 0D9B                BASR  R9,R11                             GOTO 1724A
     000072 00A4                DC    X'00A4'                                 17278
     000074 47F0 A02A           B     42(,R10)         =(0002A)                EF44

     0140 T:=*TIMD(0080)

     000078 0D9B                BASR  R9,R11                             SYFU 1724A
     00007A 00AE                DC    X'00AE'                                 17278
     00007C 4DE0 B0D8           BAS   R14,SYSFUNC                              5F1A
     000080 0190 B881           DC    X'0190B881'                              5F28

     000084 F246 7009 8190      PACK  T(5),#KST0190(7)                   MOVE  AD18
     00008A 910F 700D           TM    T+4,X'0F'                               12130
     00008E 4710 A0A0           BO    160(,R10)        =(000A0)               12176
     000092 17EE                XR    R14,R14                                 1218E
     000094 43E0 700D           IC    R14,T+4                                 12194
     000098 43EE B488           IC    R14,PSGNTR(R14)                         121AA
     00009C 42E0 700D           STC   R14,T+4                                 121B2
     0000A0 F040 7009 0002      SRP   T(5),2,0                                 ACA2
     0000A6 17EE                XR    R14,R14                                 1218E
     0000A8 43E0 700D           IC    R14,T+4                                 12194
     0000AC 43EE B488           IC    R14,PSGNTR(R14)                         121AA
     0000B0 42E0 700D           STC   R14,T+4                                 121B2

     0150 T:=T / 10
     0160 *

     0000B4 0D9B                BASR  R9,R11                              DIV 1724A
     0000B6 00C0                DC    X'00C0'                                 17278
     0000B8 F864 D100 7009      ZAP   OP1(7),T(5)                              AC60
     0000BE FD61 D100 81A1      DP    OP1(7),#KST01A1(2)                       327A
     0000C4 F844 7009 D100      ZAP   T(5),OP1(5)                              AC60
     0000CA 910D 700D           TM    T+4,X'0D'                               120B0
     0000CE 4710 A0D6           BO    214(,R10)        =(000D6)               120F6
     0000D2 960F 700D           OI    T+4,X'0F'                               1210A

     0170 DISPLAY 'ELAPSED TIME (S)' T

     0000D6 4DE0 B040           BAS   R14,RETH                           RETN  F0AA
     0000DA 00D2                DC    X'00D2'                                  F0C0

     0180 END

     0000DC 40D6 D7E3 F844 2000 DC    X'40D6D7E3F8442000'  =' OPT8à..'    END  927E
     0000E4 0000 0000           DC    X'00000000'                                nf
     0000E8 40D5 D6C3 F8F4 F140 DC    X'40D5D6C3F8F4F140'  =' NOC841 '         92E4

## UNICC-Option

Die `UNICC`-Option steuert die Generierung von optimiertem Code für `IF`-, `DECIDE FOR`- und `DECIDE ON`-Statements, die Unicode-Operanden enthalten.

Gültige Werte für `UNICC`:

Wert | Erklärung
--- | ---
`ON` | Generiert optimierten Code und prüft, ob `COLLATE=OFF` gesetzt ist (siehe Profilparameter `CFICU` in der Parameter-Referenz-Dokumentation). Falls `COLLATE=ON` gesetzt ist, schlägt die Ausführung des optimierten Code fehl und der Natural-Systemfehler NAT7023 tritt auf.
`FORCE` | Generiert optimierten Code wie bei `ON`, aber ohne abzuprüfen, ob `COLLATE=OFF` gesetzt ist.. Der mit `FORCE` optimierte Code hat eine bessere Leistung als der mit `ON` optimierte, kann jedoch falsche Ergebnisse verursachen, wenn `COLLATE=ON` gesetzt ist.
`OFF` | Es wird kein optimierter Code generiert. `OFF` ist die Standardeinstellung.

## Voraussetzungen für die Code-Generierung mit Unicode-Operanden

Der Natural Optimizer Compiler generiert optimierten Code für Natural-Statements mit Unicode-Zeichenketten, wenn die folgenden Erfordernisse erfüllt sind:

Statement | Erforderlich
--- | ---
Alle Statements | Alle im Statement benutzten Operanden müssen vom Typ Unicode sein.
`EXAMINE` | Die `ARCH`-Option muss auf einen Wert größer gleich `6` gesetzt sein.
`IF` `DECIDE FOR` `DECIDE ON` | Alle Unicode-Zeichenketten müssen normalisiert sein. Die `ARCH`-Option muss auf einen Wert größer gleich `5` gesetzt sein. Die `UNICC`-Option muss auf `ON` oder `FORCE` gesetzt sein. Die `COLLATE`-Option des Profilparameters `CFICU` muss auf `OFF` gesetzt sein (siehe Parameter-Referenz-Dokumentation).
`MOVE` `MOVE SUBSTRING` `RESET` | Die `ARCH`-Option muss auf einen Wert größer gleich `5` gesetzt sein.

## Einfluss anderer Natural-Parameter

Der globale Parameter `ZD` beeinflusst das Verhalten des NOC-Compiler. Siehe Beschreibung der `ZD`-Option unter Liste der Optionen weiter oben.

Der `COMPOPT`-Subparameter `PSIGNF` (siehe auch Systemkommando `COMPOPT` in der Natural-Systemkommando-Dokumentation) beeinflusst das Verhalten, indem er erzwingt, dass positive gepackte Dezimalzahlen bei `ON` auf F und bei `OFF` auf C gesetzt werden. Der Parameter wird angewendet, wenn `NOSGNTR=OFF` angegeben ist.

Siehe die Tabelle unten für gepackte Daten (Format P) :

`NOSGNTR=OFF` | und | `PSIGNF=ON` | Alle Vorzeichen werden auf F normalisiert (Standard).
`NOSGNTR=OFF` | und | `PSIGNF=OFF` | Alle Vorzeichen werden auf C normalisiert.
`NOSGNTR=ON` |  | Alle Vorzeichen werden so belassen, wie sie bei der letzten Operation erzeugt wurden.

Für numerische Daten (Format N) werden die Vorzeichen immer auf F normalisiert, unabhängig von den Einstellungen von `NOSGNTR` und `PSIGNF`.

### On this page

- Liste der Optionen
- ARCH-Option
- ARROPT-Option
- PGEN-Option
- UNICC-Option
- Voraussetzungen für die Code-Generierung mit Unicode-Operanden
- Einfluss anderer Natural-Parameter