Introduction of the 64-bit Operating System

HP-UX 11.0 provides maximum computing power with a full 64-bit operating system. Properly coded applications (those using only level 4 or level 5 APIs and not using any obsolete APIs) will generally run unmodified on HP-UX 11.0, providing binary compatibility. HP-UX 11.0 is a superset of HP-UX 10.x, with kernel threads, enhanced system administration tools, and improved system management capabilities. For more information on compatibility, see “Compatibility Statement for HP-UX 11.0” in Chapter 3 of this document.

HP-UX Release 11.0 can run as either a 32-bit or 64-bit operating system on systems that support 64-bit operation, with the exception of the V2200 which only supports 64-bit operation. See “32-bit and 64-bit Kernel Support” for a list of server systems that support 64-bit operation.




	NOTE: In order to use the 64-bit version of HP-UX Release 11.0, you MUST have 64-bit compatible firmware installed on your system.

HP-UX Release 11.0 offers several features to enable the full power of 64-bit computing. Tools are included to transition applications from 32-bit to 64-bit mode. The release:

Provides 64-bit addressing when the 64-bit version of HP-UX is installed on HP 64-bit hardware platforms. This enables programs to take advantage of very large address spaces and larger physical memory limits.
Provides kernel level threads for maximum efficiency of multi-threaded applications.
Complies with the latest NIS+ (Network Information Service) and NFS PV3 standards for more secure network name services and larger network file systems.
Runs in 32-bit mode and/or 64-bit mode, depending on which hardware platform you have.
Supports run-time execution of both 32-bit and 64-bit applications on HP-UX 64-bit platforms.
Supports inter-process communication between 32-bit and 64-bit applications with message queues, pipes, shared memory, and networking protocols.
Provides a cross-platform development environment for developing 32-bit and 64-bit applications.

The following table shows the evolution of recent HP-UX releases:

Table 2-1 Capacities of Recent HP-UX Releases:

Attribute	10.01	10.10	10.20	11.0 (64-bit)
File System	4 GB	128 GB	128 GB	128 GB
File Size	2 GB	2 GB	128 GB local, 2 GB network	128 GB local, 128 GB network
Physical RAM	2 GB	3.75 GB	3.75 GB	4 TB
Shared Memory	1.75 GB	1.75 GB	2.75 GB	8 TB
Process Data Space	.9 GB	1.9 GB	1.9 GB	4 TB
# File Descriptors	2 K	60 K	60 K	60 K
# of User Ids	60 K	60 K	~2,000 K	~2,000 K

Benefits of 64-bit Applications

Some applications need to transition to 64-bit mode because they are limited by the 32-bit address space. Examples include:

database management systems
engineering and mechanical design automation systems
simulation and modeling programs
decision support applications

The advantage of transitioning 32-bit applications to 64-bit applications include:

Large file caches are allowed on systems with large amounts of physical memory.
Database servers have improved performance when they can load significant portions of the database into memory.
Large process data space is mapped in a large virtual address space.
Simulation programs are able to map the entire simulation model into virtual memory.
Large file support uses standard system library calls.
Databases can contain data sets larger than 2 GB. It is simpler to store this information for a large data set in a single file.
64-bit applications can use standard I/O routines to access files larger than 2 GB.

HP-UX Compilers

The following HP compiler products support both 64-bit and 32-bit program development:

HP C
HP aC++
HP Assembler
HP DDE (debugger bundled with compilers)
HP PAK (performance toolkit bundled with compilers)
HP Linker toolset (bundled with the operating system)

The following HP compiler products do not support 64-bit program development, but are available for 32-bit program development:

HP Fortran 77 and Fortran 90
HP Pascal
HP MicroFocus COBOL

Transition Tools

There are several tools that can help transition your application from previous releases of HP-UX:

HP-UX Software Transition Kit (STK)
The STK provides a complete solution that enables the HP-UX application developer to easily transition software from HP-UX 10.x to either the 32-bit or the 64-bit version of HP-UX 11.0. In most cases, you will not need to make source changes to run your software on HP-UX 11.0. The HP-UX STK helps you answer high-level planning questions such as:
- What new features does HP-UX 11.0 offer and how can I take advantage of them?
- Do I want a 32-bit or 64-bit version of my application?
- Can I run my application on HP-UX 11.0 without making any changes to it, or should I port it?
The STK provides complete process descriptions for planning and performing the transition. It contains easy-to-follow instructions, a set of background documents, and tools to help you identify and resolve any required API changes in your C or C++ source code. These tools are known as scansummary and scandetail. scansummary summarizes the number and type of API transition problems in your source files, and is useful for planning; scandetail lists each instance of API problems by source file name and line number and is useful for making source code changes.
If you use these types of source files:
- C programs
- C++ programs
- scripts
- makefiles
the HP-UX STK tools help you locate and fix any changed or obsolete:
- functions
- commands
- macros
- structures and structure members
- header files
- language keywords
- libraries
- variables
The HP-UX STK tools also identify opportunities for using enhanced features of HP-UX 11.0. In addition to these tools, the HP-UX STK explains how to use the compiler and lint to identify and fix other 64-bit transition issues such as data model changes (for example not assigning longs to ints).
The Software Transition Kit is not a standard part of HP-UX but is available on the HP-UX 11.0 Application Release CD-ROM, or via the World Wide Web at http://www.software.hp.com/products/IA64/index.html
HP-UX Script Scanner
A new tool, /usr/sbin/scanscript, is available to help you locate and fix any changed or obsolete functionality in installation or shell scripts. scanscript can help you determine if your scripts contain any commands, paths, libraries, or variables that must be changed. For more information, see the scanscript(1M) man page.

