New in SmartHeap 5.0

Reduced space overhead

SmartHeap 5.0 significantly reduces per-block overhead in its UNIX implementations, from 5 bytes to zero bytes for blocks less than 256 bytes in size (and from 9 bytes to zero bytes in 64-bit implementations).Ê Granularity has also been reduced from 8 bytes to 4 bytes.Ê For example, whereas a 12-byte allocation would have consumed 24 bytes in SmartHeap 4.0 (12 + 5 rounded up to the next 8-byte multiple), the same 12-byte allocation uses only 12 bytes in SmartHeap 5.0.

Moreover, because SmartHeap 5.0 no longer creates multiple default memory pools for multi-threaded applications, space saving is even greater because multiple threads are able to share the same pages of heap memory in a contention-free manner rather than using separate memory pools.

New small-block allocator

An improved small-block allocator incurs zero bytes per allocation of overhead and recycles space more effectively between block sizes than the SmartHeap 3.x/4.x small-block allocator.Ê If you want to use the old small-block allocator for some reason, you may use MemPoolSetSmallBlockAllocator to change the small-block allocator for a given memory pool.Ê Use MemPoolSetSmallBlockAllocator(MemDefaultPool, MEM_SMALL_BLOCK_SH3) to use the SH 3.0/4.0 small-block allocator.Ê Specify the value MEM_SMALL_BLOCK_SH5 for the new small-block allocator.

New API to control process heap growth

SmartHeap 5.0 introduces a new API, MemProcessSetGrowIncrement, that allows you to control how much memory SmartHeap requests from the operating system when a memory pool needs to grow. The memory returned is retained in SmartHeap's free pool and is allocated to any memory pool(s) that subsequently need to grow.Ê By buffering operating system heap requests, SmartHeap 5.0 incurs less system call overhead, less operating system heap and address space fragmentation, and less operating system heap contention.

The default process grow increment is 2MB.Ê The value you specify to MemProcessSetGrowIncrement is in bytes and is rounded up to the next 64K.

Installing SmartHeap

The files on the SmartHeap installation media are not copy protected.Ê To install SmartHeap on your hard disk:

1. Identify the directory you want to install SmartHeap in, create that directory (if necessary) and cd to it.

For example, if you want to install SmartHeap in /opt/sh, enter the following commands:

mkdir /opt/sh

cd /opt/sh

2. Insert the SmartHeap media into your installation device and copy the SmartHeap archive files with the following command:

tar xpvf device_name

where device_name is the name of your installation device (for example, /dev/fd0).

3. Uncompress the SmartHeap files with the following command:

uncompress *.Z

4. Unarchive each file that ends with the .tar extension as follows:

tar xpvf filename.tar

5. Add the SmartHeap include directory to your compilerâs header file search path, and add the SmartHeap lib directory to your linkerâs library search path.

Files in the HP-UX SmartHeap release

This HP-UX 11 (32-bit and 64-bit) builds support the HP-UX pthreads.Ê

This release includes statically linkable and shared libraries, platform-independent header files, and platform-independent source files for the malloc and C++ operator new definitions.Ê Both single- and multi-thread SmartHeap libraries are included.

The following files are present in this SmartHeap distribution:

DirectoryÊÊÊÊÊÊ FileÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Description

includeÊÊÊ smrtheap.hÊÊÊÊÊÊÊÊÊÊ Header file containing all Runtime SmartHeap C declarations except malloc

includeÊÊÊ smrtheap.hppÊÊÊÊÊÊÊÊ Header file containing Runtime SmartHeap C++ declarations

includeÊÊÊ shmalloc.hÊÊÊÊÊÊÊÊÊÊ Header file containing declarations for Runtime SmartHeap ANSI C functions

libÊÊÊÊÊÊÊ libsmartheap.aÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 32-bit single-thread Runtime SmartHeap C HP archive library

libÊÊÊÊÊÊÊ libsmartheapC.aÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 32-bit single-thread Runtime SmartHeap C++ HP archive library

