PMEMCTO_MALLOC(3)

NAME

pmemcto_malloc, pmemcto_free, pmemcto_calloc, pmemcto_realloc - allocate and free persistent memory

SYNOPSIS

    #include <libpmemcto.h>

    void *pmemcto_malloc(PMEMctopool *pcp, size_t size);
    void pmemcto_free(PMEMctopool *pcp, void *ptr);
    void *pmemcto_calloc(PMEMctopool *pcp, size_t nmemb, size_t size);
    void *pmemcto_realloc(PMEMctopool *pcp, void *ptr, size_t size);

DESCRIPTION

The pmemcto_malloc() function provides the same semantics as malloc(3), but operates on the memory pool pcp instead of the process heap supplied by the system. It allocates size bytes and returns a pointer to the allocated memory. The memory is not initialized. If size is 0, then pmemcto_malloc() returns either NULL, or a unique pointer value that can later be successfully passed to pmemcto_free().

The pmemcto_free() function provides the same semantics as free(3), but operates on the memory pool pcp instead of the process heap supplied by the system. It frees the memory space pointed to by ptr, which must have been returned by a previous call to pmemcto_malloc(), pmemcto_calloc() or pmemcto_realloc() for the same pool of memory. Undefined behavior occurs if frees do not correspond to allocated memory from the same memory pool. If ptr is NULL, no operation is performed.

The pmemcto_calloc() function provides the same semantics as calloc(3), but operates on the memory pool pcp instead of the process heap supplied by the system. It allocates memory for an array of nmemb elements of size bytes each and returns a pointer to the allocated memory. The memory is set to zero. If nmemb or size is 0, then pmemcto_calloc() returns either NULL, or a unique pointer value that can later be successfully passed to pmemcto_free().

The pmemcto_realloc() function provides the same semantics as realloc(3), but operates on the memory pool pcp instead of the process heap supplied by the system. It changes the size of the memory block pointed to by ptr to size bytes. The contents will be unchanged in the range from the start of the region up to the minimum of the old and new sizes. If the new size is larger than the old size, the added memory will not be initialized. If ptr is NULL, then the call is equivalent to pmemcto_malloc(pcp, size), for all values of size; if size is equal to zero and ptr is not NULL, then the call is equivalent to pmemcto_free(pcp, ptr). Unless ptr is NULL, it must have been returned by an earlier call to pmemcto_malloc(), pmemcto_calloc(), pmemcto_realloc() or pmemcto_aligned_alloc(3). If the area pointed to was moved, a pmemcto_free(pcp, ptr) is done.

RETURN VALUE

On success, pmemcto_malloc() and pmemcto_calloc() functions return a pointer to the allocated memory. If the allocation request cannot be satisfied, a NULL pointer is returned and errno is set appropriately.

The pmemcto_free() function returns no value.

On success, pmemcto_realloc() function returns a pointer to the newly allocated memory, or NULL if it is unable to satisfy the allocation request. If size was equal to 0, either NULL or a pointer suitable to be passed to pmemcto_free() is returned. If pmemcto_realloc() fails the original block is left untouched; it is not freed or moved.

ERRORS

ENOMEM Insufficient memory available to satisfy allocation request.

NOTES

Unlike the normal malloc(), which asks the system for additional memory when it runs out, libpmemcto(7) allocates the size it is told to and never attempts to grow or shrink that memory pool.

SEE ALSO

jemalloc(3), malloc(3), pmemcto_aligned_alloc(3), libpmemcto(7) and <http://pmem.io>