HP C/HP-UX

Release A.11.00 of the HP C/HP-UX compiler product includes support for both the 32-bit data model and the new 64-bit data model. New compile-line options, new pragmas and macros, and a new object file format support the 64-bit mode. Changes to the online and hardcopy documentation describe the new features.

The default compilation mode has not changed; it remains 32-bits. The default target architecture is determined by the host machine and the system file /usr/lib/sched.models.

In 64-bit mode, the long and pointer data types are 64-bits long. In 32-bit mode, the long and pointer data types are the same size as the int data type.

The term used to specify the 64-bit mode in which the long and pointer types are 64-bits is LP64, and the term for 32-bit mode in which the int, long and pointer types are 32-bits is called ILP32.

New or Changed Options

-dynamic--Lets you tell the linker that position-independent code (PIC) objects are being linked, causing the creation of a dynamically-bound executable. This option is available in 64-bit mode only and is the default in that mode.
-noshared--Lets you tell the linker that the program you are building does not use shared libraries. This overrides the LP64 default option, -dynamic. This option is available in 64-bit mode only.
+DA2.0 or +DA2.0N--Equivalent options which allow you to compile in 32-bit mode (narrow mode) for the PA-RISC 2.0 architecture.
+DD32--This option allows you to compile in 32-bit mode (narrow mode) for the PA-RISC 1.1 architecture. This option is equivalent to +DAportable.
+DA2.0W--Allows you to compile in 64-bit mode (wide mode) specific for the PA-RISC 2.0 architecture.
+DCapptype--This option is provided for optimizing portable or embedded applications. Specify +DCemb to enable the code-generation options most often used to optimize code for embedded applications. This option is available in 64-bit mode only.
+M1--Turns on migration warnings regarding possible conflicts with future architectures.
+M2--Turns on LP64 data model migration warnings. This option is available in 64-bit mode only.
Advanced optimization options -- Options +Omultiprocessor and +Oextern have been added to optimize code for processor configuration and external symbol usage, respectively.

New Preprocessor Macros

__LP64__--Defined by compiler in 64-bit mode.
_PA_RISC2_0--Defined when compiling for PA2.0 in 32- or 64-bit modes.

New Features

The compiler now generates standard SVR4 ELF object module format in 64-bit mode.

New Pragmas

PACK-like HP_ALIGN, but more intuitive. Allows user to set the alignment of structs and unions along n-byte boundaries.
INIT, FINI-pragmas for program initialization and termination.
The Fast Libcall Pragmas:
- HP_DEFINED_EXTERNAL (32-bit only)
- HP_LONG_RETURN
- HP_NO_RELOCATION

New Libraries and Loader

64-bit libraries:

/opt/langtools/lib/pa20_64/libl.a 
/opt/langtools/lib/pa20_64/liby.a

64-bit dynamic loader:
/usr/lib/pa20_64/dld.sl

New libraries for threads:

/opt/langtools/lib/libl_thread.a
/opt/langtools/lib/pa20_64/libl_thread.a

New Defaults

The compiler option +Z is the default in 64-bit mode (position independent code, or "PIC", is generated). The default in 32-bit mode remains non-PIC.

For more information on the HP C/HP-UX 11.0 release and documentation see the HP C/HP-UX Release Notes included with the HP C/HP-UX product in the text file /opt/ansic/newconfig/RelNotes/ansic.11.00.

strtold(3C)

