Message-ID: <3EF7DD98.B4CC7241@yahoo.com>
Date: Tue, 24 Jun 2003 01:11:52 -0400
From: CBFalconer <cbfalconer AT yahoo DOT com>
Organization: Ched Research
X-Mailer: Mozilla 4.75 [en] (Win98; U)
X-Accept-Language: en
MIME-Version: 1.0
To: djgpp-workers AT delorie DOT com
Subject: Re: memalign hooks (was: LIBM patch for GCC 3.3 - math changes)
References: <20030623061004 DOT 0164E33DBBB AT iceage DOT anubex DOT com>
Content-Type: text/plain; charset=us-ascii
Content-Transfer-Encoding: 7bit
Reply-To: djgpp-workers AT delorie DOT com

Tim Van Holder wrote:
> 
... snip ...
> 
> Below is what the glibc 2.3.2 (Red Hat 8.0) has to say; note that it
> does not say what it does if BOUNDARY is NOT a power of 2.
> I could check the glibc sources if necessary.
> 
> Allocating Aligned Memory Blocks
> ................................
> 
>    The address of a block returned by `malloc' or `realloc' in the GNU
> system is always a multiple of eight (or sixteen on 64-bit systems).
> If you need a block whose address is a multiple of a higher power of
> two than that, use `memalign', `posix_memalign', or `valloc'.
> `memalign' is declared in `malloc.h' and `posix_memalign' is declared
> in `stdlib.h'.
> 
>    With the GNU library, you can use `free' to free the blocks that
> `memalign', `posix_memalign', and `valloc' return.  That does not work
> in BSD, however--BSD does not provide any way to free such blocks.
> 
>  - Function: void * memalign (size_t BOUNDARY, size_t SIZE)
>      The `memalign' function allocates a block of SIZE bytes whose
>      address is a multiple of BOUNDARY.  The BOUNDARY must be a power
>      of two!  The function `memalign' works by allocating a somewhat
>      larger block, and then returning an address within the block that
>      is on the specified boundary.
> 
>  - Function: int posix_memalign (void **MEMPTR, size_t ALIGNMENT,
>           size_t SIZE)
>      The `posix_memalign' function is similar to the `memalign'
>      function in that it returns a buffer of SIZE bytes aligned to a
>      multiple of ALIGNMENT.  But it adds one requirement to the
>      parameter ALIGNMENT: the value must be a power of two multiple of
>      `sizeof (void *)'.
> 
>      If the function succeeds in allocation memory a pointer to the
>      allocated memory is returned in `*MEMPTR' and the return value is
>      zero.  Otherwise the function returns an error value indicating
>      the problem.
> 
>      This function was introduced in POSIX 1003.1d.

Those don't agree with the memalign prototype I was fed, and
frankly I think they are seriously flawed.  For reference:

   void *memalign(size_t amount, size_t alignment);

which is logically equivalent to malloc, except it places
constraints on the returned pointer and requires alignment to be a
power of 2.  If the returned pointer is later realloced the
alignment restrictions may disappear.

-- 
Chuck F (cbfalconer AT yahoo DOT com) (cbfalconer AT worldnet DOT att DOT net)
   Available for consulting/temporary embedded and systems.
   <http://cbfalconer.home.att.net>  USE worldnet address!