HP OpenVMS systems
After a program source file is coded, it must be compiled or assembled into object modules by a language processor and then linked. The OpenVMS Linker binds the object modules into an image that can be executed on the OpenVMS operating system.
The linker processes object modules and shareable image files, as well as symbol table files, library files, and options files (used to manage the linking operation and simplify the use of complex, repetitious linker operations). The most common output of the linker is an executable image of the program. The linker can also produce a shareable image, a system image, an image map, or a symbol table file to be used by other programs being linked. Certain linking tasks, such as creating shareable images, are performed differently on OpenVMS VAX than on OpenVMS Alpha and OpenVMS I64 systems.
The Librarian utility provides for efficient storage in central, easily
accessible files of object modules, image files, macros, help text, or
other record-oriented information.
1.5.4 Testing and Debugging Programs
The OpenVMS symbolic debugger is more useful than DELTA/XDELTA for most programs: the symbolic commands entered using different interfaces (keypad, command line, or file of commands) display source code lines on the screen, have more descriptive error messages, and provide help information.
The debugger command language specified in the HP OpenVMS Debugger Manual provides more than 100 commands to control a debugging session, including these tasks:
The OpenVMS symbolic debugger provides enhanced support for programs that have multiple threads of execution within an OpenVMS process, including any program that uses POSIX Threads Library for developing real-time applications.
The debugger has been modified to support debugging of programs that contain 64-bit data addresses.
An additional debugger utility is available only on an OpenVMS Alpha system: the OpenVMS Alpha System-Code Debugger, which can be used to debug non-pageable system code and device drivers. The system-code debugger is a symbolic debugger that lets the user employ the familiar OpenVMS Debugger interface to observe and manipulate system code interactively as it executes. The system-code debugger can display the source code where the software is executing and allows the user to advance by source line.
Users can perform the following tasks using the system-code debugger:
You can use the OpenVMS Alpha System-Code Debugger to debug code
written in the following languages: C, BLISS, and MACRO. Information
about using the system-code debugger and how it differs from the
OpenVMS Debugger is given in Writing OpenVMS Alpha Device Drivers in C.
188.8.131.52 Special Modes of Operation for Debugging
The OpenVMS operating system has a number of special modes of operation designed to aid in debugging complex hardware and software problems. In general terms, these special modes enable an extra level of tracing, data recording, and consistency checking that is useful in identifying a failing hardware or software component. These modes of operation are controlled by the following system parameters:
MULTIPROCESSING is useful for debugging privileged code that uses spinlocks, such as device driver code. POOLCHECK is useful for investigating frequent and inexplicable failures in a system. When POOLCHECK is enabled, pool-checking routines execute whenever pool is deallocated or allocated. BUGCHECKFATAL is useful for debugging the executive. SYSTEM_CHECK turns on the previous three system parameters and also activates other software that aids in detecting problems. It enables a number of run-time consistency checks on system operation and records some trace information.
If you are using one of these special modes, for example, to debug a device driver or other complex application, under certain conditions generally related to high I/O loads, it is possible to incur a CPUSPINWAIT bugcheck. To prevent a CPUSPINWAIT bugcheck, use either the system default settings for these system parameters, or reduce the loading of the system.
If you have reason to change the default settings, you can reduce the
likelihood of encountering a problem by setting the SMP_LNGSPINWAIT
system parameter to a value of 9000000.
1.5.5 Using Other Program Development Utilities
|Command Definition Utility (CDU)||Enables an application developer to create commands with a syntax similar to DIGITAL Command Language (DCL) commands|
|Message utility||Permits user to create application messages to supplement the OpenVMS system messages|
|Patch utility 1||Permits users to make changes (in the form of patches) to an image or data file. If the change was made to an image, the new version can then be run without recompiling or relinking.|
|SUMSLP utility||Supplies batch-oriented editor used to make several updates to a single source file; one update program can be applied to all versions of a file|
|National character set utility||Permits users to define non-ASCII string collating sequences and to define conversion functions; allows an RMS indexed file to be collated using user-specified collating sequences|
|System Dump Analyzer utility||Determines the cause of system failures; reads the crash dump file and formats and displays it; also used to diagnose root causes that lead to an error|
OpenVMS provides extensive libraries of prewritten and debugged
routines that can be accessed by programs. Libraries specific to the
supported platforms supply commonly needed routines optimized for the
OpenVMS environment; these libraries include run-time library routines,
system services, utility routines, and RMS services. These libraries
are described in this section.
1.6.1 Using the POSIX Threads Library Routines
OpenVMS includes a user-mode, multithreading capability called POSIX Threads Library. POSIX Threads Library provides a POSIX 1003.1-1996 standard style threads interface. Additionally, POSIX Threads Library provides an interface that is the OpenVMS implementation of Distributed Computing Environment (DCE) threads as defined by The Open Group.
POSIX Threads Library is a library of run-time routines that allows the user to create multiple threads of execution within a single address space. With POSIX Threads Library Kernel Threads features enabled, POSIX Threads Library provides for concurrent processing across all CPUs by allowing a multithreaded application to have a thread executing on every CPU (on both symmetric and asymmetric multiprocessor systems). Multithreading allows computation activity to overlap I/O activity. Synchronization elements, such as mutexes and condition variables, are provided to help ensure that shared resources are accessed correctly. For scheduling and prioritizing threads, POSIX Threads Library provides multiple scheduling policies. For debugging multithreaded applications, POSIX Threads Library is supported by the OpenVMS Debugger. POSIX Threads Library also provides Thread Independent Services (TIS), which assist in the development of threadsafe APIs.
On OpenVMS Alpha and OpenVMS I64 systems, POSIX threads provide support to accept 64-bit parameters.
The highly portable POSIX threads interface contains routines grouped in the following functional categories:
For more information about threads, see the Guide to the POSIX Threads Library.
1.6.2 Using OpenVMS Run-Time Library Routines
The OpenVMS Run-Time Library (RTL) is a set of language-independent procedures for programs to be run specifically in the OpenVMS environment. RTL routines establish a common run-time environment for application programs written in any language supported in the OpenVMS common language environment. RTL procedures adhere to the OpenVMS calling standard and can be called from any program or program module in a language supported by OpenVMS (see Section 1.5.2).
The run-time library provides general-purpose functions for application programs. Table 1-5 summarizes the groups of RTL routines.
|LIB$ routines||Library routines that perform generally needed system functions such as resource allocation and common I/O procedures; provide support for 64-bit virtual addressing on Alpha and I64 systems|
|MTH$ routines 1||Math routines that perform arithmetic, algebraic, and trigonometric functions|
|DPML$ routines||Portable Mathematics Library for OpenVMS Alpha and OpenVMS I64; a set of highly accurate mathematical functions|
|OTS$ routines||Language-independent routines that perform tasks such as data conversion|
|SMG$ routines||Screen management routines used in the design of complex images on a video screen|
|STR$ routines||String manipulation routines|
In addition, language-specific RTL routines support procedures in Ada, BASIC, C, COBOL, Fortran, Pascal, and PL/I (VAX only) as well as in POSIX C. HP C RTL routines support 64-bit programming on OpenVMS Alpha and OpenVMS I64 systems.
CXML is a collection of mathematical routines optimized for Alpha
systems. These subroutines perform numerically intensive operations
that occur frequently in engineering and scientific computing, such as
linear algebra and signal processing. CXML can help reduce the cost of
computation, enhance portability, and improve productivity.
1.6.3 Using OpenVMS System Services
OpenVMS system services are procedures that control resources available to processes, provide for communication among processes, and perform basic operating system functions such as I/O coordination. Application programs can call OpenVMS system services to perform the same operations that the system services provide for the OpenVMS operating system (for example, creating a process or subprocess).
At run time, an application program calls a system service and passes control of the process to it. After execution of the system service, the service returns control to the program and also returns a condition value. The program analyzes the condition value, determines the success or failure of the system service call, and alters program execution flow as required.
OpenVMS system services are divided into functional groups, as shown in Table 1-6. System services can be used to protect and fine-tune the security of the OpenVMS environment, handle event flags and system interrupts, designate condition handlers, and provide logical name services and timer services to the application. Other system services control and provide information about processes, manage virtual memory use, and synchronize access to shared resources.
|Security||Provides mechanisms to enhance and control system security|
|Event flag||Clears, sets, and reads event flags; places process in wait state until flags are set|
|AST||Controls handling of software interrupts called asynchronous system traps (ASTs)|
|Logical names||Provide a generalized logical name service|
|Input/output||Performs input and output operations directly at the device driver level, bypassing RMS|
|Process control||Creates, deletes, and controls the execution of processes (on a clusterwide basis); permits a process on one node to request creation of a detached process on another node|
|Process information||Provides information about processes|
|Timer and time conversion||Permits scheduling of program events at specific times or time intervals; supplies binary time values|
|Condition handling||Designates condition-handling procedures that gain control when an exception/condition occurs|
|Memory management||Permits control of an application program's virtual address space|
|Change mode||Changes the access mode of a process|
|Lock management||Permits cooperating processes to synchronize their access to shared resources|
|DECdtm services||Provide for complete and consistent execution of distributed transactions and for data integrity|
|Cluster event notification 1||Requests notification when an OpenVMS Cluster configuration event occurs|
OpenVMS I/O system services perform logical, physical, and virtual I/O and network operations, and queue messages to system processes. The $QIO system service provides a direct interface to the operating system's I/O routines. These services are available from within most programming languages supported by OpenVMS and can be used to perform low-level I/O operations efficiently with a minimal amount of system overhead for time-critical applications.
On OpenVMS Alpha and OpenVMS I64 systems, new system services provide access to 64-bit virtual address space for process private use. Additionally, new system services are available to provide high CPU performance and improved symmetric multiprocessing (SMP) scaling of I/O operations. These services exhibit high-performance gains over the $QIO service.
DECdtm services ensure consistent execution of applications on the
OpenVMS operating system. In transaction processing applications, many
users may be simultaneously making inquiries and updating a database.
The distributed transaction processing environment typically involves
communication between networked systems at different locations.
DECdtm services coordinate distributed transactions by using the
two-phase commit protocol and implementing special logging and
communication techniques. DECdtm services ensure that all parts of a
transaction are completed or the transaction is aborted.
1.6.4 Using OpenVMS Utility Routines
OpenVMS programs can access some OpenVMS utilities through callable interfaces. Utility routines enable programs to invoke the utility, execute utility-specific functions, and exit the utility, returning to the program. Table 1-7 lists the OpenVMS utility routines.
|ACL$||Access control list editor (ACL editor)|
|CLI$||Command Definition Utility (CDU)|
|CONV$||Convert and Convert/Reclaim utilities (CONVERT and CONVERT/RECLAIM)|
|DCX$||Data Compression/Expansion facility (DCX)|
|FDL$||File Definition Language utility (FDL)|
|LBR$||Librarian utility (LIBRARIAN)|
|MAIL$||Mail utility (MAIL)|
|NCS$||National Character Set utility (NCS)|
|PSM$||Print Symbiont Modification facility (PSM)|
|SMB$||Symbiont/Job-Controller Interface facility (SMB)|
|SOR$||Sort/Merge utility (SORT/MERGE)|
|TPU$||DEC Text Processing Utility (DECTPU)|
You can use an optional, portable library of user-callable routines to
perform high-performance sorting on OpenVMS Alpha systems. The
high-performance sort supports a subset of the functionality present on
the OpenVMS Sort/Merge utility, using the callable interface to the
SOR$ routine. The high-performance sort/merge provides better
performance for most sort and merge operations.
1.7 Programming User Interfaces
User interfaces to the OpenVMS VAX, OpenVMS Alpha, and OpenVMS I64 operating systems include the DCL interface and the optional HP DECwindows Motif for OpenVMS graphical user interface. Another user interface is through electronic forms.
You can use DCL commands to invoke program development software (compilers, editors, linkers) and to run and control execution of programs. You can use DCL command procedures to perform repetitious operations in software development.
The Command Definition Utility (CDU) enables application developers to create DCL-level commands with a syntax similar to OpenVMS DCL commands. Using CDU, the developer can create applications with user interfaces similar to those of operating system applications. The Message utility permits an application developer to create application messages to supplement the system messages supplied by the OpenVMS operating system.
The HP DECwindows Motif for OpenVMS software provides a consistent user interface for developing software applications and includes an extensive set of programming libraries and tools. HP DECwindows Motif for OpenVMS supports both the OSF/Motif standards-based graphical user interface and the X user interface (XUI) in a single run-time and development environment. HP DECwindows Motif requires a DECwindows X11 display server (device driver and fonts) that supports the portable compiled format (PCF), permitting use of vendor-independent fonts.
The HP DECwindows Motif for OpenVMS programming libraries provided include: