# posix_memalign

## PROLOG



           This manual page is part of the POSIX Programmer's Manual.  The
           Linux implementation of this interface may differ (consult the
           corresponding Linux manual page for details of Linux behavior), or
           the interface may not be implemented on Linux.
    


## NAME



           posix_memalign — aligned memory allocation (**ADVANCED REALTIME**)
    


## SYNOPSIS



           #include <stdlib.h>
    
           int posix_memalign(void **_memptr_ , size_t _alignment_ , size_t _size_);
    


## DESCRIPTION



           The _posix_memalign_() function shall allocate _size_ bytes aligned on
           a boundary specified by _alignment_ , and shall return a pointer to
           the allocated memory in _memptr_.  The value of _alignment_ shall be a
           power of two multiple of _sizeof_(**void ***).
    
           Upon successful completion, the value pointed to by _memptr_ shall
           be a multiple of _alignment_.
    
           If the size of the space requested is 0, the behavior is
           implementation-defined: either a null pointer shall be returned in
           _memptr_ , or the behavior shall be as if the size were some non-zero
           value, except that the behavior is undefined if the the value
           returned in _memptr_ is used to access an object.
    
           The _free_() function shall deallocate memory that has previously
           been allocated by _posix_memalign_().
    


## RETURN VALUE



           Upon successful completion, _posix_memalign_() shall return zero;
           otherwise, an error number shall be returned to indicate the error
           and the contents of _memptr_ shall either be left unmodified or be
           set to a null pointer.
    
           If _size_ is 0, either:
    
            *  _posix_memalign_() shall not attempt to allocate any space, in
               which case either an implementation-defined error number shall
               be returned, or zero shall be returned with a null pointer
               returned in _memptr_ , or
    
            *  _posix_memalign_() shall attempt to allocate some space and, if
               the allocation succeeds, zero shall be returned and a pointer
               to the allocated space shall be returned in _memptr_.  The
               application shall ensure that the pointer is not used to
               access an object.
    


## ERRORS



           The _posix_memalign_() function shall fail if:
    
           **EINVAL** The value of the alignment parameter is not a power of two
                  multiple of _sizeof_(**void ***).
    
           **ENOMEM** There is insufficient memory available with the requested
                  alignment.
    
           _The following sections are informative._
    


## EXAMPLES



           The following example shows how applications can obtain consistent
           behavior on error by setting *_memptr_ to be a null pointer before
           calling _posix_memalign_().
    
               void *ptr = NULL;
               ...
               //do some work, which might goto error
               if (posix_memalign(&ptr, align, size))
                   goto error;
    
               //do some more work, which might goto error
               ...
               error:
                   free(ptr);
                   //more cleanup;
    


## APPLICATION USAGE



           The _posix_memalign_() function is part of the Advisory Information
           option and need not be provided on all implementations.
    


## RATIONALE



           None.
    


## FUTURE DIRECTIONS



           None.
    


* * *