ARIES(5)

Set the environment variable PA_DEBUG to 1.

Set the environment variable SHELL to point to a PA-RISC shell, copied from a PA-RISC HP-UX system from /usr/bin path.

Add /usr/ccs/bin to the PATH environment variable.

Invoke gdb as:

$ gdb PA-RISC_executable

Perform the preparatory steps as described above for debugging PA-RISC application under ARIES using PA-RISC gdb.

Invoke gdb as follows:

$ gdb PA-RISC_executable PA-RISC_processID

Unset the environment variable PA_DEBUG.

Restore the original value of the SHELL environment variable.

No support for debuggers other than PA-RISC HP-UX gdb for debugging PA-RISC applications on Integrity systems.

No support for old gdb versions (of HP-UX 10.20 and earlier). However, debugging of HP-UX 10.20 applications using a HP-UX 11.0 (and newer) PA-RISC gdb is supported.

PA-RISC gdb behaves differently for child processes created using fork() and vfork() system calls. ARIES emulates vfork() and fork() system calls identically. The exact behavior shown by PA-RISC gdb under ARIES may differ from that on a native PA-RISC HP-UX system.

If the debugged process is blocking in a system call, any attempt to get to the gdb command prompt by pressing ctrl-C does not work. The process needs to be killed from a different shell.

ARIES does not provide true emulation of MxN threads, and thus does not support debugging of PA-RISC applications that are linked with pthreads library and create threads in MxN model.

NOTE: The PA-RISC applications linked with MxN pthreads library are emulated under ARIES as traditional 1x1 threads, and thus can only be debugged under ARIES as any other non-MxN multi-threaded application. Refer to the EMULATION OF MxN THREADS UNDER ARIES section in this manpage for more information.

ARIES supports debugging of 32-bit and 64-bit PA-RISC HP-UX applications using 32-bit PA-RISC HP-UX gdb. 64-bit PA-RISC HP-UX gdb is not supported under ARIES.

Application path name and ARIES options must be separated by one or more white spaces.

Each non empty line must begin from first column.

ARIES options may be specified for multiple applications, each beginning on a separate line.

Relative paths and shell variables are not allowed.

An invalid ARIES option will result in process termination with error.

# in first column is treated as comment and rest of the line is ignored.

* is treated as wild card character and can be used in application path name.

ARIES wild card matching is based on simple text pattern match with no expansion of directory or file name.

When using wild cards it is possible for multiple lines to match the current application. If this behavior is not expected, then change your ARIES resource configuration file accordingly.

Application path name field must be one of following:

ARIES option processing is additive in nature. ARIES continues to search the RC file in all search paths. ARIES options found in earlier RC file matches are overwritten by option values in later RC file matches.

If the value of environment variable HOME is NULL, or the path is not accessible, ARIES will ignore the user's private RC file.

If ARIES cannot find or access the RC file in any of the search paths, it will continue with default values of options.

The ARIES RC file search in application directories enables application vendors to ship custom ARIES RC files with ARIES options values suitable for their particular applications.

[Disables] enables the creation of separate address map data structure for dynamically generated code by PA-RISC application. Enabling (-amap_smc) this option flag may provide optimal performance for JVM-like applications.

The default state of this option flag is enabled (-amap_smc).

[Disables] enables the dynamic patching of branch targets in ARIES translated code blocks.

WARNING: Disabling (-nobackpatch) this option flag will cause significant performance slowdown.

The default state of this option flag is enabled (-backpatch).

[Disables] enables the scheduling and optimization of ARIES translated code. Enabling (-breaker) this option flag is useful only for reducing the ARIES dynamic translation time although the overall performance may become slower.

The default state of this option flag is disabled (-nobreaker).

[Disables] enables the generation of PA-RISC application core file with OS version field filled with release version of the Integrity HP-UX systems. Disabling (-nocompat_core) this option flag will result in core files which may not work with gdb from an older PA-RISC HP-UX (11i version 1 and earlier) platform. Such core files need to be debugged using gdb from PA-RISC HP-UX 11i version 2 and later.

The default state of this option flag is enabled (-compat_core).

[Disables] enables appending of the process ID to the PA-RISC application core file name. See also getpid(2).

If this option flag is enabled (-corepid), the core file name will be core.PA-RISC_application_name.PID.

The default state of this option flag is disabled (-nocorepid).