libÊÊÊÊÊÊÊ libsmartheap.slÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 32-bit single-thread Runtime SmartHeap C HP shared library

libÊÊÊÊÊÊÊ libsmartheapd.aÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 32-bit single-thread Debug SmartHeap C HP archive library

libÊÊÊÊÊÊÊ libsmartheapCd.aÊÊÊÊÊÊÊÊÊÊÊÊ 32-bit single-thread Debug SmartHeap C++ HP archive library

libÊÊÊÊÊÊÊ libsmartheapd.slÊÊÊÊÊÊÊÊÊÊÊÊ 32-bit single-thread Debug SmartHeap C HP shared library

libÊÊÊÊÊÊÊ libsmartheap_mt.aÊÊÊÊÊÊÊÊÊÊ 32-bit multi-thread Runtime SmartHeap C HP archive library

libÊÊÊÊÊÊÊ libsmartheapC_mt.aÊÊÊÊÊÊÊ 32-bit multi-thread Runtime SmartHeap HP C++ archive library

DirectoryÊÊÊÊÊÊ FileÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Description

libÊÊÊÊÊÊÊ libsmartheap_mt.slÊÊÊÊÊÊÊÊÊÊÊ 32-bit multi-thread Runtime SmartHeap C HP shared library

libÊÊÊÊÊÊÊ libsmartheap_mtd.aÊÊÊÊÊÊÊÊÊÊÊ 32-bit multi-thread Debug SmartHeap HP C archive library

libÊÊÊÊÊÊÊ libsmartheapC_mtd.aÊÊÊÊÊÊÊÊ 32-bit multi-thread Debug SmartHeap C++ HP archive library

libÊÊÊÊÊÊÊ libsmartheap_mtd.slÊÊÊÊÊÊÊÊ 32-bit multi-thread Debug SmartHeap HP C shared library

libÊÊÊÊÊÊÊ libsmartheap64.aÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 64-bit single-thread Runtime SmartHeap C HP archive library

libÊÊÊÊÊÊÊ libsmartheapC64.aÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 64-bit single-thread Runtime SmartHeap C++ HP archive library

libÊÊÊÊÊÊÊ libsmartheap64.slÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 64-bit single-thread Runtime SmartHeap C HP shared library

libÊÊÊÊÊÊÊ libsmartheapd64.aÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 64-bit single-thread Debug SmartHeap C HP archive library

libÊÊÊÊÊÊÊ libsmartheapCd64.aÊÊÊÊÊÊÊÊÊÊÊ 64-bit single-thread Debug SmartHeap C++ HP archive library

libÊÊÊÊÊÊÊ libsmartheapd64.slÊÊÊÊÊÊÊÊÊÊÊ 64-bit single-thread Debug SmartHeap C HP shared library

libÊÊÊÊÊÊÊ libsmartheap_mt64.aÊÊÊÊÊÊÊÊ 64-bit multi-thread Runtime SmartHeap C HP archive library

libÊÊÊÊÊÊÊ libsmartheapC_mt64.aÊÊÊÊÊÊ 64-bit multi-thread Runtime SmartHeap HP C++ archive library

libÊÊÊÊÊÊÊ libsmartheap_mt64.slÊÊÊÊÊÊ 64-bit multi-thread Runtime SmartHeap C HP shared library

libÊÊÊÊÊÊÊ libsmartheap_mtd64.aÊÊÊÊÊÊ 64-bit multi-thread Debug SmartHeap HP C archive library

libÊÊÊÊÊÊÊ libsmartheapC_mtd64.aÊÊÊ 64-bit multi-thread Debug SmartHeap C++ HP archive library

libÊÊÊÊÊÊÊ libsmartheap_mtd64.slÊÊÊ 64-bit multi-thread Debug SmartHeap HP C shared library

Using SmartHeap with HP-UX