strtold(3C) is being deprecated and may be replaced in a future release by an API of the same name but with a different return type (the deprecated strtold returns long_double (which is an array of four unsigned 32-bit ints); the future strtold, if implemented, will return an ANSI C long double (which is a 128-bit floating point scalar).

New applications should avoid using strtold whenever possible. If ANSI C applications must use strtold, they should convert the returned long_double to a long double as described below (see the "Alternatives" section below).

Alternatives

Applications that need to convert a long_double returned by strtold into an ANSI C long double should either use memcpy or use the C union type. Here is a code excerpt showing how to do the conversion with a union:

union { 
               long_double l_d; 
               long double ld; 
       } u; 
/* convert str to a long_double; store return val in union */ 
/* (Putting value into union enables converted value to be */ 
/* accessed as an ANSI C long double)*/ 
u.l_d = strtold( (const char *)str, (char **)NULL);




	WARNING! Applications must not cast a long_double * to a long double *. They are aligned on different boundaries, and the cast may cause a processor fault (bus error).

Cross-Platform Development

HP-UX 11.0 provides a cross-platform development environment. You can compile and link both 32-bit and 64-bit applications on HP-UX 11.0 32-bit systems. Also, you can compile and link both 32-bit and 64-bit applications on HP-UX 11.0 64-bit systems.

You can optionally install 64-bit versions of HP-UX 11.0 system libraries on HP-UX 11.0 32-bit systems for cross-development. The 64-bit system libraries are in separate directories from the 32-bit system libraries.

Linking 32-bit and 64-bit object files (.o, .sl, .a) together is not supported. All modules in a program must be linked from either 32-bit objects or 64-bit objects.

You will need access to a 64-bit hardware platform running the 64-bit version of HP-UX 11.0 to test 64-bit programs.

Please note the following cross-platform limitations:

Debugging and program dump analysis tools for 64-bit programs are only supported on 64-bit HP-UX.
Kernel cross-platform development is not supported; you can not build a 64-bit kernel on 32-bit HP-UX, nor can you build a 32-bit kernel on 64-bit HP-UX.
If the device driver refers to kernel header files and libraries, development must be done on the same platform as the target run-time platform. That is, 64-bit kernel headers and libraries are not installed on the 32-bit HP-UX, nor are 32-bit kernel headers and libraries installed on 64-bit HP-UX.
The cross platform development environment supports only 32-bit and 64-bit cross-platform development environment on the same HP-UX release.

Compiler Options for Cross Development

Unless specified, HP compilers generate object files that are compatible with the hardware on which you are compiling.

HP-UX 64-bit platforms use the PA-RISC 2.0 system architecture. The default compilation mode for these systems is 32-bit narrow mode for PA-RISC 2.0. PA-RISC 2.0 narrow mode programs only run on PA-RISC 2.0 systems. The compiler command line option for this mode is +DA2.0 or +DA2.0N.(+DA means destination architecture; N stands for narrow mode.)

HP compilers generate 64-bit code when you specify the +DA2.0W command-line option. This is known as PA-RISC 2.0 wide mode; W stands for wide mode. PA-RISC 2.0 wide mode programs only run on PA-RISC 2.0 systems running the 64-bit version of HP-UX. (For more detail, see the HP-UX 64-bit Porting and Transition Guide which ships with HP C and HP aC++ as an online PostScript file; within HP C, the PostScript file is /opt/ansic/newconfig/RelNotes/64bitTrans.bk.ps; within HP aC++, the PostScript file is /opt/aCC/newconfig/TechDocs/64bitTrans.bk.ps. It is also available on the HP-UX 11.0 Instant Information CD-ROM and on the http://docs.hp.com web site.)

Compatibility with Previous Releases

HP-UX 11.0 is binary compatible with HP-UX 10.x. Fully bound shared or archived applications that work on any HP-UX 10.x release continue to work on this release without recompiling, relinking, or modifying the application. A fully bound shared application consists of an executable program and all of its related user shared libraries.

For more information on compatibility see Chapter 3 “Compatibility”

HP-UX Developer's Kit for Java(tm) and the HP-UX Virtual Machines (with JIT)

The HP-UX Virtual Machines with JIT for Java(tm) and the HP-UX Developer's Kit for Java (JDK) release 1.1.2 for HP-UX 11.0 provide the solutions necessary to develop or deploy performance-enhanced Java applications on HP 9000 Enterprise Servers, HP 9000 workstations, and HP Visualize Workstations.

Release 1.1.2 for HP-UX 11.0 includes the addition of a second virtual machine which permits you to use kernel threads to implement Java threads thus allowing a single Java application to make use of additional processors in a multiprocessor machine. This new virtual machine is the default virtual machine. The other virtual machine does not make use of kernel-threads to implement Java threads--it uses a portable, user-level "green threads" package.

You have the option of using either virtual machine, and may want to try both to see which provides the best performance for your application.

Release 1.1.2 for both the 100% Java compatible HP-UX Virtual Machines with JIT for Java and HP-UX Developer's Kit for Java also continues to provide a comprehensive and rich set of API library packages:

Reflection provides a type-safe and secure means to discover and access the fields and methods of Java objects at runtime, including new services such as JavaBeans and object scripting, and tools such as inspectors, browsers and debuggers.
Abstract Window Toolkit -- includes APIs for printing, faster scrolling, popup menus, imaging, graphics, and flexible font support.
Basic graphical user interface (GUI) components such as windows, buttons, text field, and menu choices provide a standard and extensible base for creating GUI-based applications. This release also includes new popup menu and scrollplane classes.
A lightweight user interface (UI) framework allows Java programs to directly extend components and containers.
Graphics image handling features in Release 1.1.2 give improved and faster image cropping, scaling, and rendering.
Users can activate Java programs with menu functions by keyboard shortcuts.
New printing capabilities allow users to easily print all screen graphics.
Security Package-- provides for digital signatures, certificate and key management and access control.
Java Cryptography Architecture is a flexible API which includes digital signatures and message digests. This architecture provides cross-provider interoperability, and supports algorithm independence and widely used algorithms such as DSA, SHA and MD5.
The java.security APIs provide a standard set of algorithm- specific interfaces, access control, secure hash functions, and 100% Java implementation of DSA, MD5 and SHA.
The Security Utilities provide a number of security functions such as code-signing facilities for x.509 certificate parsing and generation, certificate requests, and private key encoding according to Public Key Cryptography Standards.
Internationalization Support -- enables development of localizable applications.
This release enables developers to create multilingual programs easily and to format output and parse common data types for specific user-selected locales.
Remote Method Invocation (RMI) -- permits Java to Java communication.
The Java to Java Object Distribution feature enables an object in one Java Virtual Machine (VM) to seamlessly invoke methods on objects in a remote VM.
RMI supports communication among applets and applications over the internet by using the HTTP protocol.
Distributed Polymorphism is an extension to object polymorphism. RMI sanctions this over distributed applications.
Java Database Connectivity(tm) (JDBC) -- provides SQL database access.
The JDBC API provides database independent connectivity between a Java application and a wide range of databases. ODBC bridge drivers from your vendor of choice provide access to most popular databases.
JavaBeans(tm) -- gives end users a model with which to turn software components from one or more parties into applications.
The JavaBeans APIs enable developers to write re-usable components. JavaBeans developers will have a seamless and powerful means to run their applications in COM/ActiveX, OpenDoc, and Netscape's LiveConnect(tm).
Java Native Interface (JNI) -- allows Java to call other language libraries.
The Java Native Interface is a standard native method interface that allows Java to call up native libraries written in C, C++, assembly, or other languages. JNI offers a VM-independent programming interface to native programs that enables developers to write a single native method library version that will be binary compatible with all Java VMs on a given platform.
The Invocation Interface API allows software vendors to load the VM into arbitrary native applications, and therefore, integrate Java-based applications or functionality into their applications.
Native methods usage information and examples for the HP platform are available on the JDK software. The documentation installs in /opt/java/docs/hpux. Any updates will be published via our URL http://www.hp.com/esy/go/java.html.
Networking Package -- provides basic support for managing connections.
The URL and Socket Connections feature provides the basic support for managing connections using UDP or TCP sockets. It also provides the basic support for managing IP addresses and Web URLs.
New Socket options such as TCP_NODELAY and SO_TIMEOUT provide greater control over socket connections.
New Extendible Socket and ServerSocket classes enable custom functions such as compression and encryption.
I/O Package -- supports 16-bit Unicode characters.
The Basic Byte-Stream I/O classes provide basic facilities for file I/O, buffering, pipes, filtering, and reading and writing binary data in a portable format.
The Character-Stream I/O package allows developers to use 16-bit Unicode characters to make it easy to internationalize programs.
Object Serialization converts Java objects into a stream of bytes that can be saved, stored, transmitted, and later used to create objects.
Other APIs -- provide useful functions:
The java.lang core language classes such as String, Thread, Math, and class wrappers for primitive data types extend the functionality of Java providing, for example, control over strings, math operations and multi-threading.
Runtime classes such as ClassLoader, SecurityManager, and Runtime provide access to the VM so developers can customize runtime behavior.
The text manipulation package java.text provides support for text formatting, input, and manipulation.
Core Utility Classes include data structures which are useful in typical Java applications: a hash table, a class to manipulate dates, and a random number generator, for example.
java.util.zip provides zip archival and retrieval support.

For reference, the Java sources for the API classes are in the /opt/java/src directory.

In addition to the rich set of APIs, release 1.1.2 also improves application performance by reducing call overhead for synchronized methods, improves garbage collection, and includes the JAR (Java ARchive) platform independent file format. The JAR format enables fast downloads and allows entries to be digitally signed to authenticate origin.

For more information, see the release notes included with the Java product or check our web page at http://www.hp.com/esy/go/java.html.