[Disables] enables the dynamic translation of PA-RISC basic blocks that access and modify the Floating Point Acess Regiser (FPSR : fr0L) frequently.

The default state of this option flag is disabled (-nofpsr_trans).

[Disables] enables the printing of ARIES options and their minimum, maximum, and default values on stderr. If this option flag is enabled (-help) ARIES will exit after printing the available options.

The default state of this option flag is disabled (-nohelp).

[Disables] enables the generation of memory fence mf instruction in translation for ordered memory operations of PA-RISC application.

WARNING: Enabling (-mem_fence) this option flag will slow down the performance of memory loads in ARIES translated code. Enable (-mem_fence) this option flag only if the PA-RISC application expecting strong memory ordering (program uses volatile variables) fails under ARIES.

NOTE: Enabling the ARIES option flag -mem_order does not automatically enable (-mem_order) this option flag.

The default state of this option flag is disabled (-nomem_fence).

[Disables] enables the minimum memory footprint (process resident memory size) under ARIES. Enabling (-mem_min) this option flag is useful for applications that have constraints on process memory footprint. If this option flag is enabled (-mem_min), the sizes of all ARIES memory segments are set to their minimum values.

WARNING: Enabling (-mem_min) this option flag may cause performance slowdown due to increased number of ARIES translation code buffer flushes.

The default state of this option flag is disabled (-nomem_min).

[Disables] enables the strong memory ordering in ARIES. You should enable (-mem_order) this option flag only when your PA-RISC application expecting strong memory ordering fails under ARIES. Such an application would be the one, which does not use memory ordering semantics like ,O completer in load/store instructions or volatile cast in high level code, and still expects strong memory ordering.

WARNING: Enabling (-mem_order) this option flag may cause 2x-3x performance slowdown.

The default state of this option flag is disabled (-nomem_order).

[Disables] enables the mapping of the emulated FP (Floating Point) register context on general register stack. The performance of the floating point intensive PA-RISC applications may be better if this option flag is enabled (-opt_fpgr).

The default state of this option flag is enabled (-opt_fpgr).

[Disables] enables the ARIES optimizations for dynamically translated code to re-order PA-RISC state changing instructions, loads, and updates to general registers in order to achieve better scheduling of translated code.

WARNING: Do not enable (-opt_reorder) this option flag with multi-threaded applications like JVM which expect precise delivery of synchronous exceptions and register updates. Such applications may crash with core file if this option flag is enabled (-opt_reorder).

The default state of this option flag is disabled (-noopt_reorder).

[Disables] enables the emulation of the uname() and sysconf() system calls, to return information specific to native PA-RISC HP-UX systems. See uname(2) and sysconf(2).

Enable (-pa_os_cpu) this option flag only if the PA-RISC application expects the return values of uname() and sysconf() system calls, to be specific to the values that would have been obtained if the application was running on PA-RISC HP-UX system.

The default state of this option flag is disabled (-nopa_os_cpu).

[Disables] enables the trace scheduling and low level optimization of ARIES translated code.

NOTE: Enabling (-sched_trace) this option flag may provide improved performance for compute intensive applications.

The default state of this option flag is disabled (-nosched_trace).

[Disables] enables the dynamic translation in ARIES. Disabling (-notrans) this option flag is useful only for triaging of dynamic translator failures.

WARNING: Disabling (-notrans) this option flag will cause significant performance slowdown.

The default state of this option flag is enabled (-trans).

[Disables] enables the dynamic translation of self modifying (dynamically generated) code. Disabling (-nounsafetrans) this option flag is useful only for triaging of Java-based application failures under ARIES.

WARNING: Disabling (-nounsafetrans) this option flag will cause significant performance slowdown for Java-based applications.

The default state of this option flag is enabled (-unsafetrans).

Size in kbytes of the total memory area to be used for ARIES address map (AMAP) data structures, for mappings between PA-RISC basic blocks and translated code addresses.

NOTE: To minimize the performance drop due to increased frequency of ARIES AMAP area overflow, HP recommends setting this option value at the default or maximum size.

For optimal performance, a ratio of 1:2:2 should be maintained for the values of the ARIES options: -descsz, -amapsz, and -ccsz.

Size in kbytes of the memory area used for ARIES address map (AMAP) data structures corresponding to dynamic translations of self modifying code of PA-RISC application. This area is part of the memory region whose size is determined by the ARIES option -amapsz.