Hereâs how to get started with SmartHeap on HP-UX.

Getting started with the SmartHeap runtime library

Hereâs how you set up your application to use the SmartHeap runtime library.Ê For information on debugging your application with Debug SmartHeap, see ãDebugging an application with SmartHeap,ä later in this section.

Adding the SmartHeap header file to your source files

Important!Ê If youâre not calling SmartHeap APIs, skip to the next page.Ê You donât need to add SmartHeap header files if you simply want SmartHeap to replace malloc and operator new.Ê

For each file that makes SmartHeap API calls:

¬ For C source files, include smrtheap.h, which contains declarations for the C SmartHeap APIs.

ÊÊÊÊÊÊ #include <smrtheap.h>

¬ For C++ source files, include smrtheap.hpp, which contains declarations for SmartHeap versions of operator new and which itself includes smrtheap.h.

ÊÊÊÊÊÊ #include <smrtheap.hpp>

In both cases, the #include directive must appear after any compiler or library header files that declare malloc (for example, stdlib.h) or new (for example, new.h).

Specifying the location of SmartHeap files

To tell your compiler where to find SmartHeap include and library files:

1. Add the SmartHeap include directory to your compilerâs include path, or specify this directory on the compiler command line, for example:

-I/opt/sh/include

2. Add the SmartHeap lib directory to your linkerâs library path, or specify this directory on the linker command line, for example:

-L/opt/sh/lib

Calling MemRegisterTask

If your application is multi-threaded and targets HP-UX 11, you must add a call to MemRegisterTask()before your application creates its second thread.

Caution!Ê In HP-UX 11, SmartHeap does not initialize its heap mutexes until you call MemRegisterTask.Ê Therefore, if your program does not call MemRegisterTask before creating its second thread, memory allocation calls will not be serialized, which will almost certainly result in heap corruption.Ê

Linking with Runtime SmartHeap

To relink your application with Runtime SmartHeap:

1. Add the Runtime SmartHeap Library, after all object files, but before any other libraries, to your linker command line.

If youâre using the SmartHeap
shared library withÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Link with these libraries

A 32-bit single-threaded C applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheap.sl

A single-threaded C++ applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheap.sl,
libsmartheapC.a

A 32-bit multi-threaded C applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheap_mt.sl

A 32-bit multi-threaded C++ applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheap_mt.sl,
ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheapC_mt.a

A 64-bit single-threaded C applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheap64.sl

A 64-bit single-threaded C++ applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheap64.sl,
libsmartheapC64.a

A 64-bit multi-threaded C applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheap_mt64.sl

A 64-bit multi-threaded C++ applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheap_mt64.sl,
ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheapC_mt64.a

If youâre statically linking SmartHeap withÊÊÊÊÊÊÊÊ Link with these libraries

A 32-bit single-threaded C applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheap.a

A 32-bit single-threaded C++ applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheap.a,
ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ LibsmartheapC.a

A 32-bit multi-threaded C applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheap_mt.a

A 32-bit multi-threaded C++ applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheap_mt.a,
libsmartheapC_mt.a

A 64-bit single-threaded C applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheap64.a

A 64-bit single-threaded C++ applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheap64.a,
ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ LibsmartheapC64.a

A 64-bit multi-threaded C applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheap_mt64.a

A 64-bit multi-threaded C++ applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheap_mt64.a,
libsmartheapC_mt64.a

2. Run your make file to relink your application, for example:

make /f myapp.mak

Debugging an application with SmartHeap

Hereâs how you set up your application for debugging with Debug SmartHeap.Ê

Adding the Debug SmartHeap header file to your source files

If you want to call Debug SmartHeap APIs (dbgMemXXX), youâll need to include the Debug SmartHeap header file and recompile your application.Ê

NoteÊ Simply linking with the Debug SmartHeap Library is sufficient to allow SmartHeap to perform full error detection, but in most cases youâll also want to recompile your application so that SmartHeap includes source file names and line numbers in its error reports.

