Format
#include <umalloc.h> void _uheap_check(Heap_t heap);
Language Level: Extension
_uheap_check checks all memory blocks in the heap you
specify that have been allocated or freed using the heap-specific
debug versions of the memory management functions
(_debug_ucalloc, _debug_umalloc, and so on). _uheap_check checks
that your program has not overwritten freed memory blocks or
memory outside the bounds of allocated blocks.
_uheap_check works just like _heap_check, except that you specify the heap to check; _heap_check always checks the default heap.
When you call a heap-specific debug memory management function (such as _debug_umalloc), it calls _uheap_check automatically. You can also call _uheap_check explicitly. Place calls to _uheap_check throughout your code, especially in areas that you suspect have memory problems.
Calling _uheap_check frequently can increase your program's memory requirements and decrease its execution speed (explicitly or, for OS/2, through the tiled debug memory functions). To reduce the overhead of heap-checking, you can use the CPP_HEAP_SKIP environment variable to control how often the functions check the heap. For example:
SET CPP_HEAP_SKIP=10
specifies that every tenth call to any debug memory function (regardless of the type or heap) checks the heap. Explicit calls to _uheap_check are always performed.
To use _uheap_check and the debug versions of the memory management functions, specify the debug memory (/Tm) compiler option.
Note: The /Tm option maps all calls to memory management functions (including heap-specific versions) to their debug counterparts. To prevent a call from being mapped, parenthesize the function name.
Return Value
There is no return value.
Example
This example creates a heap and allocates memory from
it. It then calls _uheap_check to check the the memory in the
heap.
Note: You must compile this example with the /Tm option to map the _ucalloc calls to _debug_ucalloc.
#include <stdlib.h> #include <stdio.h> #include <umalloc.h> #include <string.h>
int main(void)
{
Heap_t myheap;
char *ptr;
/* Use default heap as user heap */ myheap = _udefault(NULL);
if (NULL == (ptr = (char*)_ucalloc(myheap, 100, 1))) {
puts("Cannot allocate memory from user heap.");
exit(EXIT_FAILURE);
}
memset(ptr, 'x', 105); /* overwrite storage that was not allocated */
_uheap_check(myheap);
free(ptr); return 0;
/****************************************************************************
The output should be similar to :
End of allocated object 0x00073890 was overwritten at 0x000738f4.
The first eight bytes of the memory block (in hex) are: 7878787878787878.
This memory block was (re)allocated at line number 13 in _uheap_check.c.
Heap state was valid at line 13 of _uheap_check.c.
Memory error detected at line 19 of _uheap_check.c.
****************************************************************************/
}
![]()
Managing Memory
with Multiple Heaps
Memory Management
![]()
![]()
_heap_check -- Validate Default Memory Heap
![]()
_debug_ucalloc -- Allocate and Initialize
Memory from User Heap
![]()
_debug_umalloc -- Reserve Memory Blocks from
User Heap
![]()
_debug_realloc -- Reallocate Memory Block
![]()
_debug_free -- Release Memory
![]()
_uheapchk -- Validate Memory Heap
![]()
_uheapset -- Validate and Set Memory Heap
![]()
_uheap_walk -- Return Information about
Memory Heap
![]()
<umalloc.h>
/Tm compiler option