Size in kbytes of the memory area used for the ARIES private heap. This area is part of the ARIES heap whose size is determined by the ARIES option -heap_ssz. This area is used for ARIES's internal malloc() calls.

Increase the value of this ARIES option if the ARIES error is out of memory or malloc() failed.

Size in kbytes of the backing store area for ARIES native threads that are created for emulation of the application's threads.

Size in kbytes of the memory stack area for ARIES native threads that are created for emulation of the application's threads.

Size in kbytes of the ARIES translated code buffer.

NOTE: To minimize the performance drop due to increased frequency of ARIES code cache area overflow, HP recommends setting this option value at default or maximum.

For optimal performance, a ratio of 1:2:2 should be maintained for the values of the ARIES options: -descsz, -amapsz, and -ccsz.

Format of the ARIES generated PA-RISC application core files. By default, ARIES generates core file with large utsname structure. Use this option to generate PA-RISC application core file in format other than the default.

The valid values for version are as follows:

Refer to the Generation of PA-RISC HP-UX Compatible Core File section in this manpage for details on core file formats.

Size in kbytes of the memory area for ARIES internal data structures (code cache descriptors) for accessing and managing translated code blocks.

NOTE: To minimize the performance drop due to increased frequency of ARIES code cache descriptor area overflow, HP recommends setting this option value at default or maximum.

For optimal performance, a ratio of 1:2:2 should be maintained for the values of the ARIES options: -descsz, -amapsz, and -ccsz.

Size in kbytes of the memory area for shared use by dynamic translator internal memory allocation and alternate ARIES heap for memory allocation during signal handling.

Size in kbytes of the ARIES heap used for ARIES's own malloc() calls and to allocate space for ARIES thread creation.

The ARIES heap is divided into two parts. The first part is used as ARIES private heap whose size is determined by the option -ap_heap_ssz. The remaining area from the ARIES heap is used to allocate memory for the new threads.

The values above are shown with the default values of kernel tunable parameters, pa_maxssiz_32bit and pa_maxssiz_64bit, for 32-bit and 64-bit ARIES respectively.

With increased values of the respective kernel tunable parameters, the maximum value of ARIES heap is computed as follows:

Size in kbytes of the initially allocated stack for PA-RISC applications.

At process startup time, ARIES computes the minimum value of -issz by adding the sizes of argument strings, environment variable strings, and keybits structure. If the computed value is greater than -issz value, then ARIES increases this value accordingly.

Load the dynamically translated code from file_name at process startup time. This option can optimize ARIES time spent in dynamic translations. Refer to the option -save for storing the ARIES dynamic translations to a file.

WARNING: Using this option may cause the application to fail if the application and any of its dependent shared libraries changed from the time the translations were saved previously.

Enable ARIES to stop further processing of options after executing this option. The processing is stopped from any ARIES RC file down through the search path.

This option enables application vendors to lock the ARIES configuration in ARIES RC files shipped as part of the application installation.

Chunk size in kbytes for incremental memory allocation in ARIES for PA-RISC application stack, ARIES heap, ARIES code cache, descriptors stack and AMAP regions.

WARNING: A very low value for this option might degrade overall system performance due to too many mapped regions.

Reset to default values. All ARIES options processed so far from any ARIES RC file prior to this option are reset to their default values.

Save ARIES dynamic translations to file_name at process exit. Such saved translations may be used for later invocations of the same application using ARIES option -load.

Size in kbytes of the memory area for allocating PA-RISC application stack.

The default values shown above are with the default values of the kernel tunable parameters, pa_maxssiz_32bit and pa_maxssiz_64bit, for 32-bit and 64-bit ARIES respectively.

To increase the size of PA-RISC stack beyond the default values as shown above you must increase the kernel tunable parameters, pa_maxssiz_32bit and pa_maxssiz_64bit, for 32-bit and 64-bit ARIES respectively.

Use this option to override the ARIES assumed stack size for PA-RISC application. Refer to the EMULATION OF PA-RISC APPLICATION STACK UNDER ARIES section in this manpage for more details.

Translation threshold. The n number of times a PA-RISC basic block must be interpreted before it is considered as a candidate for dynamic translation.

This option can be used to tune the PA-RISC application performance under ARIES.