For each file from which you call Debug SmartHeap APIs:

¬ Include heapagnt.h, which contains declarations of memory-allocation functions both for ANSI C (malloc, free, and so on) and for C++ (including the new and delete operators).Ê The #include directive must appear after any compiler or library header files that declare malloc (for example, stdlib.h) or new (for example, new.h):

ÊÊÊÊÊÊ #include <heapagnt.h>

NoteÊ If you already include smrtheap.h, shmalloc.h, or smrtheap.hpp, then you donât need to also include heapagnt.h.Ê The Runtime SmartHeap header files automatically include heapagnt.h when MEM_DEBUG is defined.

Specifying the location of SmartHeap files

To tell your compiler where to find Debug SmartHeap include and library files:

1. Add the SmartHeap include directory to your compilerâs include path, or specify this directory on the compiler command line, for example:

-I/opt/sh/include

2. Add the SmartHeap lib directory to your linkerâs library path, or specify this directory on the linker command line, for example:

-L/opt/sh/lib

Calling MemRegisterTask

If your application is multi-threaded and targets HP-UX 11, you must add a call to MemRegisterTask()before your application creates its second thread.

Recompiling with Debug SmartHeap

To recompile and relink your application with Debug SmartHeap:

1. Add the following options to your compiler command line:

-DMEM_DEBUG=1 -DDEFINE_NEW_MACRO=1

2. Add the Debug SmartHeap Library, before any other libraries, to your linker command line.

If youâre using the SmartHeap
shared library withÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ Link with these libraries

A 32-bit single-threaded C applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheapd.sl

A 32-bit single-threaded C++ applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheapd.sl,
LibsmartheapCd.a

A 32-bit multi-threaded C applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheap_mtd.sl

A 32-bit multi-threaded C++ applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheap_mtd.sl,
LibsmartheapC_mtd.a

A 64-bit single-threaded C applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheapd64.sl

A 64-bit single-threaded C++ applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheapd64.sl,
LibsmartheapCd64.a

A 64-bit multi-threaded C applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheap_mtd64.sl

A 64-bit multi-threaded C++ applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheap_mtd64.sl,
LibsmartheapC_mtd64.a

If youâre statically linking SmartHeap withÊÊÊÊÊÊÊÊ Link with these libraries

A 32-bit single-threaded C applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheapd.a

A 32-bit single-threaded C++ applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheapd.a,
LibsmartheapCd.a

A 32-bit multi-threaded C applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheap_mtd.a

A 32-bit multi-threaded C++ applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheap_mtd.a,
LibsmartheapC_mtd.a

A 64-bit single-threaded C applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheapd64.a

A 64-bit single-threaded C++ applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheapd64.a,
LibsmartheapCd64.a

A 64-bit multi-threaded C applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheap_mtd64.a

A 64-bit multi-threaded C++ applicationÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ libsmartheap_mtd64.a,
LibsmartheapC_mtd64.a

These files are in the lib subdirectory under the directory where you installed SmartHeap.

3. Run your make file to rebuild your application, for example:

make /f myapp.mak

SmartHeap HP-UX platform notes

Compiler functions that SmartHeap overrides

SmartHeap overrides malloc, calloc, realloc, free, new, and delete on all platforms, as explained in ¤2.3.2, ¤2.3.3, and ¤2.3.4 in the SmartHeap Programmerâs Guide.

If you donât want SmartHeap to override one or more of these functions, you should remove the applicable object module from the SmartHeap libraries.Ê For example, use the following command to prevent SmartHeap from overriding malloc with the statically linked non-debug single-thread SmartHeap library:

ar d libsmartheap.a shmalloc.o

If you remove the shmalloc.o object module from a SmartHeap library, youâll need to define SmartHeap_malloc at file scope.Ê For example:

int SmartHeap_malloc = 0;

Multi-threading in HP-UX

The libsmartheap_mt* SmartHeap libraries are fully thread-reentrant (MT-safe).Ê If you link SmartHeap with an application that creates multiple threads, make sure to call MemRegisterTask before starting the second thread.Ê

For the HP-UX thread-reentrant libraries, the default memory pool (used by malloc and new) is always serialized after the MemRegisterTask call, unless you define MemDefaultPoolFlags to disable serialization.Ê Memory pools you create with MemPoolInit[FS] are not serialized unless you supply eitherÊ MEM_POOL_DEFAULT or MEM_POOL_SERIALIZE with the flags parameter.

If you use a given memory pool in only one thread at any time, do not supply MEM_POOL_DEFAULT or MEM_POOL_SERIALIZE when initializing the memory pool, or performance will suffer needlessly.Ê

Using shared memory in SmartHeap for HP-UX

Beginning in version 3.0, SmartHeap supports UNIX shared memory. SmartHeap uses the shared memory and semaphore facilities of the standard InterProcess Communication (IPC) package to implement shared memory pools.

Use MemPoolInitNamedShared to create shared memory pools.Ê The name parameter to MemPoolInitNamedShared must be a valid shared memory object key, according to UNIX conventions.Ê Use ftok() to create a key, and cast the result to (const char *) when passing to MemPoolInitNamedShared.Ê The flags parameter implicitly includes MEM_POOL_SHARED and MEM_POOL_SERIALIZE, so you do not need to specify these two flags.

The size parameter to MemPoolInitNamedShared specifies the total size of the underlying UNIX shared memory segment.Ê This cannot be resized once the memory pool is created.Ê Specify the total amount of memory you wish to make available to the memory pool.

When determining the pool size, keep in mind that each memory pool requires 4K of space for internal data structures and that free space occupies, on average, one third of the total space in a memory pool.Ê Therefore, if X is the maximum number of bytes you will allocate, specify a pool size of at least X * 2 + 4K.Ê You can use the MemPoolSize function to determine the actual memory in use in a pool, and use this as a guideline for the size parameter.Ê Note that Debug SmartHeap uses more memory than Runtime SmartHeap to store debugging state.

Shared memory pools are always serialized with inter-process synchronization mutual exclusion.Ê You can concurrently allocate blocks from a shared pool from multiple processes with complete safety.

Once a shared memory pool has been created, you can access it from other processes by calling MemPoolAttachShared and specifying the shared pool name.Ê Always pass NULL as the pool parameter for UNIX.

The MemPoolInitNamedShared call must have returned in the original process before MemPoolAttachShared will succeed in another process.Ê The reason for this restriction is that the semaphore that provides for serialization is stored in the shared memory object ÷ there can be no guarantee that the semaphore has been initialized and stored in the shared memory object until the shared memory object itself has been initialized.

You can call MemPoolAttachShared concurrently from as many processesÊ as you like once MemPoolInitNamedShared has returned.

You can use all of the SmartHeap allocation and de-allocation APIs with shared memory pools.Ê In Debug SmartHeap, shared memory pools fully support all of the same debugging facilities as private memory pools.

If SmartHeap detects an error such an overwrite in a shared pool, the error is reported to the process in which the error is detected, regardless of where the shared memory pool was created.

In Debug SmartHeap, when you compile your source files with MEM_DEBUG, SmartHeap stores a pointer to the source file name in each allocated memory block.Ê The actual file name is a string constant, generated by the compiler, that exists only in the current process.Ê For shared memory pools, SmartHeap copies file name strings into space owned by the shared memory pool, so the file names are accessible from all processes that attach to the pool.Ê Only the first 19 characters of file names are stored, so if you allocate shared memory from source files having longer names, the file names reported in memory error reports will be truncated to the first 19 characters.

To end access to a shared pool from a given process, call MemPoolFree from that process.Ê The shared pool will continue to exist until every process that has access to it calls MemPoolFree.Ê The process that creates a shared pool does not need to be the last process to call MemPoolFree; the shared pool is not owned by a particular process.

