(Cat? OR feline) AND NOT dog?
Cat? W/5 behavior
(Cat? OR feline) AND traits
Cat AND charact*

This guide provides a more detailed description of the syntax that is supported along with examples.

This search box also supports the look-up of an IP.com Digital Signature (also referred to as Fingerprint); enter the 72-, 48-, or 32-character code to retrieve details of the associated file or submission.

Concept Search - What can I type?

For a concept search, you can enter phrases, sentences, or full paragraphs in English. For example, copy and paste the abstract of a patent application or paragraphs from an article.

Concept search eliminates the need for complex Boolean syntax to inform retrieval. Our Semantic Gist engine uses advanced cognitive semantic analysis to extract the meaning of data. This reduces the chances of missing valuable information, that may result from traditional keyword searching.

Transparent Pooling in User Controlled Heaps

Publishing Venue

IBM

Related People

Benayon, JW: AUTHOR

Abstract

Most memory management algorithms treat all sizes equally with respect to allocation policies. In practice, applications tend to allocate objects of many sizes, yet few sizes will dominate all the allocations required for the program. Therefore, if the user can indicate the range of preferred sizes to the memory allocator for pooling, performance can be greatly improved during allocation and deallocation of objects, thus resulting in faster execution and reduced page swapping.

Country

United States

Language

English (United States)

This text was extracted from an ASCII text file.

This is the abbreviated version, containing approximately
49% of the total text.

Transparent Pooling in User Controlled Heaps

Most memory
management algorithms treat all sizes equally with
respect to allocation policies. In
practice, applications tend to
allocate objects of many sizes, yet few sizes will dominate all the
allocations required for the program.
Therefore, if the user can
indicate the range of preferred sizes to the memory allocator for
pooling, performance can be greatly improved during allocation and
deallocation of objects, thus resulting in faster execution and
reduced page swapping.

In most
deallocation algorithms, an attempt is made to coalesce
a freed object with other objects in the free heap, resulting in an
expensive operation with respect to processing and page swapping.
The advantage of this coalescing is that the heap will always reuse
the freed object to satisfy future
smaller and same size requests,
thus minimizing the working set
size. The disadvantage is clearly
seen when an application repetitively allocates and deallocates a
common size such that the coalescing is immediately split in a
subsequent heap operation. It is for
this type of application that a
substantial improvement in speed is gained with transparent pooling
in multiple heaps.

In the IBM*
VisualAge* C++ product for OS/2* and Windows** NT
platforms, support for user controlled multiple heaps is provided.
This allows the user to provide a call-back interface when
expanding/shrinking the heap and direct the base malloc routines to
allocate from this private heap. Through
the usage of the callback
routines, the user is able to provide
any type of memory such as
tiled, shared, non-shared, stack, static, etc. to the allocator for
future heap operations. The allocator is
not aware of the
accessibility to the storage by other processes, thus it is unable to
allocate memory from the system directly
for internal structures and
must rely on the callbacks routines to acquire memory.

The solution
to the above performance problem is for the user
to supply a range of object sizes that an allocator should provide
optimal performance with respect to speed and page swapping. This is
accomplished via a function interface that accepts a heap handle to a
user defined heap, minimum size, maximum size, growth size, and flags
as follows:
int _upool(Heap_t uh, size_t min_sz,
size_t max_sz,
size_t incr_qty, size_t
flags)

The memory
allocator will utilize the range of sizes during an
allocation to acquire storage from a faster data structure than that
used for other sizes. Similarly. a deallocation will place the
object in this new structure for future allocations thus preventing
an unnecessary coalesce. The incr_qty
parameter is required so the
pool will create 'incr_qty' items of a particular size when the pool
is empty and needs to be expanded. The
flags parameter allows the
user to provide further options to the allocator for performance...