The valid range of values for n is from 0 to MAXINT (defined in /usr/include/sys/param.h).

The default value of this option is 16.

Trace scheduling threshold. The n number of times a translated block must execute before it is considered as a candidate for second pass translation with trace scheduling and optimizations.

This option can be used to tune the PA-RISC application performance under ARIES.

The valid range of values for n is from 0 to MAXINT (defined in /usr/include/sys/param.h).

The default value of this option is 1024.

ARIES's initialized data, un-initialized data (BSS) and thread local storage (TLS).

ARIES heap for internal malloc() calls and for creating ARIES threads for emulation of PA-RISC application's threads.

PA-RISC application's stack.

Translated code buffer (code cache region).

Data structures to access and manage the translated code blocks.

AMAP data structures for mapping of PA-RISC basic blocks and translated code block addresses.

Memory area used by ARIES dynamic translator as heap.

ARIES option -ssz value if -ssz is specified in the ARIES RC file.

The stack size value inherited from the parent process, If the ARIES option -ssz is not present in the ARIES RC file.

In most cases, the stack size value inherited from the parent process is the current value of kernel tunable parameter maxssiz, or the ulimit -s value in the shell.

For details on the maximum possible stack size under ARIES, Refer to the Relation Between pa_maxssiz_32|64bit and ARIES Parameters section in this manpage for more details.

NOTE: Stack sizes can be inherited among Integrity system native processes (32-bit and 64-bit) and emulated PA-RISC processes (32-bit and 64-bit), subjected to the limitation on available stack space under ARIES.

General applications, which have average mix of I/O intensive, memory intensive and system intensive operations.

Integer intensive applications which spend significant time in algorithmic computations.

Any category of PA-RISC applications migrated from old PA-RISC systems like N-class and earlier.

Static image rendering graphics applications (no animations).

Certain data base and client applications.

Floating point intensive applications like most scientific simulation, modeling applications. The performance slowdown is due to architectural differences between PA-RISC and Itanium(R) processor features and resources for floating point operations.

Java-based applications. Unless your application has JNI code, use Integrity native JVM. Depending on execution profile, performance of Java applications varies significantly under ARIES.

Multi-threaded applications that spend significant amount of time in thread synchronization operations. Thread suspension operation experiences slow performance under ARIES.

PA-RISC applications which use performance libraries such as HP mlib are not good candidates to run under ARIES. It is not possible for ARIES to emulate the detailed behavior of the application for maximum emulated hardware resource utilization.

OpenGL-based PA-RISC applications experience poor performance under ARIES. Such applications would execute with better performance under ARIES if they can use OpenGL display lists and send graphics data using GLX protocol mode.

PA-RISC applications which frequently use volatile variables or are compiled with option +Ovolatile.

For applications which are very much loop intensive, reduce the ARIES translation threshold value (ARIES option -ts).

For applications that run for a long duration and have good locality of execution (few functions account for significant portion of total execution time), you may consider enabling trace scheduling (ARIES option flag -sched_trace).

If trace scheduling is enabled, you may consider fine tuning the trace scheduling threshold (ARIES option -ts_trace).

For long running Java applications that have large methods, consider increasing the size of ARIES AMAP for dynamically generated code (ARIES option -amapsz_smc).

For some rare applications that access and modify the Floating Point Access Register (FPSR : fr0L) register in a loop, consider enabling translations for such blocks (ARIES option flag -fpgr_trans).

Some applications experience good performance if ARIES maps emulated FP register context on general registers. While others would perform well if this optimization is disabled. Consider changing the ARIES option flag -[no]opt_fpgr.

Some applications may show slight performance gain if re-ordering of state changing instructions and memory loads is enabled (ARIES option flag -[no]opt_reorder).

WARNING: Some multi-threaded applications like JVM might fail with core dump if ARIES re-orders state changing PA-RISC instructions.

Some applications that have large text segment size or load many shared libraries may require large code cache region size (ARIES option -descsz, -amapsz, -ccsz). For best results make sure that sizes of these parameters are in the ratio 1:2:2.

Some applications that require ARIES to spend significant time in dynamic translations may work faster if translations are cached (ARIES option -load, -save). The save and load of translated code works best for statically linked applications.

WARNING: Some PA-RISC applications may not work correctly with the loading of ARIES dynamic translations cached on disk during previous executions of the same application.