Sets a memory management strategy.
Restriction: These tunables are supported for native COBOL only.
Syntax:
>>-----set memory_strategy=---strategy-specification------><
Parameters:
strategy-specification
|
A numeric value representing one or more of the following flags (see
Comments for information about valid combinations):
- 0x00000001
- Check bytes strategy: prepend and append check bytes to each memory allocation
- 0x00000002
- Check freed memory strategy: monitor for subsequent corruption the last
n memory blocks freed, where
n is the current value set using the memory_free_check_size run-time tunable
- 0x00000004
- Reuse strategy: allow freed memory being monitored for corruption to be used to satisfy allocation requests
- 0x40000000
- Compatibility strategy: maintain compatibility with previous versions of the run-time system
- 0x80000000
- Validate strategy: validate memory each time an allocation or free operation occurs
|
Properties:
Default:
|
0x00000001
|
IDE equivalent:
|
None
|
Comments:
You can use this tunable to enable a process to be executed with one or more memory management strategies in place. For example, to specify that each memory allocation made by the run-time system is to have check bytes prepended and appended, and that each time an allocation or free operation takes place memory is to be validated, you would set the tunable as follows:
Only certain combinations of strategies are valid:
When the check bytes memory management strategy is in place, and the run-time system receives a request to free a memory block, the run-time system checks that the check bytes have not been corrupted, and then releases the memory. A corruption occurs when a program has written past the end of another memory block into the header of this one, or a program has written past the end of this memory block. If the run-time system detects a corruption, it issues run-time system error COBRT252 indicating the memory block address and type of memory that has been corrupted, for example:
When the check freed memory strategy is in place, and the run-time system receives a request to free a memory block, the run-time system does not release the memory, but instead:
You should use the check freed memory strategy strategy with caution as it can lead to memory fragmentation and a significantly larger memory footprint for the process than would normally be expected.
You can use the reuse memory management strategy in conjunction with the check freed memory strategy to allow freed memory to be used to satisfy new allocation requests. When the reuse strategy is in effect and the run-time system needs to allocate a new block of memory, it first checks whether an area of freed memory will satisfy the allocation request. An allocation request will be satisfied from freed memory only if the size and type of the freed memory exactly match the size and type of the allocation request. When an allocation request is satisfied from freed memory, the run-time system first validates the contents of the freed memory. If the validation fails (that is, the memory does not contain the expected check value), the run-time system issues run-time system error COBRT252.
The compatibility memory strategy is provided to give compatibility with the memory management provided in earlier versions of the run-time system. If this strategy is specified, all other strategies except validation are ignored. This strategy does not perform any memory validation or tracking, and silently ignores any memory chaining errors it encounters if an attempt is made to free a memory block more than once.
The validation memory management strategy causes all memory allocations previously made by the run-time system using the check bytes memory management strategy and all freed memory to be validated each time the run-time system is requested to perform a memory allocate or free operation. Additionally, if the operating system allows it, an operating-system memory heap validation check is performed. You should use this strategy with caution since it will lead to a major performance degradation in those applications that perform a large number of memory allocate and free operations.