Classes | |
class | ACE_bad_alloc_class |
Functions | |
Efficiently compute aligned pointers to powers of 2 boundaries. | |
unsigned int | ACE_align_binary (unsigned int ptr, unsigned int alignment) |
Return the next integer aligned to a required boundary. | |
uintptr_t | ACE_align_binary (uintptr_t ptr, uintptr_t alignment) |
Return the next integer aligned to a required boundary. | |
char * | ACE_ptr_align_binary (char const *ptr, unsigned int alignment) |
Return the next address aligned to a required boundary. | |
char * | ACE_ptr_align_binary (unsigned char const *ptr, unsigned int alignment) |
Return the next address aligned to a required boundary. | |
char * | ACE_ptr_align_binary (char const *ptr, uintptr_t alignment) |
Return the next address aligned to a required boundary. | |
char * | ACE_ptr_align_binary (unsigned char const *ptr, uintptr_t alignment) |
Return the next address aligned to a required boundary. | |
Variables | |
ACE_BEGIN_VERSIONED_NAMESPACE_DECL typedef char * | ACE_MALLOC_T |
uintptr_t ACE_align_binary | ( | uintptr_t | ptr, | |
uintptr_t | alignment | |||
) | [inline] |
Return the next integer aligned to a required boundary.
Efficiently align "value" up to "alignment", knowing that all such boundaries are binary powers and that we're using two's complement arithmetic.
Since the alignment is a power of two its binary representation is:
alignment = 0...010...0
hence
alignment - 1 = 0...001...1 = T1
so the complement is:
~(alignment - 1) = 1...110...0 = T2
Notice that there is a multiple of alignment in the range [
,
+ T1], also notice that if
X = (
+ T1 ) & T2
then
<= X <=
+ T1
because the & operator only changes the last bits, and since X is a multiple of alignment (its last bits are zero) we have found the multiple we wanted.
ptr | the base pointer | |
alignment | the required alignment |
unsigned int ACE_align_binary | ( | unsigned int | ptr, | |
unsigned int | alignment | |||
) | [inline] |
Return the next integer aligned to a required boundary.
Efficiently align "value" up to "alignment", knowing that all such boundaries are binary powers and that we're using two's complement arithmetic.
Since the alignment is a power of two its binary representation is:
alignment = 0...010...0
hence
alignment - 1 = 0...001...1 = T1
so the complement is:
~(alignment - 1) = 1...110...0 = T2
Notice that there is a multiple of alignment in the range [
,
+ T1], also notice that if
X = (
+ T1 ) & T2
then
<= X <=
+ T1
because the & operator only changes the last bits, and since X is a multiple of alignment (its last bits are zero) we have found the multiple we wanted.
ptr | the base pointer | |
alignment | the required alignment |
char* ACE_ptr_align_binary | ( | unsigned char const * | ptr, | |
uintptr_t | alignment | |||
) | [inline] |
Return the next address aligned to a required boundary.
char* ACE_ptr_align_binary | ( | char const * | ptr, | |
uintptr_t | alignment | |||
) | [inline] |
Return the next address aligned to a required boundary.
char* ACE_ptr_align_binary | ( | unsigned char const * | ptr, | |
unsigned int | alignment | |||
) | [inline] |
Return the next address aligned to a required boundary.
char* ACE_ptr_align_binary | ( | char const * | ptr, | |
unsigned int | alignment | |||
) | [inline] |
Return the next address aligned to a required boundary.
typedef void * ACE_MALLOC_T |