View source for r6.0.0:Lfds600 abstraction aligned malloc

{{DISPLAYTITLE:r6.0.0:lfds600_abstraction_aligned_malloc}}
==Source Files==
 /liblfds600/src/lfds600_abstraction/lfds600_abstraction_aligned_malloc.c
 /liblfds600/inc/liblfds600.h

==Prototype==
 void *lfds600_abstraction_aligned_malloc( size_t size, size_t align_in_bytes );

==Parameters==
''size_t size''
: Number of bytes to allocate.

''size_t align_in_bytes''
: Allocation alignment.

==Return Value==
Pointer to the allocated memory.

==Notes==
Typically platforms impose alignment restrictions on variables used in atomic instructions.  ANSI C does not provide a malloc capable of honouring alignment requests.  Major operating systems (Windows, Linux, Solaris, etc) do.

On such platforms implementation of this abstraction function is trivial since it is just a call to the operating system provided function.

On embedded platforms, there will be no operating system to provide such a function.

In this environment, the usual solution is to use normal malloc() to obtain the requested amount of memory plus a little more, such that we can return to the user a pointer to memory which begins at an aligned address.  We also need to store a flag, just above the pointer we return to the user, which indicates, when we call ''[[r6.0.0:lfds600_abstraction_aligned_free|lfds600_abstraction_aligned_free]]'', how much we have to subtract from the pointer the user gave us to get back to the actual original pointer returned by malloc().

==Examples==
Under POSIX 6.00 and later, there is a function to provide aligned memory allocation called ''[http://www.opengroup.org/onlinepubs/000095399/functions/posix_memalign.html posix_memalign]'', which has the following prototype;

 int posix_memalign( void **memptr, size_t alignment, size_t size );

As such, the implementation of ''lfds600_abstraction_aligned_malloc'' for a system providing POSIX 6.00 or greater looks like this;

 #if (_XOPEN_SOURCE >= 600)
 
   /* TRD : any OS on any CPU with any compiler with POSIX 6.00 or better
 
            _XOPEN_SOURCE  is actually set by the user, not by the compiler
                           it is the way the user signals to the compiler what
                           level of POSIX should be available
                           (it assumes of course the compiler has support for the given level of POSIX requested)
   */
 
   void *lfds600_abstraction_aligned_malloc( size_t size, size_t align_in_bytes )
   {
     int
       rv;
 
     void
       *memory;
 
     rv = posix_memalign( &memory, align_in_bytes, size );
 
     // TRD : posix_memalign returns 0 on success, docs do not say *memory == NULL on fail
     if( rv != 0 )
       memory = NULL;
 
     return( memory );
   }
 
 #endif

==See Also==
* [[r6.0.0:lfds600_abstraction (liblfds)|lfds600_abstraction (liblfds)]]
* [[r6.0.0:lfds600_abstraction_aligned_free|lfds600_abstraction_aligned_free]]