PSL Optimizer Tool

The PATROL PSL Optimizer tool is a three-level, multi-pass, intermediate code (quad) optimizer

Supported Platforms

Operating Systems

• UNIX
• Windows

PATROL Versions

• PATROL 3.2 only

Resource Requirements

The PSL Optimizer requires no additional resources beyond those specified for running the PATROL product.

When to Use the PSL Optimizer

Use this tool to optimize your KM code.

How to Install the PSL Optimizer

This tool is part of the PATROL Agent. No further setup is required once PATROL has been installed.

How to Deactivate the PSL Optimizer

Since this tool is part of the PATROL product, there is no requirement to deactivate the tool.

About the PSL Optimizer

When a PSL script is compiled, it is compiled down to an intermediate code. The PATROL Optimizer transforms the intermediate code generated by the PSL Compiler so that the code executes more efficiently in the PSL interpreter.

Optimization Levels

You can specify the level of optimization by using the -O flag with the PSL stand-alone compiler or with the PATROL Agent function. You can also use the pragma keyword in PSL to set the optimization level for a particular PSL script. 

The supported levels of optimization are:

Level 1: Peephole optimizations

Level 1 optimizations are ignorant of a program's control flow and are limited to the analysis of a program on an instruction by instruction basis. 

Level 1 optimizations include the following:

• jump chain reduction
• useless jump removal
• redundant instruction removal
• parameter packing

Jump chain reduction

This optimization looks for unconditional jumps to one or more Control Transfer Statement (CTS) instructions. The terminal CTS instruction is then replicated onto all of the non-terminal CTS instructions.

Useless jump removal

This optimization looks for unconditional and conditional jumps to the next instruction. The jump is then removed.

Redundant instruction removal

This optimization looks for redundant statements without side effects. One of the redundant statements is then removed.

Parameter Packing

This optimization looks for adjacent parameter instructions and packs them into a more efficient parameter instruction.

Level 2: Local optimizations

Level 2 optimizations use a flowgraph to optimize the program one basic block at a time. Code motion, addition, and removal are limited to a basic block unit. 

Level 2 optimizations include the following:

• constant folding
• constant propagation
• global constant propagation
• definition removal
• string concatenation conversion
• parameter ordering

Constant folding

Expressions are evaluated when their arguments are known at optimization time. The result of the folded expression replaces the original expression with an assignment operation.

Constant propagation

The results of constant folding are tracked and propagated into other expressions using the value. These values can then be folded into other expressions.

Global constant propagation

The values of symbols used in subsequent basic blocks are seeded for future Level 2 fold-and-propagate optimizations.

Definition removal

Expressions defining symbols that are later defined, without first being referenced, are removed. Expressions with side effects remove only the assignment to the symbol.

String concatenation conversion

Chains of string concatenations are converted into a single and more efficient call to the PSL join() function.

Parameter ordering

Parameter statements with nested expressions are re-ordered so all expression evaluation occurs before the first parameter statement and all parameter statements immediately precede the call statement. This exposes Level 1 parameter packing opportunities.

Level 3: Global optimizations

Level 3 optimizations alter the flowgraph by adding, removing, and re-locating basic blocks. 

Level 3 optimizations include the following:

• block chain reduction
• unreachable code removal
• loop tail logic injection
• orphan block inlining

Block chain reduction

One or more basic blocks that are entered from an unconditional jump are copied to the jump point. The resultant basic block is then extended to include the copied block.

Unreachable code removal

Code that can never be executed is removed.

Loop tail logic injection

Loops with conditional heads and unconditional tails are converted so that the condition evaluation takes place in the loop's tail(s). This decreases loop overhead by removing an unnecessary jump to the condition block.

Orphan block inlining

Blocks that are entered exclusively via jumps are inlined (moved) into the innermost loop that references this block.

Optimization Criteria

The PSL Optimizer decides at what level to optimize a program based on the following criteria:

• requested level
• demanded level
• maximum level

Requested level of optimization

The requested level is implicitly defined based on the context of the call to the PSL Compiler. For example, a PSL parameter script will request Level 3 global optimization when it is compiled. A script submitted via the %PSL command will request the default level (Level 1 peephole) of optimization when it is compiled. 

Currently, Level 3 global optimization is requested for all pre-discovery, discovery, and parameter PSL scripts. The default Level 1 is used for all other commands.

Demanded level of optimization

The demanded level is explicitly defined and takes precedence over the requested level. The demanded level can be specified on the command line or directly in the PSL program via the pragma statement. 

For example, a parameter can demand Level 2 optimization (and thus override the Level 3 request) by inserting the following pragma statement in the program: 

pragma " O2 " ;

Likewise, the optimization level can be specified system-wide via the command line as follows: 

PatrolAgent -02

This will cause all PSL scripts to be optimized at Level 2 except for any scripts containing a pragma statement requesting another level of optimization.

Maximum level of optimization

The maximum level is explicitly defined and takes precedence over the demanded level and the requested level. The maximum level restricts the Optimizer tool from invoking higher levels. For example, if a parameter specifies a maximum optimization level of 1, it will never get optimized at Levels 2 or 3. A program specifying a maximum level can use a pragma statement like this: 

pragma -OM1;

Likewise, the maximum level can be specified system-wide via the command line as follows: 

PatrolAgent -OM1 

Specifying a maximum level of zero (0) turns off the PSL Optimizer tool.

Command-Line Specified Options

The PSL Optimizer tool can be controlled using the following methods:

• Via a command-line switch for the psl and PatrolAgent commands. This affects scripts system wide.
• Via the pragma PSL statement. This affects only the script using the pragma statement.

The format is as follows: 

-O # M# P#

Where to go from here

PATROL Script Language overview and functions