Creating heaps in user-supplied regions

The SmartHeap API MemPoolInitRegion is now supported in HP and other UNIX platforms in SmartHeap 5.0 and higher. MemPoolInitRegion allows you to create a memory pool within a region of memory you supply.

For details about this API, see the entry for MemPoolInitRegion in ¤4.2, ãFunction reference,ä in the SmartHeap Programmerâs Guide.

SmartHeap HP-UX-specific values

The following are some platform-specific defaults and attributes for this version of SmartHeap (all values in bytes, non-debug version of SmartHeap; all values subject to change in future versions):

DescriptionÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 32bitÊ 64bitÊÊÊÊ Related API

Default page sizeÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 64KÊÊÊÊÊÊ 64KÊÊÊÊÊÊ MemPoolSetPageSize

Default fixed-size block sizeÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 20ÊÊÊÊÊÊÊÊÊ 40ÊÊÊÊÊÊÊÊÊ MemPoolSetBlockSizeFS

Per-alloc overhead, FS blocksÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 0ÊÊÊÊÊÊÊÊÊÊÊ 0ÊÊÊÊÊÊÊÊÊÊÊ MemAllocFS

Per-alloc overhead, blocks < 256 bytesÊÊÊÊÊÊÊ 0ÊÊÊÊÊÊÊÊÊÊÊ 0ÊÊÊÊÊÊÊÊÊÊÊ MemAllocPtr, malloc, new

Per-alloc overhead, var ptr blocksÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 4ÊÊÊÊÊÊÊÊÊÊÊ 8ÊÊÊÊÊÊÊÊÊÊÊ MemAllocPtr, malloc, new

Per-alloc overhead, var handle blocksÊÊÊÊÊÊÊÊÊ 16ÊÊÊÊÊÊÊÊÊ 32ÊÊÊÊÊÊÊÊÊ MemAlloc

Granularity, FS blocksÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 8ÊÊÊÊÊÊÊÊÊÊÊ 8ÊÊÊÊÊÊÊÊÊÊÊ MemAllocFS

Granularity, blocks < 256 bytesÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 4ÊÊÊÊÊÊÊÊÊÊÊ 8ÊÊÊÊÊÊÊÊÊÊÊ MemAllocPtr, malloc, new

Granularity, all othersÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 8ÊÊÊÊÊÊÊÊÊÊÊ 8ÊÊÊÊÊÊÊÊÊÊÊ MemAllocPtr, MemAlloc

Minimum block size, FS blocksÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 8ÊÊÊÊÊÊÊÊÊÊÊ 8ÊÊÊÊÊÊÊÊÊÊÊ MemAllocFS

Minimum block size, all othersÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 4ÊÊÊÊÊÊÊÊÊÊÊ 8ÊÊÊÊÊÊÊÊÊÊÊ MemAllocPtr, MemAlloc

Per-page overhead, all APIsÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 44ÊÊÊÊÊÊÊÊÊ 88

Minimum page sizeÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 64KÊÊÊÊÊÊ 64KÊÊÊÊÊÊ MemPoolSetPageSize

Maximum page sizeÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 64KÊÊÊÊÊÊ 64KÊÊÊÊÊÊ MemPoolSetPageSize

Size of empty memory poolÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ 64KÊÊÊÊÊÊ 64KÊÊÊÊÊÊ MemPoolInit[FS]

Default error handling for HP-UX

The default error handler in the HP-UX version of SmartHeap prompts with ãAbort, Ignore [, Retry]ä to stderr.Ê Retry is present only for recoverable errors.Ê

If you type:

á ãaä for Abort, SmartHeap calls the abort function, which terminates the application.Ê

á ãiä for Ignore, the SmartHeap function that reported the error returns with an error return value.Ê

á ãrä for Retry, SmartHeap retries the operation (for example, attempts a memory allocation again).