How to allocate memory which is 2^k aligned

Hi,
can somebody help me figure out how can I make write a function
which inturn uses malloc routine to allocate memory which is 2^k
aligned?

The condition is such that there should not be any memory leak and it
should not also waste memory.

Thanks,
Divick

Divick wrote:I think you're looking to calculate the next power of 2 from a number.
Given that you need to allocate N bytes, the N is not necessarily any
power of 2, so you need to find the next power of 2 that is not smaller
than N. You can do it in a loop.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

Divick posted:

"malloc" does this already -- it allocates memory whose alignment is strict
enough to satisfy the alignment of any kind of object.

You might like "aligned_storage" aswell (Google for it), although it
allocates on the stack rather than on the heap.

--

Frederick Gotham

Divick wrote:For more or less arbitrary values of k, the only way to do it is to
allocate a block that's sure to be large enough (i.e. 2^(k+1)) and pick
off an address within that block that meets your alignment requirements.

For values of k such that 2^k is the alignment of some type (typically
2, 4, 8, or 16 bytes), malloc returns a pointer that's suitably aligned
for any type, so you don't need to do anything special.

--
-- Pete

Author of "The Standard C++ Library Extensions: a Tutorial and
Reference." For more information about this book, see
www.petebecker.com/tr1book.

Frederick Gotham wrote:But malloc only satisfies the alignment requirements of the
implementation - e.g. hardware alignment requirements. The application
may have stricter requirements depending on what you want to do.

Regards,
Bart.

For more or less arbitrary values of k, the only way to do it is toSince I have constraint that I have to use malloc in my application and
I also want that once that memory is passed to me I should be able to
free the memory. Thus simply returning the offset will not solve my
purpose as once the application passes the same location to me , I will
pass the location to free and free wouldn't know that it was actually
allocated. See the code below

The problem with the code below is that free does not know how to free
the memory because I pass it the address which malloc didn't return.
The other problem is that lot of memory gets wasted. Is there a way to
overcome such problems?

#define ALIGNMENT_K 3

void * allocate_memory(size_t size)
{
//allocate memory so that at least there is an address which is
2^k aligned
char * mem = (char *)malloc(size + 2^ALIGNMENT_K);

//calculate offset and if it is not 2^k aligned then
//increment the pointer till it is.
while( (*mem & ~(0xffffffff << ALIGNMENT_K)) != 0 )
{
mem++;
}

return (void *)mem;
}

//If the mem pointer is not the same that malloc returned then it
//is a problem and free won't be able to free the memory
void free_memory(void * mem)
{
free(mem);
}

I hope I am clear in my question and intent.

Thanks,
Divick

But malloc only satisfies the alignment requirements of theYup exactly that is what my problem is. Thanks for asserting in a clear
way.

Divick

Divick wrote:There is no portable way. But why do you want a specific alignment in
the first place? The reason for this must be for some nonportable
reason and the platform your program is to run on likely will support
such a call - or at least just waste virtual (not real) memory.

/Peter

Divick <divick.kishore@gmail.comwrote:
It seems you have to write your own version of free() that contains
a map between the original values returned by malloc() and
the aligned values passed to the application.

This should be reasonably easy using a std::map.

Steve

Divick wrote:you could try something like

template <std::size_t Size, std::size_t Align>
struct aligned_str
{
boost::aligned_storage<Size, Alignaligned_;
};

typedef aligned_str<Size, Alignmy_aligned;
my_aligned * p = static_cast<my_aligned*>(malloc(sizeof(my_aligned) );
// and use
p->aligned_.address();

dasjotre wrote:
<snip>

sorry, I was beeing lazy ...

template <std::size_t Size, std::size_t Align>
class aligned_str
{
boost::aligned_storage<Size, Alignaligned_;

public:

void * operator new(std::size_t)
{
typedef aligned_str<Size, AllignT;
return malloc(sizeof(T));
}

void operator delete(void *p)
{
free(p);
}

void * address(){ return aligned_.address(); }
};

typedef aligned_str<Size, Alignmy_aligned;
::std::auto_ptr<my_alignedp (new my_aligned);
// and use
p->address();

dasjotre wrote:I don't think that will work. aligned_storage is basically a union of a
char array of the appropriate size and some other type with suitable
alignment. For TR1 we made it clear that, essentially, the value of
Align must be a value that is the alignment of some type. It doesn't
handle arbitrary alignment values.

--

-- Pete

Author of "The Standard C++ Library Extensions: a Tutorial and Reference."
For more information about this book, see www.petebecker.com/tr1book.